Skip to main content

bitwarden_vault/cipher/
change_login_password.rs

1use bitwarden_core::key_management::KeySlotIds;
2use bitwarden_crypto::{CryptoError, KeyStore};
3use bitwarden_error::bitwarden_error;
4use thiserror::Error;
5
6use super::{
7    cipher::{Cipher, CipherType, CipherView, EncryptMode, StrictDecrypt},
8    cipher_client::should_use_blob_encryption,
9};
10
11/// Error returned by [`Cipher::change_login_password`].
12#[bitwarden_error(flat)]
13#[derive(Debug, Error)]
14pub enum ChangeLoginPasswordError {
15    /// The cipher is partial, so re-encrypting it would drop its password history.
16    #[error("Cannot change the password of a partial cipher")]
17    PartialCipher,
18    /// The cipher is not a login.
19    #[error("Cannot change the login password of a cipher that is not a login")]
20    NotLogin,
21    /// Strict decryption or re-encryption failed.
22    #[error(transparent)]
23    Crypto(#[from] CryptoError),
24}
25
26impl Cipher {
27    /// Decrypts this cipher strictly, sets a new login password, records the old one in the
28    /// password history, and re-encrypts it.
29    pub fn change_login_password(
30        self,
31        key_store: &KeyStore<KeySlotIds>,
32        new_password: &str,
33    ) -> Result<Cipher, ChangeLoginPasswordError> {
34        // A partial original has no password history to chain; see `edit_cipher`.
35        if self.partial_data.is_some() {
36            return Err(ChangeLoginPasswordError::PartialCipher);
37        }
38        if self.r#type != CipherType::Login {
39            return Err(ChangeLoginPasswordError::NotLogin);
40        }
41
42        // Strict: an undecryptable field is an error, as re-encrypting would wipe it.
43        let mut view: CipherView = key_store.decrypt(&StrictDecrypt(self))?;
44        if view.login.is_none() {
45            return Err(ChangeLoginPasswordError::NotLogin);
46        }
47
48        let original = view.clone();
49        if let Some(login) = view.login.as_mut() {
50            login.password = Some(new_password.to_owned());
51        }
52        view.update_password_history(&original);
53
54        // The security state picks the format, as in the edit flows. Organization ciphers stay
55        // field-level until the helper supports them (PM-32430), then switch here automatically.
56        let use_blob = should_use_blob_encryption(&key_store.context(), view.organization_id);
57        let mode = if use_blob {
58            EncryptMode::Blob(view)
59        } else {
60            EncryptMode::Legacy(view)
61        };
62        Ok(key_store.encrypt(mode)?)
63    }
64}
65
66#[cfg(test)]
67mod tests {
68    use bitwarden_core::key_management::{
69        BLOB_SECURITY_VERSION, SymmetricKeySlotId, create_test_crypto_with_user_key,
70    };
71    use bitwarden_crypto::{Decryptable, SymmetricCryptoKey, SymmetricKeyAlgorithm};
72
73    use super::*;
74    use crate::{
75        LoginUriView, LoginView, PasswordHistoryView,
76        cipher::{CipherRepromptType, blob::try_parse_blob},
77    };
78
79    fn key_store() -> KeyStore<KeySlotIds> {
80        create_test_crypto_with_user_key(SymmetricCryptoKey::make(
81            SymmetricKeyAlgorithm::Aes256CbcHmac,
82        ))
83    }
84
85    fn login_view() -> CipherView {
86        CipherView {
87            partial: false,
88            r#type: CipherType::Login,
89            login: Some(LoginView {
90                username: Some("user".to_string()),
91                password: Some("old-password".to_string()),
92                password_revision_date: None,
93                uris: Some(vec![LoginUriView {
94                    uri: Some("https://example.com".to_string()),
95                    r#match: None,
96                    uri_checksum: None,
97                }]),
98                totp: None,
99                autofill_on_page_load: None,
100                http_authentication_enabled: None,
101                fido2_credentials: None,
102            }),
103            id: Some("fd411a1a-fec8-4070-985d-0e6560860e69".parse().unwrap()),
104            organization_id: None,
105            folder_id: None,
106            collection_ids: vec![],
107            key: None,
108            name: "My login".to_string(),
109            notes: None,
110            identity: None,
111            card: None,
112            secure_note: None,
113            ssh_key: None,
114            bank_account: None,
115            drivers_license: None,
116            passport: None,
117            favorite: false,
118            reprompt: CipherRepromptType::None,
119            organization_use_totp: true,
120            edit: true,
121            permissions: None,
122            view_password: true,
123            local_data: None,
124            attachments: None,
125            attachment_decryption_failures: None,
126            fields: None,
127            password_history: None,
128            creation_date: "2024-01-30T17:55:36.150Z".parse().unwrap(),
129            deleted_date: None,
130            revision_date: "2024-01-30T17:55:36.150Z".parse().unwrap(),
131            archived_date: None,
132        }
133    }
134
135    fn encrypt(key_store: &KeyStore<KeySlotIds>, view: CipherView) -> Cipher {
136        key_store.encrypt(EncryptMode::Legacy(view)).unwrap()
137    }
138
139    #[test]
140    fn changes_password_and_keeps_other_fields() {
141        let key_store = key_store();
142        let cipher = encrypt(&key_store, login_view());
143
144        let changed = cipher
145            .change_login_password(&key_store, "new-password")
146            .unwrap();
147
148        let view: CipherView = key_store.decrypt(&changed).unwrap();
149        let login = view.login.unwrap();
150        assert_eq!(login.password.as_deref(), Some("new-password"));
151        assert_eq!(login.username.as_deref(), Some("user"));
152        assert_eq!(
153            login.uris.unwrap()[0].uri.as_deref(),
154            Some("https://example.com")
155        );
156        assert_eq!(view.name, "My login");
157    }
158
159    #[test]
160    fn records_old_password_in_history() {
161        let key_store = key_store();
162        let mut view = login_view();
163        view.password_history = Some(vec![PasswordHistoryView {
164            password: "older-password".to_string(),
165            last_used_date: "2024-01-01T00:00:00Z".parse().unwrap(),
166        }]);
167        let cipher = encrypt(&key_store, view);
168
169        let changed = cipher
170            .change_login_password(&key_store, "new-password")
171            .unwrap();
172
173        let view: CipherView = key_store.decrypt(&changed).unwrap();
174        let history = view.password_history.unwrap();
175        assert_eq!(history.len(), 2);
176        assert_eq!(history[0].password, "old-password");
177        assert_eq!(history[1].password, "older-password");
178        assert!(view.login.unwrap().password_revision_date.is_some());
179    }
180
181    #[test]
182    fn keeps_legacy_format_below_blob_version() {
183        let key_store = key_store();
184        let cipher = encrypt(&key_store, login_view());
185
186        let changed = cipher
187            .change_login_password(&key_store, "new-password")
188            .unwrap();
189
190        assert!(try_parse_blob(&changed).is_none());
191    }
192
193    #[test]
194    fn uses_blob_format_at_blob_version() {
195        let key_store = key_store();
196        key_store.set_security_state_version(BLOB_SECURITY_VERSION);
197        let cipher = key_store.encrypt(EncryptMode::Blob(login_view())).unwrap();
198
199        let changed = cipher
200            .change_login_password(&key_store, "new-password")
201            .unwrap();
202
203        assert!(try_parse_blob(&changed).is_some());
204        let view: CipherView = key_store.decrypt(&changed).unwrap();
205        assert_eq!(
206            view.login.unwrap().password.as_deref(),
207            Some("new-password")
208        );
209        assert_eq!(view.password_history.unwrap()[0].password, "old-password");
210    }
211
212    #[test]
213    fn keeps_the_item_key() {
214        let key_store = key_store();
215        let cipher = encrypt(&key_store, login_view());
216        let original_key = cipher.key.clone().expect("item key is generated");
217
218        let changed = cipher
219            .change_login_password(&key_store, "new-password")
220            .unwrap();
221
222        // The result's fields decrypt under the original item key.
223        let mut ctx = key_store.context();
224        let item_key = ctx
225            .unwrap_symmetric_key(SymmetricKeySlotId::User, &original_key)
226            .unwrap();
227        let name: String = changed.name.unwrap().decrypt(&mut ctx, item_key).unwrap();
228        assert_eq!(name, "My login");
229    }
230
231    #[test]
232    fn refuses_non_login_cipher() {
233        let key_store = key_store();
234        let mut view = login_view();
235        view.r#type = CipherType::SecureNote;
236        view.login = None;
237        let cipher = encrypt(&key_store, view);
238
239        let result = cipher.change_login_password(&key_store, "new-password");
240
241        assert!(matches!(result, Err(ChangeLoginPasswordError::NotLogin)));
242    }
243
244    #[test]
245    fn refuses_partial_cipher() {
246        let key_store = key_store();
247        let mut cipher = encrypt(&key_store, login_view());
248        cipher.partial_data = Some("{}".to_string());
249
250        let result = cipher.change_login_password(&key_store, "new-password");
251
252        assert!(matches!(
253            result,
254            Err(ChangeLoginPasswordError::PartialCipher)
255        ));
256    }
257
258    #[test]
259    fn refuses_cipher_with_undecryptable_field() {
260        let key_store = key_store();
261        let other_store = create_test_crypto_with_user_key(SymmetricCryptoKey::make(
262            SymmetricKeyAlgorithm::Aes256CbcHmac,
263        ));
264        let mut cipher = encrypt(&key_store, login_view());
265        // Password encrypted under an unrelated key, so it cannot decrypt here.
266        let foreign = encrypt(&other_store, login_view());
267        cipher.login.as_mut().unwrap().password = foreign.login.unwrap().password;
268
269        let result = cipher.change_login_password(&key_store, "new-password");
270
271        assert!(matches!(result, Err(ChangeLoginPasswordError::Crypto(_))));
272    }
273}