1use 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 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 check_for_old_attachments(&sync.ciphers)?;
83
84 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 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 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, }]),
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 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}