bitwarden_auth/token_management/
password_manager_token_handler.rs1use std::sync::{Arc, RwLock};
4
5use bitwarden_core::{
6 NotAuthenticatedError,
7 auth::{TokenHandler, login::LoginError},
8 client::persisted_state::{AUTHENTICATION_TOKENS, AuthenticationTokens, USER_LOGIN_METHOD},
9 key_management::KeySlotIds,
10};
11use bitwarden_crypto::KeyStore;
12use bitwarden_state::{PersistedValue, registry::StateRegistry};
13use chrono::Utc;
14
15use super::middleware::{MiddlewareExt, MiddlewareWrapper};
16
17#[derive(Clone, Default)]
19pub struct PasswordManagerTokenHandler {
20 inner: Arc<RwLock<PasswordManagerTokenHandlerInner>>,
21}
22
23#[derive(Clone, Default)]
24struct PasswordManagerTokenHandlerInner {
25 tokens: Option<PersistedValue<AUTHENTICATION_TOKENS>>,
27 login_method: Option<PersistedValue<USER_LOGIN_METHOD>>,
28 identity_config: Option<bitwarden_api_api::Configuration>,
29}
30
31#[async_trait::async_trait]
32impl TokenHandler for PasswordManagerTokenHandler {
33 fn initialize_middleware(
34 &self,
35 state_registry: &StateRegistry,
36 identity_config: bitwarden_api_api::Configuration,
37 _key_store: KeyStore<KeySlotIds>,
38 ) -> Arc<dyn reqwest_middleware::Middleware> {
39 {
40 let mut inner = self.inner.write().expect("RwLock is not poisoned");
41 inner.tokens = Some(state_registry.value::<AUTHENTICATION_TOKENS>());
42 inner.login_method = Some(state_registry.value::<USER_LOGIN_METHOD>());
43 inner.identity_config = Some(identity_config);
44 }
45 Arc::new(MiddlewareWrapper::new(self.clone()))
46 }
47
48 async fn set_tokens(
49 &self,
50 access_token: String,
51 refresh_token: Option<String>,
52 expires_in: u64,
53 ) {
54 let tokens = self
55 .inner
56 .read()
57 .expect("RwLock is not poisoned")
58 .tokens
59 .clone();
60
61 if let Some(tokens) = tokens {
62 tokens
63 .set(AuthenticationTokens {
64 access_token,
65 refresh_token,
66 expires_on: Utc::now().timestamp() + expires_in as i64,
67 })
68 .await
69 .ok();
70 }
71 }
72}
73
74#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
75#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
76impl MiddlewareExt for PasswordManagerTokenHandler {
77 async fn current_token(&self) -> Option<(String, i64)> {
78 let inner = self.inner.read().expect("RwLock is not poisoned").clone();
79 let tokens = inner.tokens?.try_get().await.ok().flatten()?;
80 Some((tokens.access_token, tokens.expires_on))
81 }
82
83 async fn renew_token(&mut self) -> Result<Option<String>, LoginError> {
84 let inner = self.inner.read().expect("RwLock is not poisoned").clone();
85
86 let tokens = inner
87 .tokens
88 .ok_or(NotAuthenticatedError)?
89 .get()
90 .await
91 .map_err(|_| NotAuthenticatedError)?;
92
93 let login_method = inner.login_method.ok_or(NotAuthenticatedError)?;
94 let identity_config = inner.identity_config.ok_or(NotAuthenticatedError)?;
95
96 let login_method = login_method
97 .get()
98 .await
99 .map_err(|_| NotAuthenticatedError)?;
100
101 let (access_token, refresh_token, expires_in) =
102 bitwarden_core::auth::renew::renew_pm_token_sdk_managed(
103 tokens.refresh_token,
104 &login_method,
105 identity_config,
106 )
107 .await?;
108
109 self.set_tokens(access_token.clone(), refresh_token, expires_in)
110 .await;
111 Ok(Some(access_token))
112 }
113}
114
115#[cfg(test)]
116mod tests {
117 use bitwarden_api_api::apis::AuthRequired;
118 use bitwarden_core::client::{
119 login_method::UserLoginMethod,
120 persisted_state::{AuthenticationTokens, USER_LOGIN_METHOD},
121 };
122 use bitwarden_crypto::Kdf;
123 use bitwarden_state::registry::StateRegistry;
124 use wiremock::MockServer;
125
126 use super::*;
127 use crate::token_management::test_utils::*;
128
129 async fn registry_with_api_key_login() -> StateRegistry {
130 let registry = StateRegistry::new_with_memory_db();
131 registry
132 .value::<USER_LOGIN_METHOD>()
133 .set(UserLoginMethod::ApiKey {
134 client_id: "test-client".to_string(),
135 client_secret: "test-secret".to_string(),
136 email: "[email protected]".to_string(),
137 kdf: Kdf::default_pbkdf2(),
138 })
139 .await
140 .unwrap();
141 registry
142 }
143
144 async fn seed_tokens(
145 registry: &StateRegistry,
146 access_token: &str,
147 refresh_token: Option<&str>,
148 expires_in: i64,
149 ) {
150 registry
151 .value::<AUTHENTICATION_TOKENS>()
152 .set(AuthenticationTokens {
153 access_token: access_token.to_string(),
154 refresh_token: refresh_token.map(str::to_string),
155 expires_on: Utc::now().timestamp() + expires_in,
156 })
157 .await
158 .unwrap();
159 }
160
161 #[tokio::test]
162 async fn attaches_existing_token_when_not_expired() {
163 let app_server = start_app_server().await;
164 let identity_server = MockServer::start().await;
165
166 let registry = registry_with_api_key_login().await;
167 seed_tokens(®istry, "original-token", Some("refresh"), 5000).await;
168
169 let handler = PasswordManagerTokenHandler::default();
170 let client = build_client(&handler, ®istry, &identity_server);
171
172 let auth = send_auth_request(&client, &app_server).await;
173 assert_eq!(auth.as_deref(), Some("Bearer original-token"));
174 assert_eq!(identity_server.received_requests().await.unwrap().len(), 0);
175 assert_eq!(app_server.received_requests().await.unwrap().len(), 1);
176 }
177
178 #[tokio::test]
179 async fn renews_expired_token() {
180 let app_server = start_app_server().await;
181 let identity_server = start_renewal_server("renewed-token").await;
182
183 let registry = registry_with_api_key_login().await;
184 seed_tokens(®istry, "expired-token", Some("old-refresh"), 0).await;
186
187 let handler = PasswordManagerTokenHandler::default();
188 let client = build_client(&handler, ®istry, &identity_server);
189
190 let auth = send_auth_request(&client, &app_server).await;
191 assert_eq!(auth.as_deref(), Some("Bearer renewed-token"));
192 assert_eq!(identity_server.received_requests().await.unwrap().len(), 1);
193 assert_eq!(app_server.received_requests().await.unwrap().len(), 1);
194 }
195
196 #[tokio::test]
197 async fn retries_with_renewed_token_on_401() {
198 let app_server = start_app_server_rejecting("stale-token").await;
199 let identity_server = start_renewal_server("renewed-token").await;
200
201 let registry = registry_with_api_key_login().await;
202 seed_tokens(®istry, "stale-token", Some("refresh"), 5000).await;
204
205 let handler = PasswordManagerTokenHandler::default();
206 let client = build_client(&handler, ®istry, &identity_server);
207
208 let response = client
209 .get(format!("{}/test", app_server.uri()))
210 .with_extension(AuthRequired::Bearer)
211 .send()
212 .await
213 .unwrap();
214 assert_eq!(response.status(), 200);
215
216 let requests = app_server.received_requests().await.unwrap();
217 assert_eq!(requests.len(), 2);
218 assert_eq!(
219 requests[0].headers.get("Authorization").unwrap(),
220 "Bearer stale-token"
221 );
222 assert_eq!(
223 requests[1].headers.get("Authorization").unwrap(),
224 "Bearer renewed-token"
225 );
226 assert_eq!(identity_server.received_requests().await.unwrap().len(), 1);
227 }
228
229 #[tokio::test]
230 async fn refreshes_on_retry_when_initial_token_unavailable() {
231 let app_server = start_app_server_accepting("renewed-token").await;
234 let identity_server = start_renewal_server_failing_then_succeeding("renewed-token").await;
235
236 let registry = registry_with_api_key_login().await;
237 seed_tokens(®istry, "stale-token", Some("refresh"), 0).await;
238
239 let handler = PasswordManagerTokenHandler::default();
240 let client = build_client(&handler, ®istry, &identity_server);
241
242 let response = client
243 .get(format!("{}/test", app_server.uri()))
244 .with_extension(AuthRequired::Bearer)
245 .send()
246 .await
247 .unwrap();
248 assert_eq!(response.status(), 200);
249
250 let requests = app_server.received_requests().await.unwrap();
251 assert_eq!(requests.len(), 2);
252 assert!(requests[0].headers.get("Authorization").is_none());
253 assert_eq!(
254 requests[1].headers.get("Authorization").unwrap(),
255 "Bearer renewed-token"
256 );
257 assert_eq!(identity_server.received_requests().await.unwrap().len(), 2);
258 }
259
260 #[tokio::test]
261 async fn concurrent_401s_trigger_a_single_renewal() {
262 let app_server = start_app_server_rejecting("stale-token").await;
265 let identity_server =
266 start_renewal_server_with_delay("renewed-token", std::time::Duration::from_millis(100))
267 .await;
268
269 let registry = registry_with_api_key_login().await;
270 seed_tokens(®istry, "stale-token", Some("refresh"), 5000).await;
271
272 let handler = PasswordManagerTokenHandler::default();
273 let client = build_client(&handler, ®istry, &identity_server);
274
275 send_concurrent_auth_requests(&client, &app_server, 5).await;
276
277 assert_eq!(identity_server.received_requests().await.unwrap().len(), 1);
278 }
279
280 #[tokio::test]
281 async fn concurrent_requests_trigger_a_single_renewal() {
282 let app_server = start_app_server().await;
283 let identity_server =
285 start_renewal_server_with_delay("renewed-token", std::time::Duration::from_millis(100))
286 .await;
287
288 let registry = registry_with_api_key_login().await;
289 seed_tokens(®istry, "expired-token", Some("refresh"), 0).await;
290
291 let handler = PasswordManagerTokenHandler::default();
292 let client = build_client(&handler, ®istry, &identity_server);
293
294 send_concurrent_auth_requests(&client, &app_server, 5).await;
295
296 assert_eq!(identity_server.received_requests().await.unwrap().len(), 1);
297 let app_requests = app_server.received_requests().await.unwrap();
298 assert_eq!(app_requests.len(), 5);
299 for req in app_requests {
300 assert_eq!(
301 req.headers.get("Authorization").unwrap(),
302 "Bearer renewed-token"
303 );
304 }
305 }
306}