tuwunel_service/users/
browser_session.rs1use std::time::Duration;
9
10use futures::TryFutureExt;
11use ruma::UserId;
12use tuwunel_core::{
13 Result, debug, implement,
14 utils::{
15 BoolExt, hash::sha256::hash as sha256, millis_since_unix_epoch, random_string,
16 result::NotFound, stream::TryReadyExt, time::now,
17 },
18 warn,
19};
20use tuwunel_database::{Deserialized, Interfix};
21
22const TTL_MAX: u64 = 60 * 60 * 24 * 90;
27
28const SECRET_LENGTH: usize = 32;
29
30pub struct BrowserSession {
35 pub token: String,
37
38 pub lifetime: Duration,
40}
41
42#[implement(super::Service)]
54#[tracing::instrument(level = "debug", skip(self, verified, replaces))]
55pub async fn create_browser_session(
56 &self,
57 user_id: &UserId,
58 verified: Option<&str>,
59 replaces: Option<&str>,
60) -> Option<BrowserSession> {
61 if let Some((owner, secret)) = replaces.and_then(parse_token) {
62 self.remove_browser_session(owner, secret);
63 }
64
65 let verified = verified?;
66 let _password_guard = self.changing_password.lock(user_id).await;
67
68 self.db
69 .userid_password
70 .get(user_id)
71 .map_ok(|current| &*current == verified.as_bytes())
72 .await
73 .inspect_err(
74 |error| warn!(%user_id, %error, "Unreadable password, starting no browser session"),
75 )
76 .ok()?
77 .and_then(|| self.mint_browser_session(user_id))
78}
79
80#[implement(super::Service)]
85pub(super) fn mint_browser_session(&self, user_id: &UserId) -> Option<BrowserSession> {
86 let lifetime = self.browser_session_ttl()?;
87 let secret = random_string(SECRET_LENGTH);
88 let digest = sha256(&secret);
89
90 self.db
91 .useridbrowsersession_createdat
92 .put((user_id, digest.as_slice()), millis_since_unix_epoch());
93
94 Some(BrowserSession {
95 token: format!("{secret}.{user_id}"),
96 lifetime,
97 })
98}
99
100#[implement(super::Service)]
106#[tracing::instrument(level = "debug", skip_all)]
107pub async fn find_browser_session<'a>(&self, token: &'a str) -> Option<&'a UserId> {
108 let lifetime = self.browser_session_ttl()?;
109 let Some((user_id, secret)) = parse_token(token) else {
110 debug!("Malformed browser session token, ignoring");
111 return None;
112 };
113
114 let digest = sha256(secret);
115
116 let created_at: u64 = self
117 .db
118 .useridbrowsersession_createdat
119 .qry(&(user_id, digest.as_slice()))
120 .await
121 .deserialized()
122 .present()
123 .inspect_err(|error| warn!(%user_id, %error, "Unreadable browser session, ignoring"))
124 .ok()
125 .flatten()?;
126
127 let age = now().saturating_sub(Duration::from_millis(created_at));
128
129 age.lt(&lifetime).then_some(user_id)
130}
131
132#[implement(super::Service)]
137pub fn end_browser_session(&self, token: &str, user_id: &UserId) {
138 if let Some((owner, secret)) = parse_token(token).filter(|(owner, _)| *owner == user_id) {
139 self.remove_browser_session(owner, secret);
140 }
141}
142
143#[implement(super::Service)]
150#[tracing::instrument(level = "debug", skip(self))]
151pub async fn end_browser_sessions(&self, user_id: &UserId) -> Result {
152 let sessions = &self.db.useridbrowsersession_createdat;
153
154 sessions
155 .keys_prefix_raw(&(user_id, Interfix))
156 .ready_try_for_each(|key| {
157 sessions.remove(key);
158
159 Ok(())
160 })
161 .await
162}
163
164fn parse_token(token: &str) -> Option<(&UserId, &str)> {
165 let (secret, user_id) = token
166 .split_once('.')
167 .filter(|(secret, _)| secret.len().eq(&SECRET_LENGTH))?;
168
169 <&UserId>::try_from(user_id)
170 .ok()
171 .map(|user_id| (user_id, secret))
172}
173
174#[implement(super::Service)]
175fn remove_browser_session(&self, user_id: &UserId, secret: &str) {
176 let digest = sha256(secret);
177
178 self.db
179 .useridbrowsersession_createdat
180 .del((user_id, digest.as_slice()));
181}
182
183#[implement(super::Service)]
184fn browser_session_ttl(&self) -> Option<Duration> {
185 let ttl = self
186 .services
187 .config
188 .authentication
189 .oidc
190 .browser_session_ttl
191 .min(TTL_MAX);
192
193 ttl.gt(&0).then_some(Duration::from_secs(ttl))
194}