Skip to main content

bitwarden_user_crypto_management/key_rotation/
unlock.rs

1//! Functionality for re-encrypting unlock (decryption) methods during user key rotation.
2//! During key-rotation, a new user-key is sampled. The unlock module then creates a set of newly
3//! encrypted copies, one for each decryption/unlock method.
4use 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/// The data necessary to re-share the user-key to a V1 emergency access membership. Note: The
33/// Public-key must be verified/trusted. Further, there is no sender authentication possible here.
34#[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            // The name can be null if a user does not set a name; fall back to the email and
51            // then to "Unknown" so we always have a non-empty display name.
52            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/// The data necessary to re-share the user-key to a V1 organization membership. Note: The
62/// Public-key must be verified/trusted. Further, there is no sender authentication possible here.
63#[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    /// Failed to update the unlock data for the master password
92    MasterPasswordDerivation,
93    /// Failed to update the unlock data for TDE/PRF-Passkey
94    KeysetUnlockDataReencryption,
95    /// Failed to update the unlock data for emergency access or organization membership
96    KeySharingError,
97    /// Failed to wrap the user key with the Key Connector key
98    KeyConnectorWrapping,
99    /// Failed to create v2 upgrade token
100    UpgradeTokenCreation,
101}
102
103pub(super) struct ReencryptMasterPasswordChangeAndUnlockInput {
104    /// Master password change data.
105    pub(super) password: String,
106    pub(super) hint: Option<String>,
107    pub(super) kdf: Kdf,
108    pub(super) salt: String,
109    /// Common unlock data to re-encrypt
110    pub(super) common_unlock_data: ReencryptCommonUnlockDataInput,
111}
112
113pub(super) struct ReencryptCommonUnlockDataInput {
114    /// The trusted device keysets.
115    pub(super) trusted_devices: Vec<PartialRotateableKeyset>,
116    /// The webauthn credential keysets.
117    pub(super) webauthn_credentials: Vec<PartialRotateableKeyset>,
118    /// The V1 organization memberships.
119    pub(super) trusted_organization_keys: Vec<V1OrganizationMembership>,
120    /// The V1 emergency access memberships.
121    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        // Master password change + key rotation always needs to logout other sessions, so no
155        // upgrade token is created.
156        v2_upgrade_token: None,
157    })
158}
159
160/// Re-encrypts the unlock methods that every key rotation flow shares.
161pub(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
204/// Re-encrypt TDE device keys for the new user key.
205fn 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
223/// Re-encrypt passkey (WebAuthn PRF) credentials for the new user key.
224fn 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
242/// Re-encrypt emergency access keys for the new user key.
243fn 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            // Share the key to the organization. Note: No sender authentication
254            // and the passed in public-key must be verified/trusted.
255            match UnsignedSharedKey::encapsulate(new_user_key_id, &ea.public_key, ctx) {
256                Ok(reencrypted_key) => Ok(EmergencyAccessWithIdRequestModel {
257                    // Default value that is ignored on the server
258                    r#type: models::EmergencyAccessType::Takeover,
259                    // Default value that is ignored on the server
260                    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
270/// Re-encrypt organization membership keys for the new user key.
271fn 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            // The rotation context passes only memberships whose public key the user confirmed.
283            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
302/// Leaves account recovery for organization admins to update, so the user is not involved.
303///
304/// Sending no key keeps the one the organization already holds. The organizations are still listed.
305/// Leaving them out would look like the user is no longer enrolled.
306fn 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        // Verify the unlock data can decrypt the user key
508        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        // Verify the unlock data can decrypt the user key
552        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        // Ensure it decrypts to the correct key after rotation
636        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        // Ensure it decrypts to the correct key after rotation
686        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}