1use std::str::FromStr;
5
6use bitwarden_api_api::models::{
7 self, CommonUnlockDataRequestModel, EmergencyAccessKeyDataResponseModel,
8 EmergencyAccessWithIdRequestModel, MasterPasswordUnlockAndAuthenticationDataModel,
9 OrganizationPasswordResetKeyDataResponseModel, OrganizationUserAccountRecoveryRequestModel,
10 OtherDeviceKeysUpdateRequestModel, UnlockDataRequestModel, V2UpgradeTokenRequestModel,
11 WebAuthnLoginRotateKeyRequestModel,
12};
13use bitwarden_core::{
14 key_management::{
15 KeySlotIds, MasterPasswordAuthenticationData, MasterPasswordUnlockData, SymmetricKeySlotId,
16 V2UpgradeToken,
17 },
18 require,
19};
20use bitwarden_crypto::{
21 CoseKeyThumbprintExt, Kdf, KeyStoreContext, PublicKey, SpkiPublicKeyBytes, UnsignedSharedKey,
22};
23use bitwarden_encoding::B64;
24use bitwarden_organization_crypto::{account_recovery::AccountRecovery, trust_proof::TrustProof};
25use serde::{Deserialize, Serialize};
26use tracing::{debug, debug_span, error, info};
27
28use crate::key_rotation::{
29 KeyRotationDataParseError, partial_rotateable_keyset::PartialRotateableKeyset,
30};
31
32#[derive(Serialize, Deserialize, Clone)]
35#[bitwarden_ffi::wasm_record]
36pub struct V1EmergencyAccessMembership {
37 pub id: uuid::Uuid,
38 pub grantee_id: uuid::Uuid,
39 pub name: String,
40 pub public_key: PublicKey,
41}
42
43impl TryFrom<EmergencyAccessKeyDataResponseModel> for V1EmergencyAccessMembership {
44 type Error = KeyRotationDataParseError;
45
46 fn try_from(ea: EmergencyAccessKeyDataResponseModel) -> Result<Self, Self::Error> {
47 Ok(Self {
48 id: require!(ea.id),
49 grantee_id: require!(ea.grantee_id),
50 name: ea
53 .grantee_name
54 .or(ea.grantee_email)
55 .unwrap_or_else(|| "Unknown".to_string()),
56 public_key: parse_public_key(&require!(ea.public_key))?,
57 })
58 }
59}
60
61#[derive(Serialize, Deserialize, Clone)]
64#[bitwarden_ffi::wasm_record]
65pub struct V1OrganizationMembership {
66 pub organization_id: uuid::Uuid,
67 pub name: String,
68 pub public_key: PublicKey,
69}
70
71impl TryFrom<OrganizationPasswordResetKeyDataResponseModel> for V1OrganizationMembership {
72 type Error = KeyRotationDataParseError;
73
74 fn try_from(o: OrganizationPasswordResetKeyDataResponseModel) -> Result<Self, Self::Error> {
75 Ok(Self {
76 organization_id: require!(o.organization_id),
77 name: require!(o.organization_name),
78 public_key: parse_public_key(&require!(o.organization_public_key))?,
79 })
80 }
81}
82
83fn parse_public_key(public_key_b64: &str) -> Result<PublicKey, KeyRotationDataParseError> {
84 Ok(PublicKey::from_der(&SpkiPublicKeyBytes::from(
85 B64::from_str(public_key_b64)?.into_bytes(),
86 ))?)
87}
88
89#[derive(Debug)]
90pub(super) enum ReencryptError {
91 MasterPasswordDerivation,
93 KeysetUnlockDataReencryption,
95 KeySharingError,
97 KeyConnectorWrapping,
99 UpgradeTokenCreation,
101}
102
103pub(super) struct ReencryptMasterPasswordChangeAndUnlockInput {
104 pub(super) password: String,
106 pub(super) hint: Option<String>,
107 pub(super) kdf: Kdf,
108 pub(super) salt: String,
109 pub(super) common_unlock_data: ReencryptCommonUnlockDataInput,
111}
112
113pub(super) struct ReencryptCommonUnlockDataInput {
114 pub(super) trusted_devices: Vec<PartialRotateableKeyset>,
116 pub(super) webauthn_credentials: Vec<PartialRotateableKeyset>,
118 pub(super) trusted_organization_keys: Vec<V1OrganizationMembership>,
120 pub(super) trusted_emergency_access_keys: Vec<V1EmergencyAccessMembership>,
122}
123
124pub(super) fn reencrypt_master_password_change_unlock_data(
125 input: ReencryptMasterPasswordChangeAndUnlockInput,
126 current_user_key_id: SymmetricKeySlotId,
127 new_user_key_id: SymmetricKeySlotId,
128 ctx: &mut KeyStoreContext<KeySlotIds>,
129) -> Result<UnlockDataRequestModel, ReencryptError> {
130 let master_password_unlock_data = reencrypt_userkey_for_masterpassword_unlock(
131 input.password,
132 input.hint,
133 input.kdf,
134 input.salt,
135 new_user_key_id,
136 ctx,
137 )?;
138
139 let common_unlock_data = reencrypt_common_unlock_data(
140 input.common_unlock_data,
141 current_user_key_id,
142 new_user_key_id,
143 false,
144 ctx,
145 )?;
146
147 Ok(UnlockDataRequestModel {
148 master_password_unlock_data: Box::new(master_password_unlock_data),
149 emergency_access_unlock_data: common_unlock_data.emergency_access_unlock_data,
150 organization_account_recovery_unlock_data: common_unlock_data
151 .organization_account_recovery_unlock_data,
152 passkey_unlock_data: common_unlock_data.passkey_unlock_data,
153 device_key_unlock_data: common_unlock_data.device_key_unlock_data,
154 v2_upgrade_token: None,
157 })
158}
159
160pub(super) fn reencrypt_common_unlock_data(
162 input: ReencryptCommonUnlockDataInput,
163 current_user_key_id: SymmetricKeySlotId,
164 new_user_key_id: SymmetricKeySlotId,
165 creates_v2_upgrade_token: bool,
166 ctx: &mut KeyStoreContext<KeySlotIds>,
167) -> Result<CommonUnlockDataRequestModel, ReencryptError> {
168 let tde_device_unlock_data = reencrypt_tde_devices(
169 &input.trusted_devices,
170 current_user_key_id,
171 new_user_key_id,
172 ctx,
173 )?;
174 let prf_passkey_unlock_data = reencrypt_passkey_credentials(
175 &input.webauthn_credentials,
176 current_user_key_id,
177 new_user_key_id,
178 ctx,
179 )?;
180 let emergency_accesses =
181 reencrypt_emergency_access_keys(input.trusted_emergency_access_keys, new_user_key_id, ctx)?;
182 let organizations_memberships = if creates_v2_upgrade_token {
183 defer_organization_account_recovery_to_admins(input.trusted_organization_keys)
184 } else {
185 reencrypt_organization_memberships(input.trusted_organization_keys, new_user_key_id, ctx)?
186 };
187
188 let upgrade_token = make_upgrade_token_if_needed(
189 current_user_key_id,
190 new_user_key_id,
191 creates_v2_upgrade_token,
192 ctx,
193 )?;
194
195 Ok(CommonUnlockDataRequestModel {
196 emergency_access_unlock_data: Some(emergency_accesses),
197 organization_account_recovery_unlock_data: Some(organizations_memberships),
198 passkey_unlock_data: Some(prf_passkey_unlock_data),
199 device_key_unlock_data: Some(tde_device_unlock_data),
200 v2_upgrade_token: upgrade_token,
201 })
202}
203
204fn reencrypt_tde_devices(
206 trusted_devices: &[PartialRotateableKeyset],
207 current_user_key_id: SymmetricKeySlotId,
208 new_user_key_id: SymmetricKeySlotId,
209 ctx: &mut KeyStoreContext<KeySlotIds>,
210) -> Result<Vec<OtherDeviceKeysUpdateRequestModel>, ReencryptError> {
211 trusted_devices
212 .iter()
213 .map(|device| {
214 let _span = debug_span!("reencrypt_device_key", device_id = ?device.id).entered();
215 device
216 .rotate_userkey(current_user_key_id, new_user_key_id, ctx)
217 .map_err(|_| ReencryptError::KeysetUnlockDataReencryption)
218 .map(Into::into)
219 })
220 .collect()
221}
222
223fn reencrypt_passkey_credentials(
225 webauthn_credentials: &[PartialRotateableKeyset],
226 current_user_key_id: SymmetricKeySlotId,
227 new_user_key_id: SymmetricKeySlotId,
228 ctx: &mut KeyStoreContext<KeySlotIds>,
229) -> Result<Vec<WebAuthnLoginRotateKeyRequestModel>, ReencryptError> {
230 webauthn_credentials
231 .iter()
232 .map(|cred| {
233 let _span =
234 debug_span!("reencrypt_webauthn_credential", credential_id = ?cred.id).entered();
235 cred.rotate_userkey(current_user_key_id, new_user_key_id, ctx)
236 .map_err(|_| ReencryptError::KeysetUnlockDataReencryption)
237 .map(Into::into)
238 })
239 .collect()
240}
241
242fn reencrypt_emergency_access_keys(
244 trusted_emergency_access_keys: Vec<V1EmergencyAccessMembership>,
245 new_user_key_id: SymmetricKeySlotId,
246 ctx: &mut KeyStoreContext<KeySlotIds>,
247) -> Result<Vec<EmergencyAccessWithIdRequestModel>, ReencryptError> {
248 trusted_emergency_access_keys
249 .into_iter()
250 .map(|ea| {
251 let _span =
252 debug_span!("reencrypt_emergency_access_key", grantee_id = ?ea.id).entered();
253 match UnsignedSharedKey::encapsulate(new_user_key_id, &ea.public_key, ctx) {
256 Ok(reencrypted_key) => Ok(EmergencyAccessWithIdRequestModel {
257 r#type: models::EmergencyAccessType::Takeover,
259 wait_time_days: 1,
261 id: ea.id,
262 key_encrypted: reencrypted_key.to_string().into(),
263 }),
264 Err(_) => Err(ReencryptError::KeySharingError),
265 }
266 })
267 .collect()
268}
269
270fn reencrypt_organization_memberships(
272 trusted_organization_keys: Vec<V1OrganizationMembership>,
273 new_user_key_id: SymmetricKeySlotId,
274 ctx: &mut KeyStoreContext<KeySlotIds>,
275) -> Result<Vec<OrganizationUserAccountRecoveryRequestModel>, ReencryptError> {
276 trusted_organization_keys
277 .into_iter()
278 .map(|org_membership| {
279 let _span =
280 debug_span!("reencrypt_organization_key", organization = ?org_membership.organization_id)
281 .entered();
282 let Ok(trusted_thumbprint) = org_membership.public_key.thumbprint() else {
284 return Err(ReencryptError::KeySharingError);
285 };
286 match AccountRecovery::make(
287 new_user_key_id,
288 &org_membership.public_key,
289 &TrustProof::ManuallyTrustedThumbprint(trusted_thumbprint),
290 ctx,
291 ) {
292 Ok(account_recovery) => Ok(OrganizationUserAccountRecoveryRequestModel {
293 reset_password_key: Some(String::from(&account_recovery)),
294 organization_id: org_membership.organization_id,
295 }),
296 Err(_) => Err(ReencryptError::KeySharingError),
297 }
298 })
299 .collect()
300}
301
302fn defer_organization_account_recovery_to_admins(
307 organization_memberships: Vec<V1OrganizationMembership>,
308) -> Vec<OrganizationUserAccountRecoveryRequestModel> {
309 organization_memberships
310 .into_iter()
311 .map(|org_membership| {
312 debug!(
313 organization = ?org_membership.organization_id,
314 "Leaving account recovery for organization admins to update",
315 );
316 OrganizationUserAccountRecoveryRequestModel {
317 reset_password_key: None,
318 organization_id: org_membership.organization_id,
319 }
320 })
321 .collect()
322}
323
324fn reencrypt_userkey_for_masterpassword_unlock(
325 password: String,
326 hint: Option<String>,
327 kdf: Kdf,
328 salt: String,
329 new_user_key_id: SymmetricKeySlotId,
330 ctx: &mut KeyStoreContext<KeySlotIds>,
331) -> Result<MasterPasswordUnlockAndAuthenticationDataModel, ReencryptError> {
332 let _span = debug_span!("derive_master_password_unlock_data").entered();
333 let unlock_data =
334 MasterPasswordUnlockData::derive(&password, &kdf, &salt, new_user_key_id, ctx)
335 .map_err(|_| ReencryptError::MasterPasswordDerivation)?;
336 let authentication_data = MasterPasswordAuthenticationData::derive(&password, &kdf, &salt)
337 .map_err(|_| ReencryptError::MasterPasswordDerivation)?;
338 to_authentication_and_unlock_data(unlock_data, authentication_data, hint)
339 .map_err(|_| ReencryptError::MasterPasswordDerivation)
340}
341
342#[derive(Debug)]
343struct ParsingError;
344
345fn to_authentication_and_unlock_data(
346 master_password_unlock_data: MasterPasswordUnlockData,
347 master_password_authentication_data: MasterPasswordAuthenticationData,
348 hint: Option<String>,
349) -> Result<MasterPasswordUnlockAndAuthenticationDataModel, ParsingError> {
350 let (kdf_type, kdf_iterations, kdf_memory, kdf_parallelism) =
351 match master_password_unlock_data.kdf {
352 bitwarden_crypto::Kdf::PBKDF2 { iterations } => {
353 (models::KdfType::PBKDF2_SHA256, iterations, None, None)
354 }
355 bitwarden_crypto::Kdf::Argon2id {
356 iterations,
357 memory,
358 parallelism,
359 } => (
360 models::KdfType::Argon2id,
361 iterations,
362 Some(memory),
363 Some(parallelism),
364 ),
365 };
366 Ok(MasterPasswordUnlockAndAuthenticationDataModel {
367 kdf_type,
368 kdf_iterations: kdf_iterations.get().try_into().map_err(|_| ParsingError)?,
369 kdf_memory: kdf_memory
370 .map(|m| m.get().try_into().map_err(|_| ParsingError))
371 .transpose()?,
372 kdf_parallelism: kdf_parallelism
373 .map(|p| p.get().try_into().map_err(|_| ParsingError))
374 .transpose()?,
375 email: Some(master_password_unlock_data.salt.clone()),
376 master_key_authentication_hash: Some(
377 master_password_authentication_data
378 .master_password_authentication_hash
379 .to_string(),
380 ),
381 master_key_encrypted_user_key: Some(
382 master_password_unlock_data
383 .master_key_wrapped_user_key
384 .to_string(),
385 ),
386 master_password_hint: hint,
387 master_password_salt: Some(master_password_unlock_data.salt.clone()),
388 contained_key_id: master_password_unlock_data
389 .contained_key_id
390 .as_ref()
391 .map(|id| id.to_string()),
392 })
393}
394
395fn make_upgrade_token_if_needed(
396 current_user_key_id: SymmetricKeySlotId,
397 new_user_key_id: SymmetricKeySlotId,
398 creates_v2_upgrade_token: bool,
399 ctx: &mut KeyStoreContext<KeySlotIds>,
400) -> Result<Option<Box<V2UpgradeTokenRequestModel>>, ReencryptError> {
401 if !creates_v2_upgrade_token {
402 return Ok(None);
403 }
404
405 let token = V2UpgradeToken::create(current_user_key_id, new_user_key_id, ctx).map_err(|e| {
406 error!("Failed to create V2 upgrade token: {e}");
407 ReencryptError::UpgradeTokenCreation
408 })?;
409 info!("Upgrade token created for the key rotation");
410 Ok(Some(Box::new(token.into())))
411}
412
413#[cfg(test)]
414mod tests {
415 use std::num::NonZeroU32;
416
417 use bitwarden_api_api::models::KdfType;
418 use bitwarden_core::key_management::KeySlotIds;
419 use bitwarden_crypto::{
420 Kdf, KeyStore, PublicKeyEncryptionAlgorithm, SymmetricKeyAlgorithm, UnsignedSharedKey,
421 };
422 use uuid::Uuid;
423
424 use super::*;
425 use crate::key_rotation::partial_rotateable_keyset::PartialRotateableKeyset;
426
427 fn create_test_kdf_pbkdf2() -> Kdf {
428 Kdf::PBKDF2 {
429 iterations: NonZeroU32::new(600000).expect("valid iterations"),
430 }
431 }
432
433 fn create_test_kdf_argon2id() -> Kdf {
434 Kdf::Argon2id {
435 iterations: NonZeroU32::new(3).expect("valid iterations"),
436 memory: NonZeroU32::new(64).expect("valid memory"),
437 parallelism: NonZeroU32::new(4).expect("valid parallelism"),
438 }
439 }
440
441 fn assert_symmetric_keys_equal(
442 key_id_1: SymmetricKeySlotId,
443 key_id_2: SymmetricKeySlotId,
444 ctx: &mut KeyStoreContext<KeySlotIds>,
445 ) {
446 #[allow(deprecated)]
447 let key_1 = ctx
448 .dangerous_get_symmetric_key(key_id_1)
449 .expect("key 1 should exist");
450 #[allow(deprecated)]
451 let key_2 = ctx
452 .dangerous_get_symmetric_key(key_id_2)
453 .expect("key 2 should exist");
454 assert_eq!(key_1, key_2, "symmetric keys should be equal");
455 }
456
457 fn empty_common_unlock_input() -> ReencryptCommonUnlockDataInput {
458 ReencryptCommonUnlockDataInput {
459 trusted_devices: vec![],
460 webauthn_credentials: vec![],
461 trusted_organization_keys: vec![],
462 trusted_emergency_access_keys: vec![],
463 }
464 }
465
466 fn request_model_to_token(request: V2UpgradeTokenRequestModel) -> V2UpgradeToken {
467 V2UpgradeToken {
468 wrapped_user_key_1: request
469 .wrapped_user_key1
470 .parse()
471 .expect("wrapped_user_key1 should parse"),
472 wrapped_user_key_2: request
473 .wrapped_user_key2
474 .parse()
475 .expect("wrapped_user_key2 should parse"),
476 }
477 }
478
479 #[test]
480 fn test_to_authentication_and_unlock_data_pbkdf2() {
481 let store: KeyStore<KeySlotIds> = KeyStore::default();
482 let mut ctx = store.context_mut();
483
484 let kdf = create_test_kdf_pbkdf2();
485 let salt = "[email protected]";
486 let password = "test_password";
487
488 let user_key_id = ctx.generate_symmetric_key();
489 let unlock_data = MasterPasswordUnlockData::derive(password, &kdf, salt, user_key_id, &ctx)
490 .expect("derive should succeed");
491 let auth_data = MasterPasswordAuthenticationData::derive(password, &kdf, salt)
492 .expect("derive should succeed");
493
494 let result = to_authentication_and_unlock_data(unlock_data, auth_data, None);
495 assert!(result.is_ok());
496
497 let model = result.expect("should be ok");
498 assert_eq!(model.kdf_type, KdfType::PBKDF2_SHA256);
499 assert_eq!(model.kdf_iterations, 600000);
500 assert!(model.kdf_memory.is_none());
501 assert!(model.kdf_parallelism.is_none());
502 assert_eq!(model.email, Some(salt.to_string()));
503 assert!(model.master_key_authentication_hash.is_some());
504 assert!(model.master_key_encrypted_user_key.is_some());
505 assert!(model.master_password_hint.is_none());
506
507 let master_password_unlock_data = MasterPasswordUnlockData {
509 master_key_wrapped_user_key: model
510 .master_key_encrypted_user_key
511 .expect("should be present")
512 .parse()
513 .expect("should parse"),
514 kdf: kdf.clone(),
515 salt: salt.to_string(),
516 contained_key_id: None,
517 };
518 let decrypted_user_key = master_password_unlock_data
519 .unwrap_to_context(password, &mut ctx)
520 .expect("unwrap should succeed");
521 assert_symmetric_keys_equal(user_key_id, decrypted_user_key, &mut ctx);
522 }
523
524 #[test]
525 fn test_to_authentication_and_unlock_data_argon2id() {
526 let store: KeyStore<KeySlotIds> = KeyStore::default();
527 let mut ctx = store.context_mut();
528
529 let kdf = create_test_kdf_argon2id();
530 let salt = "[email protected]";
531 let password = "test_password";
532
533 let user_key_id = ctx.generate_symmetric_key();
534 let unlock_data = MasterPasswordUnlockData::derive(password, &kdf, salt, user_key_id, &ctx)
535 .expect("derive should succeed");
536 let auth_data = MasterPasswordAuthenticationData::derive(password, &kdf, salt)
537 .expect("derive should succeed");
538
539 let result = to_authentication_and_unlock_data(unlock_data, auth_data, None);
540 assert!(result.is_ok());
541
542 let model = result.expect("should be ok");
543 assert_eq!(model.kdf_type, KdfType::Argon2id);
544 assert_eq!(model.kdf_iterations, 3);
545 assert_eq!(model.kdf_memory, Some(64));
546 assert_eq!(model.kdf_parallelism, Some(4));
547 assert_eq!(model.email, Some(salt.to_string()));
548 assert!(model.master_key_authentication_hash.is_some());
549 assert!(model.master_key_encrypted_user_key.is_some());
550
551 let master_password_unlock_data = MasterPasswordUnlockData {
553 master_key_wrapped_user_key: model
554 .master_key_encrypted_user_key
555 .expect("should be present")
556 .parse()
557 .expect("should parse"),
558 kdf: kdf.clone(),
559 salt: salt.to_string(),
560 contained_key_id: None,
561 };
562 let decrypted_user_key = master_password_unlock_data
563 .unwrap_to_context(password, &mut ctx)
564 .expect("unwrap should succeed");
565 assert_symmetric_keys_equal(user_key_id, decrypted_user_key, &mut ctx);
566 }
567
568 #[test]
569 fn test_reencrypt_unlock_device_key_data() {
570 let store: KeyStore<KeySlotIds> = KeyStore::default();
571 let mut ctx = store.context_mut();
572
573 let current_user_key_id = ctx.generate_symmetric_key();
574 let new_user_key_id = ctx.generate_symmetric_key();
575
576 let (device_keyset, device_private_key) =
577 PartialRotateableKeyset::make_test_keyset(current_user_key_id, &mut ctx);
578
579 let result = reencrypt_common_unlock_data(
580 ReencryptCommonUnlockDataInput {
581 trusted_devices: vec![device_keyset],
582 webauthn_credentials: vec![],
583 trusted_organization_keys: vec![],
584 trusted_emergency_access_keys: vec![],
585 },
586 current_user_key_id,
587 new_user_key_id,
588 false,
589 &mut ctx,
590 );
591
592 let unlock_data = result.expect("should be ok");
593
594 let device_unlock = unlock_data
595 .device_key_unlock_data
596 .as_ref()
597 .expect("should be present")
598 .first()
599 .expect("should have at least one");
600 let decrypted_user_key = device_unlock
601 .encrypted_user_key
602 .parse::<UnsignedSharedKey>()
603 .expect("should parse")
604 .decapsulate(device_private_key, &mut ctx)
605 .expect("unwrap should succeed");
606 assert_symmetric_keys_equal(new_user_key_id, decrypted_user_key, &mut ctx);
607 }
608
609 #[test]
610 fn test_reencrypt_unlock_webauthn_prf_credential_data() {
611 let store: KeyStore<KeySlotIds> = KeyStore::default();
612 let mut ctx = store.context_mut();
613
614 let current_user_key_id = ctx.generate_symmetric_key();
615 let new_user_key_id = ctx.generate_symmetric_key();
616
617 let (credential_keyset, credential_private_key) =
618 PartialRotateableKeyset::make_test_keyset(current_user_key_id, &mut ctx);
619
620 let result = reencrypt_common_unlock_data(
621 ReencryptCommonUnlockDataInput {
622 trusted_devices: vec![],
623 webauthn_credentials: vec![credential_keyset],
624 trusted_organization_keys: vec![],
625 trusted_emergency_access_keys: vec![],
626 },
627 current_user_key_id,
628 new_user_key_id,
629 false,
630 &mut ctx,
631 );
632
633 let unlock_data = result.expect("should be ok");
634
635 let credential_unlock = unlock_data
637 .passkey_unlock_data
638 .as_ref()
639 .expect("should be present")
640 .first()
641 .expect("should have at least one");
642 let decrypted_user_key = credential_unlock
643 .encrypted_user_key
644 .parse::<UnsignedSharedKey>()
645 .expect("should parse")
646 .decapsulate(credential_private_key, &mut ctx)
647 .expect("unwrap should succeed");
648 assert_symmetric_keys_equal(new_user_key_id, decrypted_user_key, &mut ctx);
649 }
650
651 #[test]
652 fn test_reencrypt_unlock_emergency_access_data() {
653 let store: KeyStore<KeySlotIds> = KeyStore::default();
654 let mut ctx = store.context_mut();
655
656 let current_user_key_id = ctx.generate_symmetric_key();
657 let new_user_key_id = ctx.generate_symmetric_key();
658
659 let organization_private_key =
660 ctx.make_private_key(PublicKeyEncryptionAlgorithm::RsaOaepSha1);
661 let emergency_access = V1EmergencyAccessMembership {
662 id: Uuid::new_v4(),
663 grantee_id: Uuid::new_v4(),
664 name: "Test User".to_string(),
665 public_key: ctx
666 .get_public_key(organization_private_key)
667 .expect("key exists"),
668 };
669
670 let result = reencrypt_common_unlock_data(
671 ReencryptCommonUnlockDataInput {
672 trusted_devices: vec![],
673 webauthn_credentials: vec![],
674 trusted_organization_keys: vec![],
675 trusted_emergency_access_keys: vec![emergency_access],
676 },
677 current_user_key_id,
678 new_user_key_id,
679 false,
680 &mut ctx,
681 );
682
683 let unlock_data = result.expect("should be ok");
684
685 let emergency_access_unlock = unlock_data
687 .emergency_access_unlock_data
688 .as_ref()
689 .expect("should be present")
690 .first()
691 .expect("should have at least one");
692 let decrypted_user_key = emergency_access_unlock
693 .key_encrypted
694 .as_ref()
695 .map(|k| k.parse::<UnsignedSharedKey>())
696 .expect("should be present")
697 .expect("should parse")
698 .decapsulate(organization_private_key, &mut ctx)
699 .expect("unwrap should succeed");
700 assert_symmetric_keys_equal(new_user_key_id, decrypted_user_key, &mut ctx);
701 }
702
703 #[test]
704 fn test_reencrypt_unlock_organization_membership_data() {
705 let store: KeyStore<KeySlotIds> = KeyStore::default();
706 let mut ctx = store.context_mut();
707
708 let current_user_key_id = ctx.generate_symmetric_key();
709 let new_user_key_id = ctx.generate_symmetric_key();
710
711 let org_key = ctx.make_private_key(PublicKeyEncryptionAlgorithm::RsaOaepSha1);
712 let org_membership = V1OrganizationMembership {
713 organization_id: Uuid::new_v4(),
714 name: "Test Org".to_string(),
715 public_key: ctx.get_public_key(org_key).expect("key exists"),
716 };
717
718 let result = reencrypt_common_unlock_data(
719 ReencryptCommonUnlockDataInput {
720 trusted_devices: vec![],
721 webauthn_credentials: vec![],
722 trusted_organization_keys: vec![org_membership],
723 trusted_emergency_access_keys: vec![],
724 },
725 current_user_key_id,
726 new_user_key_id,
727 false,
728 &mut ctx,
729 );
730
731 let unlock_data = result.expect("should be ok");
732
733 let org_membership_unlock = unlock_data
734 .organization_account_recovery_unlock_data
735 .as_ref()
736 .expect("should be present")
737 .first()
738 .expect("should have at least one");
739 let decrypted_user_key = org_membership_unlock
740 .reset_password_key
741 .as_ref()
742 .map(|k| k.parse::<UnsignedSharedKey>())
743 .expect("should be present")
744 .expect("should parse")
745 .decapsulate(org_key, &mut ctx)
746 .expect("unwrap should succeed");
747 assert_symmetric_keys_equal(new_user_key_id, decrypted_user_key, &mut ctx);
748 }
749
750 #[test]
751 fn test_reencrypt_unlock_organization_membership_data_with_upgrade_token_sends_no_key() {
752 let store: KeyStore<KeySlotIds> = KeyStore::default();
753 let mut ctx = store.context_mut();
754
755 let current_user_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
756 let new_user_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::XAes256Gcm);
757
758 let org_key = ctx.make_private_key(PublicKeyEncryptionAlgorithm::RsaOaepSha1);
759 let organization_id = Uuid::new_v4();
760 let org_membership = V1OrganizationMembership {
761 organization_id,
762 name: "Test Org".to_string(),
763 public_key: ctx.get_public_key(org_key).expect("key exists"),
764 };
765
766 let result = reencrypt_common_unlock_data(
767 ReencryptCommonUnlockDataInput {
768 trusted_devices: vec![],
769 webauthn_credentials: vec![],
770 trusted_organization_keys: vec![org_membership],
771 trusted_emergency_access_keys: vec![],
772 },
773 current_user_key_id,
774 new_user_key_id,
775 true,
776 &mut ctx,
777 );
778
779 let unlock_data = result.expect("should be ok");
780
781 let org_membership_unlock = unlock_data
782 .organization_account_recovery_unlock_data
783 .as_ref()
784 .expect("should be present");
785 assert_eq!(org_membership_unlock.len(), 1);
786 assert_eq!(org_membership_unlock[0].organization_id, organization_id);
787 assert!(
788 org_membership_unlock[0].reset_password_key.is_none(),
789 "account recovery is left for organization admins to update"
790 );
791 }
792
793 #[test]
794 fn test_reencrypt_common_unlock_data_v1_to_v2_creates_upgrade_token() {
795 let store: KeyStore<KeySlotIds> = KeyStore::default();
796 let mut ctx = store.context_mut();
797
798 let current_user_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
799 let new_user_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::XAes256Gcm);
800
801 let result = reencrypt_common_unlock_data(
802 empty_common_unlock_input(),
803 current_user_key_id,
804 new_user_key_id,
805 true,
806 &mut ctx,
807 );
808
809 let unlock_data = result.expect("should be ok");
810 let token_request = *unlock_data
811 .v2_upgrade_token
812 .expect("v2_upgrade_token should be populated for V1 -> V2 rotation");
813 let token = request_model_to_token(token_request);
814
815 let unwrapped_v2_id = token
816 .unwrap_v2(current_user_key_id, &mut ctx)
817 .expect("unwrap_v2 should succeed");
818 assert_symmetric_keys_equal(new_user_key_id, unwrapped_v2_id, &mut ctx);
819
820 let unwrapped_v1_id = token
821 .unwrap_v1(new_user_key_id, &mut ctx)
822 .expect("unwrap_v1 should succeed");
823 assert_symmetric_keys_equal(current_user_key_id, unwrapped_v1_id, &mut ctx);
824 }
825
826 #[test]
827 fn test_reencrypt_common_unlock_data_without_upgrade_token_returns_none() {
828 let store: KeyStore<KeySlotIds> = KeyStore::default();
829 let mut ctx = store.context_mut();
830
831 let current_user_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
832 let new_user_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::XAes256Gcm);
833
834 let result = reencrypt_common_unlock_data(
835 empty_common_unlock_input(),
836 current_user_key_id,
837 new_user_key_id,
838 false,
839 &mut ctx,
840 );
841
842 let unlock_data = result.expect("should be ok");
843 assert!(unlock_data.v2_upgrade_token.is_none());
844 }
845
846 fn make_valid_public_key_b64() -> String {
847 let store: KeyStore<KeySlotIds> = KeyStore::default();
848 let mut ctx = store.context_mut();
849 let key_id = ctx.make_private_key(PublicKeyEncryptionAlgorithm::RsaOaepSha1);
850 ctx.get_public_key(key_id)
851 .expect("public key exists")
852 .to_string()
853 }
854
855 #[test]
856 fn test_v1_emergency_access_membership_try_from_uses_name_when_present() {
857 let id = Uuid::new_v4();
858 let grantee_id = Uuid::new_v4();
859 let model = EmergencyAccessKeyDataResponseModel {
860 id: Some(id),
861 grantee_id: Some(grantee_id),
862 grantee_name: Some("Alice".to_string()),
863 grantee_email: Some("[email protected]".to_string()),
864 public_key: Some(make_valid_public_key_b64()),
865 ..Default::default()
866 };
867
868 let membership = V1EmergencyAccessMembership::try_from(model).expect("should be ok");
869 assert_eq!(membership.id, id);
870 assert_eq!(membership.grantee_id, grantee_id);
871 assert_eq!(membership.name, "Alice");
872 }
873
874 #[test]
875 fn test_v1_emergency_access_membership_try_from_falls_back_to_email_when_name_missing() {
876 let model = EmergencyAccessKeyDataResponseModel {
877 id: Some(Uuid::new_v4()),
878 grantee_id: Some(Uuid::new_v4()),
879 grantee_name: None,
880 grantee_email: Some("[email protected]".to_string()),
881 public_key: Some(make_valid_public_key_b64()),
882 ..Default::default()
883 };
884
885 let membership = V1EmergencyAccessMembership::try_from(model).expect("should be ok");
886 assert_eq!(membership.name, "[email protected]");
887 }
888
889 #[test]
890 fn test_v1_emergency_access_membership_try_from_falls_back_to_unknown_when_name_and_email_missing()
891 {
892 let model = EmergencyAccessKeyDataResponseModel {
893 id: Some(Uuid::new_v4()),
894 grantee_id: Some(Uuid::new_v4()),
895 grantee_name: None,
896 grantee_email: None,
897 public_key: Some(make_valid_public_key_b64()),
898 ..Default::default()
899 };
900
901 let membership = V1EmergencyAccessMembership::try_from(model).expect("should be ok");
902 assert_eq!(membership.name, "Unknown");
903 }
904
905 #[test]
906 fn test_v1_emergency_access_membership_try_from_missing_id_returns_error() {
907 let model = EmergencyAccessKeyDataResponseModel {
908 id: None,
909 grantee_id: Some(Uuid::new_v4()),
910 grantee_name: Some("Alice".to_string()),
911 grantee_email: None,
912 public_key: Some(make_valid_public_key_b64()),
913 ..Default::default()
914 };
915
916 let Err(err) = V1EmergencyAccessMembership::try_from(model) else {
917 panic!("expected error")
918 };
919 assert!(matches!(err, KeyRotationDataParseError::MissingField(_)));
920 }
921
922 #[test]
923 fn test_v1_emergency_access_membership_try_from_missing_grantee_id_returns_error() {
924 let model = EmergencyAccessKeyDataResponseModel {
925 id: Some(Uuid::new_v4()),
926 grantee_id: None,
927 grantee_name: Some("Alice".to_string()),
928 grantee_email: None,
929 public_key: Some(make_valid_public_key_b64()),
930 ..Default::default()
931 };
932
933 let Err(err) = V1EmergencyAccessMembership::try_from(model) else {
934 panic!("expected error")
935 };
936 assert!(matches!(err, KeyRotationDataParseError::MissingField(_)));
937 }
938
939 #[test]
940 fn test_v1_emergency_access_membership_try_from_missing_public_key_returns_error() {
941 let model = EmergencyAccessKeyDataResponseModel {
942 id: Some(Uuid::new_v4()),
943 grantee_id: Some(Uuid::new_v4()),
944 grantee_name: Some("Alice".to_string()),
945 grantee_email: None,
946 public_key: None,
947 ..Default::default()
948 };
949
950 let Err(err) = V1EmergencyAccessMembership::try_from(model) else {
951 panic!("expected error")
952 };
953 assert!(matches!(err, KeyRotationDataParseError::MissingField(_)));
954 }
955
956 #[test]
957 fn test_v1_emergency_access_membership_try_from_invalid_b64_public_key_returns_error() {
958 let model = EmergencyAccessKeyDataResponseModel {
959 id: Some(Uuid::new_v4()),
960 grantee_id: Some(Uuid::new_v4()),
961 grantee_name: Some("Alice".to_string()),
962 grantee_email: None,
963 public_key: Some("not valid base64 !!!".to_string()),
964 ..Default::default()
965 };
966
967 let Err(err) = V1EmergencyAccessMembership::try_from(model) else {
968 panic!("expected error")
969 };
970 assert!(matches!(err, KeyRotationDataParseError::B64(_)));
971 }
972
973 #[test]
974 fn test_v1_emergency_access_membership_try_from_invalid_spki_public_key_returns_error() {
975 let model = EmergencyAccessKeyDataResponseModel {
976 id: Some(Uuid::new_v4()),
977 grantee_id: Some(Uuid::new_v4()),
978 grantee_name: Some("Alice".to_string()),
979 grantee_email: None,
980 public_key: Some(B64::from(b"not-a-real-public-key".as_slice()).to_string()),
981 ..Default::default()
982 };
983
984 let Err(err) = V1EmergencyAccessMembership::try_from(model) else {
985 panic!("expected error")
986 };
987 assert!(matches!(err, KeyRotationDataParseError::Crypto(_)));
988 }
989
990 #[test]
991 fn test_reencrypt_master_password_change_unlock_data_never_returns_upgrade_token() {
992 let store: KeyStore<KeySlotIds> = KeyStore::default();
993 let mut ctx = store.context_mut();
994
995 let current_user_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
996 let new_user_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::XAes256Gcm);
997
998 let input = ReencryptMasterPasswordChangeAndUnlockInput {
999 password: "test_password".to_string(),
1000 hint: None,
1001 kdf: create_test_kdf_pbkdf2(),
1002 salt: "[email protected]".to_string(),
1003 common_unlock_data: empty_common_unlock_input(),
1004 };
1005
1006 let unlock_data = reencrypt_master_password_change_unlock_data(
1007 input,
1008 current_user_key_id,
1009 new_user_key_id,
1010 &mut ctx,
1011 )
1012 .expect("should be ok");
1013
1014 assert!(
1015 unlock_data.v2_upgrade_token.is_none(),
1016 "master password change rotation must never include a v2 upgrade token"
1017 );
1018 }
1019}