1use time::{Duration, OffsetDateTime};
4
5use serde::Serialize;
6
7use crate::context::AuthContext;
8use crate::cookies::{
9 delete_session_cookie, get_cookie_cache, get_session_cookie, parse_cookies, set_cookie_cache,
10 set_session_cookie, verify_cookie_value, Cookie, CookieCachePayload, CookieOptions,
11 SessionCookieOptions,
12};
13use crate::db::{DbAdapter, Session, User};
14use crate::error::OpenAuthError;
15use crate::session::SessionStore;
16use crate::user::DbUserStore;
17
18#[derive(Debug, Clone, PartialEq, Eq)]
19pub struct GetSessionInput {
20 pub cookie_header: String,
21 pub disable_cookie_cache: bool,
22 pub disable_refresh: bool,
23 pub defer_refresh: bool,
24}
25
26impl GetSessionInput {
27 pub fn new(cookie_header: impl Into<String>) -> Self {
28 Self {
29 cookie_header: cookie_header.into(),
30 disable_cookie_cache: false,
31 disable_refresh: false,
32 defer_refresh: false,
33 }
34 }
35
36 #[must_use]
37 pub fn disable_cookie_cache(mut self) -> Self {
38 self.disable_cookie_cache = true;
39 self
40 }
41
42 #[must_use]
43 pub fn disable_refresh(mut self) -> Self {
44 self.disable_refresh = true;
45 self
46 }
47
48 #[must_use]
49 pub fn defer_refresh(mut self) -> Self {
50 self.defer_refresh = true;
51 self
52 }
53}
54
55#[derive(Debug, Clone, PartialEq, Eq)]
56pub struct GetSessionResult {
57 pub session: Option<Session>,
58 pub user: Option<User>,
59 pub cookies: Vec<Cookie>,
60 pub needs_refresh: bool,
61}
62
63#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
64pub struct SignOutResult {
65 pub success: bool,
66 #[serde(skip)]
67 pub cookies: Vec<Cookie>,
68}
69
70#[derive(Clone, Copy)]
71pub struct SessionAuth<'a> {
72 adapter: &'a dyn DbAdapter,
73 context: &'a AuthContext,
74}
75
76impl<'a> SessionAuth<'a> {
77 pub fn new(adapter: &'a dyn DbAdapter, context: &'a AuthContext) -> Self {
78 Self { adapter, context }
79 }
80
81 pub async fn get_session(
82 &self,
83 input: GetSessionInput,
84 ) -> Result<Option<GetSessionResult>, OpenAuthError> {
85 let signed_token =
86 match get_session_cookie(&input.cookie_header, cookie_prefix(self.context), None) {
87 Some(value) => value,
88 None => return Ok(None),
89 };
90 let Some(token) = verify_cookie_value(&signed_token, &self.context.secret)? else {
91 return Ok(Some(unauthenticated(delete_session_cookie(
92 &self.context.auth_cookies,
93 &input.cookie_header,
94 false,
95 ))));
96 };
97
98 if self.context.options.session.cookie_cache.enabled && !input.disable_cookie_cache {
99 if let Some(cached) = get_cookie_cache::<Session, User>(
100 &input.cookie_header,
101 &self.context.auth_cookies.session_data.name,
102 &self.context.secret,
103 self.context.options.session.cookie_cache.strategy,
104 self.context.options.session.cookie_cache.version.as_deref(),
105 )? {
106 if cached.session.expires_at > OffsetDateTime::now_utc() {
107 return Ok(Some(authenticated(
108 cached.session,
109 cached.user,
110 Vec::new(),
111 false,
112 )));
113 }
114 }
115 }
116
117 let session_store = SessionStore::new(self.adapter, self.context);
118 let Some(mut session) = session_store.find_session(&token).await? else {
119 return Ok(Some(unauthenticated(delete_session_cookie(
120 &self.context.auth_cookies,
121 &input.cookie_header,
122 false,
123 ))));
124 };
125
126 let user_store = DbUserStore::new(self.adapter);
127 let Some(user) = user_store.find_user_by_id(&session.user_id).await? else {
128 return Ok(Some(unauthenticated(delete_session_cookie(
129 &self.context.auth_cookies,
130 &input.cookie_header,
131 false,
132 ))));
133 };
134
135 let dont_remember = signed_cookie(
136 &input.cookie_header,
137 &self.context.auth_cookies.dont_remember_token.name,
138 &self.context.secret,
139 )?
140 .is_some();
141 let needs_refresh = !dont_remember
142 && !input.disable_refresh
143 && !self.context.options.session.disable_session_refresh
144 && session_needs_refresh(&session, self.context);
145 let mut cookies = Vec::new();
146
147 if needs_refresh && !input.defer_refresh {
148 let refreshed_expires_at = OffsetDateTime::now_utc()
149 + Duration::seconds(self.context.session_config.expires_in as i64);
150 if let Some(updated_session) = session_store
151 .update_session_expiry(&session.token, refreshed_expires_at)
152 .await?
153 {
154 session = updated_session;
155 cookies.extend(set_session_cookie(
156 &self.context.auth_cookies,
157 &self.context.secret,
158 &session.token,
159 SessionCookieOptions {
160 dont_remember: false,
161 overrides: CookieOptions {
162 max_age: seconds_until(session.expires_at),
163 ..CookieOptions::default()
164 },
165 },
166 )?);
167 } else {
168 return Ok(Some(unauthenticated(delete_session_cookie(
169 &self.context.auth_cookies,
170 &input.cookie_header,
171 false,
172 ))));
173 }
174 }
175
176 if self.context.options.session.cookie_cache.enabled {
177 cookies.extend(self.cookie_cache_cookies(&session, &user)?);
178 }
179
180 Ok(Some(authenticated(session, user, cookies, needs_refresh)))
181 }
182
183 pub async fn sign_out(
184 &self,
185 cookie_header: impl AsRef<str>,
186 ) -> Result<SignOutResult, OpenAuthError> {
187 let cookie_header = cookie_header.as_ref();
188 if let Some(signed_token) =
189 get_session_cookie(cookie_header, cookie_prefix(self.context), None)
190 {
191 if let Some(token) = verify_cookie_value(&signed_token, &self.context.secret)? {
192 let _delete_result = SessionStore::new(self.adapter, self.context)
193 .delete_session(&token)
194 .await;
195 }
196 }
197
198 Ok(SignOutResult {
199 success: true,
200 cookies: delete_session_cookie(&self.context.auth_cookies, cookie_header, false),
201 })
202 }
203
204 fn cookie_cache_cookies(
205 &self,
206 session: &Session,
207 user: &User,
208 ) -> Result<Vec<Cookie>, OpenAuthError> {
209 let payload = CookieCachePayload {
210 session: session.clone(),
211 user: user.clone(),
212 updated_at: OffsetDateTime::now_utc().unix_timestamp(),
213 version: self
214 .context
215 .options
216 .session
217 .cookie_cache
218 .version
219 .clone()
220 .unwrap_or_else(|| "1".to_owned()),
221 };
222 let max_age = self
223 .context
224 .options
225 .session
226 .cookie_cache
227 .max_age
228 .unwrap_or(60 * 5);
229 set_cookie_cache(
230 &self.context.auth_cookies,
231 &self.context.secret,
232 &payload,
233 self.context.options.session.cookie_cache.strategy,
234 max_age,
235 )
236 }
237}
238
239fn cookie_prefix(context: &AuthContext) -> Option<&str> {
240 context.options.advanced.cookie_prefix.as_deref()
241}
242
243fn signed_cookie(
244 cookie_header: &str,
245 cookie_name: &str,
246 secret: &str,
247) -> Result<Option<String>, OpenAuthError> {
248 let Some(value) = parse_cookies(cookie_header).get(cookie_name).cloned() else {
249 return Ok(None);
250 };
251 verify_cookie_value(&value, secret)
252}
253
254fn session_needs_refresh(session: &Session, context: &AuthContext) -> bool {
255 if context.options.session.cookie_cache.refresh_cache {
256 return false;
257 }
258 let due_at = session.expires_at - Duration::seconds(context.session_config.expires_in as i64)
259 + Duration::seconds(context.session_config.update_age as i64);
260 due_at <= OffsetDateTime::now_utc()
261}
262
263fn seconds_until(expires_at: OffsetDateTime) -> Option<u64> {
264 let seconds = (expires_at - OffsetDateTime::now_utc()).whole_seconds();
265 u64::try_from(seconds).ok()
266}
267
268fn authenticated(
269 session: Session,
270 user: User,
271 cookies: Vec<Cookie>,
272 needs_refresh: bool,
273) -> GetSessionResult {
274 GetSessionResult {
275 session: Some(session),
276 user: Some(user),
277 cookies,
278 needs_refresh,
279 }
280}
281
282fn unauthenticated(cookies: Vec<Cookie>) -> GetSessionResult {
283 GetSessionResult {
284 session: None,
285 user: None,
286 cookies,
287 needs_refresh: false,
288 }
289}