Skip to main content

bitwarden_user_crypto_management/key_rotation/
password_change_and_rotate_user_keys.rs

1//! Functionality for rotating user keys, bundled with a password change.
2use bitwarden_api_api::models::RotateUserAccountKeysAndDataRequestModel;
3use bitwarden_core::key_management::{
4    KeySlotIds, MasterPasswordAuthenticationData,
5    account_cryptographic_state::WrappedAccountCryptographicState,
6};
7use bitwarden_crypto::{KeyStore, PublicKey};
8use serde::{Deserialize, Serialize};
9use tracing::info;
10
11use crate::{
12    UserCryptoManagementClient,
13    key_rotation::{
14        RotateUserKeysError,
15        crypto::rotate_account_cryptographic_state_to_request_model,
16        data::{check_for_old_attachments, reencrypt_data},
17        rotate_user_keys::UpgradeTokenAction,
18        rotation_context::make_rotation_context,
19        sync::{SyncedAccountData, sync_current_account_data},
20        unlock::{
21            ReencryptCommonUnlockDataInput, ReencryptMasterPasswordChangeAndUnlockInput,
22            reencrypt_master_password_change_unlock_data,
23        },
24    },
25};
26
27#[derive(Serialize, Deserialize, Clone)]
28#[bitwarden_ffi::wasm_record]
29#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
30pub struct PasswordChangeAndRotateUserKeysRequest {
31    pub old_password: String,
32    pub password: String,
33    pub hint: Option<String>,
34    pub trusted_emergency_access_public_keys: Vec<PublicKey>,
35    pub trusted_organization_public_keys: Vec<PublicKey>,
36}
37
38#[bitwarden_ffi::wasm_export]
39impl UserCryptoManagementClient {
40    /// Combines a password change and user key rotation into a single request.
41    ///
42    /// Before rotating, this checks whether the user's public key encryption key pair needs
43    /// regeneration and fixes it if necessary. This ensures that key rotation can proceed even
44    /// if the existing private key is corrupt.
45    pub async fn password_change_and_rotate_user_keys(
46        &self,
47        request: PasswordChangeAndRotateUserKeysRequest,
48    ) -> Result<(), RotateUserKeysError> {
49        let api_client = &self.client.internal.get_api_configurations().api_client;
50        let key_store = self.client.internal.get_key_store();
51
52        let sync = sync_current_account_data(api_client)
53            .await
54            .map_err(|_| RotateUserKeysError::Api)?;
55
56        let wrapped_account_cryptographic_state = self
57            .regenerate_public_key_encryption_key_pair_if_needed_with_ciphers(&sync.ciphers)
58            .await
59            .map_err(|_| RotateUserKeysError::Crypto)?
60            .unwrap_or_else(|| sync.wrapped_account_cryptographic_state.clone());
61
62        internal_password_change_and_rotate_user_keys(
63            key_store,
64            api_client,
65            request,
66            wrapped_account_cryptographic_state,
67            sync,
68        )
69        .await
70    }
71}
72
73#[bitwarden_logging::instrument(name = "password_change_and_rotate_user_keys", level = "info", err)]
74async fn internal_password_change_and_rotate_user_keys(
75    key_store: &KeyStore<KeySlotIds>,
76    api_client: &bitwarden_api_api::apis::ApiClient,
77    request: PasswordChangeAndRotateUserKeysRequest,
78    wrapped_account_cryptographic_state: WrappedAccountCryptographicState,
79    sync: SyncedAccountData,
80) -> Result<(), RotateUserKeysError> {
81    // Fail early if any cipher has old attachments that would become irrecoverable
82    check_for_old_attachments(&sync.ciphers)?;
83
84    // Create a separate scope so that the mutable context is not held across the await point
85    let post_request = {
86        let mut ctx = key_store.context_mut();
87
88        let rotation_context = make_rotation_context(
89            &sync,
90            request.trusted_organization_public_keys.as_slice(),
91            request.trusted_emergency_access_public_keys.as_slice(),
92            UpgradeTokenAction::Skip,
93            &mut ctx,
94        )?;
95
96        info!("Rotating account cryptographic state for user key rotation");
97        let account_keys_model = rotate_account_cryptographic_state_to_request_model(
98            &wrapped_account_cryptographic_state,
99            &rotation_context.current_user_key_id,
100            &rotation_context.new_user_key_id,
101            &mut ctx,
102        )
103        .map_err(|_| RotateUserKeysError::Crypto)?;
104
105        info!("Re-encrypting account data for user key rotation");
106        let account_data_model = reencrypt_data(
107            sync.folders.as_slice(),
108            sync.ciphers.as_slice(),
109            sync.sends.as_slice(),
110            rotation_context.current_user_key_id,
111            rotation_context.new_user_key_id,
112            &mut ctx,
113        )
114        .map_err(|_| RotateUserKeysError::Crypto)?;
115
116        info!("Re-encrypting account unlock data for user key rotation");
117        let (kdf, salt) = sync.kdf_and_salt.ok_or(RotateUserKeysError::Api)?;
118        let unlock_data_model = reencrypt_master_password_change_unlock_data(
119            ReencryptMasterPasswordChangeAndUnlockInput {
120                password: request.password,
121                hint: request.hint,
122                kdf: kdf.clone(),
123                salt: salt.clone(),
124                common_unlock_data: ReencryptCommonUnlockDataInput {
125                    trusted_devices: sync.trusted_devices,
126                    webauthn_credentials: sync.passkeys,
127                    trusted_organization_keys: rotation_context.v1_organization_memberships,
128                    trusted_emergency_access_keys: rotation_context.v1_emergency_access_memberships,
129                },
130            },
131            rotation_context.current_user_key_id,
132            rotation_context.new_user_key_id,
133            &mut ctx,
134        )
135        .map_err(|_| RotateUserKeysError::Crypto)?;
136
137        let old_master_password_authentication_data =
138            MasterPasswordAuthenticationData::derive(&request.old_password, &kdf, &salt)
139                .map_err(|_| RotateUserKeysError::Crypto)?;
140
141        RotateUserAccountKeysAndDataRequestModel {
142            old_master_key_authentication_hash: Some(
143                old_master_password_authentication_data
144                    .master_password_authentication_hash
145                    .to_string(),
146            ),
147            account_keys: Box::new(account_keys_model),
148            account_data: Box::new(account_data_model),
149            account_unlock_data: Box::new(unlock_data_model),
150            // Only V2 (COSE-encoded) user keys carry a key id; V1 keys omit the fields. The server
151            // rejects the rotation if `old_user_key_id` is not the user's current key id.
152            old_user_key_id: ctx
153                .get_symmetric_key_id(rotation_context.current_user_key_id)
154                .map(|id| id.to_string()),
155            new_user_key_id: ctx
156                .get_symmetric_key_id(rotation_context.new_user_key_id)
157                .map(|id| id.to_string()),
158        }
159    };
160
161    info!("Posting rotated user account keys and data to server");
162    api_client
163        .accounts_key_management_api()
164        .password_change_and_rotate_user_account_keys(Some(post_request))
165        .await
166        .map_err(|_| RotateUserKeysError::Api)?;
167    info!("Successfully rotated user account keys and data");
168    Ok(())
169}
170
171#[cfg(test)]
172mod tests {
173    use std::str::FromStr;
174
175    use bitwarden_api_api::apis::ApiClient;
176    use bitwarden_core::key_management::{
177        KeySlotIds, SymmetricKeySlotId,
178        account_cryptographic_state::WrappedAccountCryptographicState,
179    };
180    use bitwarden_crypto::{Kdf, KeyStore, PublicKeyEncryptionAlgorithm, SymmetricKeyAlgorithm};
181    use bitwarden_vault::{Attachment, Cipher, CipherType};
182    use chrono::DateTime;
183
184    use super::*;
185
186    fn make_test_key_store_and_synced_data() -> (KeyStore<KeySlotIds>, SyncedAccountData) {
187        let store: KeyStore<KeySlotIds> = KeyStore::default();
188        let wrapped_private_key = {
189            let mut ctx = store.context_mut();
190            let user_key = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
191            let _ = ctx.persist_symmetric_key(user_key, SymmetricKeySlotId::User);
192            let private_key = ctx.make_private_key(PublicKeyEncryptionAlgorithm::RsaOaepSha1);
193            ctx.wrap_private_key(SymmetricKeySlotId::User, private_key)
194                .unwrap()
195        };
196
197        let sync = SyncedAccountData {
198            wrapped_account_cryptographic_state: WrappedAccountCryptographicState::V1 {
199                private_key: wrapped_private_key,
200            },
201            folders: vec![],
202            ciphers: vec![],
203            sends: vec![],
204            emergency_access_memberships: vec![],
205            organization_memberships: vec![],
206            trusted_devices: vec![],
207            passkeys: vec![],
208            kdf_and_salt: Some((
209                Kdf::PBKDF2 {
210                    iterations: std::num::NonZeroU32::new(600000).unwrap(),
211                },
212                "test_salt".to_string(),
213            )),
214        };
215
216        (store, sync)
217    }
218
219    #[tokio::test]
220    async fn test_password_change_and_rotate_user_keys_missing_kdf_returns_api_error() {
221        let (key_store, mut sync) = make_test_key_store_and_synced_data();
222        sync.kdf_and_salt = None;
223
224        let api_client = ApiClient::new_mocked(|mock| {
225            mock.accounts_key_management_api
226                .expect_password_change_and_rotate_user_account_keys()
227                .never();
228        });
229
230        let result = internal_password_change_and_rotate_user_keys(
231            &key_store,
232            &api_client,
233            PasswordChangeAndRotateUserKeysRequest {
234                old_password: "old_password".to_string(),
235                password: "new_password".to_string(),
236                hint: None,
237                trusted_organization_public_keys: vec![],
238                trusted_emergency_access_public_keys: vec![],
239            },
240            sync.wrapped_account_cryptographic_state.clone(),
241            sync,
242        )
243        .await;
244
245        assert!(matches!(result, Err(RotateUserKeysError::Api)));
246        if let ApiClient::Mock(mut mock) = api_client {
247            mock.accounts_key_management_api.checkpoint();
248        }
249    }
250
251    #[tokio::test]
252    async fn test_password_change_and_rotate_user_keys_success() {
253        let (key_store, sync) = make_test_key_store_and_synced_data();
254        let api_client = ApiClient::new_mocked(|mock| {
255            mock.accounts_key_management_api
256                .expect_password_change_and_rotate_user_account_keys()
257                .once()
258                .returning(|_| Ok(()));
259        });
260
261        let result = internal_password_change_and_rotate_user_keys(
262            &key_store,
263            &api_client,
264            PasswordChangeAndRotateUserKeysRequest {
265                old_password: "old_password".to_string(),
266                password: "new_password".to_string(),
267                hint: None,
268                trusted_organization_public_keys: vec![],
269                trusted_emergency_access_public_keys: vec![],
270            },
271            sync.wrapped_account_cryptographic_state.clone(),
272            sync,
273        )
274        .await;
275
276        assert!(result.is_ok());
277        if let ApiClient::Mock(mut mock) = api_client {
278            mock.accounts_key_management_api.checkpoint();
279        }
280    }
281
282    #[tokio::test]
283    async fn test_password_change_and_rotate_user_keys_post_api_failure_returns_api_error() {
284        let (key_store, sync) = make_test_key_store_and_synced_data();
285        let api_client = ApiClient::new_mocked(|mock| {
286            mock.accounts_key_management_api
287                .expect_password_change_and_rotate_user_account_keys()
288                .once()
289                .returning(|_| {
290                    Err(serde_json::Error::io(std::io::Error::other("API error")).into())
291                });
292        });
293
294        let result = internal_password_change_and_rotate_user_keys(
295            &key_store,
296            &api_client,
297            PasswordChangeAndRotateUserKeysRequest {
298                old_password: "old_password".to_string(),
299                password: "new_password".to_string(),
300                hint: None,
301                trusted_organization_public_keys: vec![],
302                trusted_emergency_access_public_keys: vec![],
303            },
304            sync.wrapped_account_cryptographic_state.clone(),
305            sync,
306        )
307        .await;
308
309        assert!(matches!(result, Err(RotateUserKeysError::Api)));
310        if let ApiClient::Mock(mut mock) = api_client {
311            mock.accounts_key_management_api.checkpoint();
312        }
313    }
314
315    #[tokio::test]
316    async fn test_password_change_and_rotate_old_attachments_returns_error() {
317        let (key_store, mut sync) = make_test_key_store_and_synced_data();
318        let enc_string = "2.STIyTrfDZN/JXNDN9zNEMw==|NDLum8BHZpPNYhJo9ggSkg==|UCsCLlBO3QzdPwvMAWs2VVwuE6xwOx/vxOooPObqnEw=";
319
320        // Add a cipher with an old attachment (key is None)
321        sync.ciphers = vec![Cipher {
322            partial_data: None,
323            id: None,
324            organization_id: None,
325            folder_id: None,
326            collection_ids: vec![],
327            r#type: CipherType::Login,
328            login: None,
329            identity: None,
330            card: None,
331            secure_note: None,
332            ssh_key: None,
333            bank_account: None,
334            drivers_license: None,
335            passport: None,
336            favorite: false,
337            reprompt: Default::default(),
338            organization_use_totp: false,
339            edit: false,
340            permissions: None,
341            view_password: false,
342            name: Some(enc_string.parse().unwrap()),
343            revision_date: DateTime::from_str("2024-01-01T00:00:00Z").unwrap(),
344            archived_date: None,
345            creation_date: DateTime::from_str("2024-01-01T00:00:00Z").unwrap(),
346            attachments: Some(vec![Attachment {
347                id: None,
348                url: None,
349                size: None,
350                size_name: None,
351                file_name: None,
352                key: None, // Old attachment - no per-attachment key
353            }]),
354            fields: None,
355            key: None,
356            notes: None,
357            local_data: None,
358            password_history: None,
359            deleted_date: None,
360            data: None,
361        }];
362
363        let api_client = ApiClient::new_mocked(|mock| {
364            // Rotation API should never be called
365            mock.accounts_key_management_api
366                .expect_password_change_and_rotate_user_account_keys()
367                .never();
368        });
369
370        let result = internal_password_change_and_rotate_user_keys(
371            &key_store,
372            &api_client,
373            PasswordChangeAndRotateUserKeysRequest {
374                old_password: "old_password".to_string(),
375                password: "new_password".to_string(),
376                hint: None,
377                trusted_organization_public_keys: vec![],
378                trusted_emergency_access_public_keys: vec![],
379            },
380            sync.wrapped_account_cryptographic_state.clone(),
381            sync,
382        )
383        .await;
384
385        assert!(matches!(result, Err(RotateUserKeysError::OldAttachments)));
386        if let ApiClient::Mock(mut mock) = api_client {
387            mock.accounts_key_management_api.checkpoint();
388        }
389    }
390}