Skip to main content

openauth_core/auth/oauth/
state.rs

1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3use time::{Duration, OffsetDateTime};
4
5use crate::context::AuthContext;
6use crate::crypto::random::generate_random_string;
7use crate::db::DbAdapter;
8use crate::error::OpenAuthError;
9use crate::options::OAuthStateStoreStrategy;
10use crate::verification::{CreateVerificationInput, DbVerificationStore};
11
12use super::tokens::{decrypt_with_context, encrypt_with_context};
13
14#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
15pub struct OAuthStateLink {
16    pub email: String,
17    pub user_id: String,
18}
19
20#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
21pub struct OAuthStateData {
22    pub callback_url: String,
23    pub code_verifier: String,
24    pub error_url: Option<String>,
25    pub new_user_url: Option<String>,
26    pub link: Option<OAuthStateLink>,
27    pub expires_at: OffsetDateTime,
28    pub request_sign_up: bool,
29    pub additional_data: Value,
30}
31
32#[derive(Debug, Clone, PartialEq)]
33pub struct OAuthStateInput {
34    pub callback_url: String,
35    pub error_url: Option<String>,
36    pub new_user_url: Option<String>,
37    pub link: Option<OAuthStateLink>,
38    pub request_sign_up: bool,
39    pub additional_data: Value,
40    pub expires_at: Option<OffsetDateTime>,
41}
42
43impl Default for OAuthStateInput {
44    fn default() -> Self {
45        Self {
46            callback_url: String::new(),
47            error_url: None,
48            new_user_url: None,
49            link: None,
50            request_sign_up: false,
51            additional_data: Value::Null,
52            expires_at: None,
53        }
54    }
55}
56
57#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
58pub struct GeneratedOAuthState {
59    pub state: String,
60    pub data: OAuthStateData,
61}
62
63pub async fn generate_oauth_state(
64    context: &AuthContext,
65    adapter: Option<&dyn DbAdapter>,
66    input: OAuthStateInput,
67) -> Result<GeneratedOAuthState, OpenAuthError> {
68    if input.callback_url.is_empty() {
69        return Err(OpenAuthError::Api("callback URL is required".to_owned()));
70    }
71    let data = OAuthStateData {
72        callback_url: input.callback_url,
73        code_verifier: generate_random_string(128),
74        error_url: input.error_url,
75        new_user_url: input.new_user_url,
76        link: input.link,
77        expires_at: input
78            .expires_at
79            .unwrap_or_else(|| OffsetDateTime::now_utc() + Duration::minutes(10)),
80        request_sign_up: input.request_sign_up,
81        additional_data: input.additional_data,
82    };
83    let state = match context.options.account.store_state_strategy {
84        OAuthStateStoreStrategy::Cookie => {
85            let json = serde_json::to_string(&data)
86                .map_err(|error| OpenAuthError::Crypto(error.to_string()))?;
87            encrypt_with_context(&json, context)?
88        }
89        OAuthStateStoreStrategy::Database => {
90            let adapter = adapter.ok_or_else(|| {
91                OpenAuthError::Adapter("database OAuth state requires an adapter".to_owned())
92            })?;
93            let state = generate_random_string(32);
94            let json = serde_json::to_string(&data)
95                .map_err(|error| OpenAuthError::Crypto(error.to_string()))?;
96            DbVerificationStore::new(adapter)
97                .create_verification(CreateVerificationInput::new(
98                    oauth_state_identifier(&state),
99                    json,
100                    data.expires_at,
101                ))
102                .await?;
103            state
104        }
105    };
106    Ok(GeneratedOAuthState { state, data })
107}
108
109pub async fn parse_oauth_state(
110    context: &AuthContext,
111    adapter: Option<&dyn DbAdapter>,
112    state: &str,
113) -> Result<OAuthStateData, OpenAuthError> {
114    let data = match context.options.account.store_state_strategy {
115        OAuthStateStoreStrategy::Cookie => {
116            let json = decrypt_with_context(state, context)?;
117            serde_json::from_str::<OAuthStateData>(&json)
118                .map_err(|error| OpenAuthError::Crypto(error.to_string()))?
119        }
120        OAuthStateStoreStrategy::Database => {
121            let adapter = adapter.ok_or_else(|| {
122                OpenAuthError::Adapter("database OAuth state requires an adapter".to_owned())
123            })?;
124            let verifications = DbVerificationStore::new(adapter);
125            let identifier = oauth_state_identifier(state);
126            let verification = verifications
127                .find_verification(&identifier)
128                .await?
129                .ok_or_else(|| OpenAuthError::Api("invalid OAuth state".to_owned()))?;
130            let data = serde_json::from_str::<OAuthStateData>(&verification.value)
131                .map_err(|error| OpenAuthError::Crypto(error.to_string()))?;
132            if data.expires_at > OffsetDateTime::now_utc() {
133                verifications.delete_verification(&identifier).await?;
134            }
135            data
136        }
137    };
138    if data.expires_at <= OffsetDateTime::now_utc() {
139        return Err(OpenAuthError::Api("OAuth state expired".to_owned()));
140    }
141    Ok(data)
142}
143
144pub fn oauth_state_identifier(state: &str) -> String {
145    format!("oauth-state-{state}")
146}