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#[bitwarden_error(flat)]
13#[derive(Debug, Error)]
14pub enum ChangeLoginPasswordError {
15 #[error("Cannot change the password of a partial cipher")]
17 PartialCipher,
18 #[error("Cannot change the login password of a cipher that is not a login")]
20 NotLogin,
21 #[error(transparent)]
23 Crypto(#[from] CryptoError),
24}
25
26impl Cipher {
27 pub fn change_login_password(
30 self,
31 key_store: &KeyStore<KeySlotIds>,
32 new_password: &str,
33 ) -> Result<Cipher, ChangeLoginPasswordError> {
34 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 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 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 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 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}