Skip to main content

bitwarden_auth/token_management/
password_manager_token_handler.rs

1//! Token handler implementation for Bitwarden Password Manager authentication.
2
3use 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/// Token handler for Bitwarden authentication.
18#[derive(Clone, Default)]
19pub struct PasswordManagerTokenHandler {
20    inner: Arc<RwLock<PasswordManagerTokenHandlerInner>>,
21}
22
23#[derive(Clone, Default)]
24struct PasswordManagerTokenHandlerInner {
25    // Filled in by initialize_middleware.
26    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(&registry, "original-token", Some("refresh"), 5000).await;
168
169        let handler = PasswordManagerTokenHandler::default();
170        let client = build_client(&handler, &registry, &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        // expires_in=0 puts the token inside the renewal margin.
185        seed_tokens(&registry, "expired-token", Some("old-refresh"), 0).await;
186
187        let handler = PasswordManagerTokenHandler::default();
188        let client = build_client(&handler, &registry, &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        // Locally-valid token forces renewal through the 401 retry path.
203        seed_tokens(&registry, "stale-token", Some("refresh"), 5000).await;
204
205        let handler = PasswordManagerTokenHandler::default();
206        let client = build_client(&handler, &registry, &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        // First identity call fails, so the initial request goes out unauthenticated and the
232        // forced renewal on retry produces a valid token.
233        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(&registry, "stale-token", Some("refresh"), 0).await;
238
239        let handler = PasswordManagerTokenHandler::default();
240        let client = build_client(&handler, &registry, &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        // Locally-valid tokens, so renewal only happens via the 401 retry path. Coalescing should
263        // collapse the five retries into a single identity-server call.
264        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(&registry, "stale-token", Some("refresh"), 5000).await;
271
272        let handler = PasswordManagerTokenHandler::default();
273        let client = build_client(&handler, &registry, &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        // Renewal delay so that concurrent renewals would overlap if not serialized.
284        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(&registry, "expired-token", Some("refresh"), 0).await;
290
291        let handler = PasswordManagerTokenHandler::default();
292        let client = build_client(&handler, &registry, &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}