Skip to main content

openauth_core/auth/
session.rs

1//! Core session resolution and sign-out behavior.
2
3use 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}