openauth_core/auth/oauth/
state.rs1use 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}