1use bitwarden_api_api::{
2 apis::ApiClient,
3 models::{CipherCollectionsRequestModel, CipherRequestModel},
4};
5use bitwarden_collections::collection::CollectionId;
6use bitwarden_core::{
7 ApiError, MissingFieldError, NotAuthenticatedError, UserId, key_management::KeySlotIds,
8};
9use bitwarden_crypto::{CryptoError, IdentifyKey, KeyStore};
10use bitwarden_error::bitwarden_error;
11use bitwarden_state::repository::RepositoryError;
12use thiserror::Error;
13
14use super::CipherAdminClient;
15use crate::{
16 Cipher, CipherId, CipherView, DecryptError, ItemNotFoundError, VaultParseError,
17 cipher::cipher::{EncryptMode, PartialCipher, StrictDecrypt},
18 cipher_client::{
19 edit::{CipherEditRequest, convert_request_to_cipher_view},
20 should_use_blob_encryption,
21 },
22};
23
24#[allow(missing_docs)]
25#[bitwarden_error(flat)]
26#[derive(Debug, Error)]
27pub enum EditCipherAdminError {
28 #[error(transparent)]
29 ItemNotFound(#[from] ItemNotFoundError),
30 #[error(transparent)]
31 Crypto(#[from] CryptoError),
32 #[error(transparent)]
33 Api(#[from] ApiError),
34 #[error(transparent)]
35 VaultParse(#[from] VaultParseError),
36 #[error(transparent)]
37 MissingField(#[from] MissingFieldError),
38 #[error(transparent)]
39 NotAuthenticated(#[from] NotAuthenticatedError),
40 #[error(transparent)]
41 Repository(#[from] RepositoryError),
42 #[error(transparent)]
43 Uuid(#[from] uuid::Error),
44 #[error(transparent)]
45 Decrypt(#[from] DecryptError),
46 #[error("Editing a PAM-gated cipher requires a full original; the supplied view is partial")]
48 PartialOriginal,
49}
50
51async fn edit_cipher(
52 key_store: &KeyStore<KeySlotIds>,
53 api_client: &bitwarden_api_api::apis::ApiClient,
54 encrypted_for: UserId,
55 original_cipher_view: CipherView,
56 request: CipherEditRequest,
57 use_strict_decryption: bool,
58 use_blob: bool,
59) -> Result<CipherView, EditCipherAdminError> {
60 let cipher_id = request.id;
61 let folder_id = request.folder_id;
64 let favorite = request.favorite;
65
66 if original_cipher_view.partial {
70 return Err(EditCipherAdminError::PartialOriginal);
71 }
72
73 let mut view: CipherView = convert_request_to_cipher_view(request);
74 view.update_password_history(&original_cipher_view);
75
76 let encrypted_by_key_id = key_store
82 .context()
83 .get_symmetric_key_id(view.key_identifier())
84 .map(|id| id.to_string());
85 let mode = if use_blob {
86 EncryptMode::Blob(view)
87 } else {
88 EncryptMode::Legacy(view)
89 };
90 let cipher: Cipher = key_store.encrypt(mode)?;
91 let mut cipher_request: CipherRequestModel = cipher.try_into()?;
92 cipher_request.encrypted_for = Some(encrypted_for.into());
93 cipher_request.encrypted_by_key_id = encrypted_by_key_id;
94
95 let orig_mode = if use_blob {
96 EncryptMode::Blob(original_cipher_view)
97 } else {
98 EncryptMode::Legacy(original_cipher_view)
99 };
100 let orig_cipher = key_store.encrypt(orig_mode)?;
101
102 let mut cipher: Cipher = api_client
103 .ciphers_api()
104 .put_admin(cipher_id.into(), Some(cipher_request))
105 .await?
106 .merge_with_cipher(Some(orig_cipher))?;
107
108 cipher.folder_id = folder_id;
109 cipher.favorite = favorite;
110
111 Ok(if use_strict_decryption {
112 key_store.decrypt(&StrictDecrypt(cipher))?
113 } else {
114 key_store.decrypt(&cipher)?
115 })
116}
117
118pub async fn add_to_collections(
120 cipher_id: CipherId,
121 collection_ids: Vec<CollectionId>,
122 api_client: &ApiClient,
123 key_store: &KeyStore<KeySlotIds>,
124 use_strict_decryption: bool,
125) -> Result<CipherView, EditCipherAdminError> {
126 let req = CipherCollectionsRequestModel {
127 collection_ids: collection_ids
128 .into_iter()
129 .map(|id| id.to_string())
130 .collect(),
131 };
132
133 let api = api_client.ciphers_api();
134 let cipher: Cipher = api
135 .put_collections_admin(&cipher_id.to_string(), Some(req))
136 .await?
137 .merge_with_cipher(None)?;
138
139 Ok(if use_strict_decryption {
140 key_store.decrypt(&StrictDecrypt(cipher))?
141 } else {
142 key_store.decrypt(&cipher)?
143 })
144}
145
146#[allow(deprecated)]
147#[bitwarden_ffi::wasm_export]
148impl CipherAdminClient {
149 pub async fn edit(
151 &self,
152 request: CipherEditRequest,
153 original_cipher_view: CipherView,
154 ) -> Result<CipherView, EditCipherAdminError> {
155 let key_store = self.client.internal.get_key_store();
156 let config = self.client.internal.get_api_configurations();
157
158 let user_id = self
159 .client
160 .internal
161 .get_user_id()
162 .ok_or(NotAuthenticatedError)?;
163
164 let use_blob = should_use_blob_encryption(&key_store.context(), request.organization_id);
165
166 edit_cipher(
167 key_store,
168 &config.api_client,
169 user_id,
170 original_cipher_view,
171 request,
172 self.is_strict_decrypt().await,
173 use_blob,
174 )
175 .await
176 }
177
178 pub async fn update_collection(
180 &self,
181 cipher_id: CipherId,
182 collection_ids: Vec<CollectionId>,
183 ) -> Result<CipherView, EditCipherAdminError> {
184 add_to_collections(
185 cipher_id,
186 collection_ids,
187 &self.client.internal.get_api_configurations().api_client,
188 self.client.internal.get_key_store(),
189 self.is_strict_decrypt().await,
190 )
191 .await
192 }
193}
194
195#[cfg(test)]
196mod tests {
197 use bitwarden_api_api::{apis::ApiClient, models::CipherMiniResponseModel};
198 use bitwarden_core::key_management::SymmetricKeySlotId;
199 use bitwarden_crypto::{KeyStore, SymmetricCryptoKey, SymmetricKeyAlgorithm};
200
201 use super::*;
202 use crate::{CipherId, CipherRepromptType, CipherType, LoginView};
203
204 const TEST_CIPHER_ID: &str = "5faa9684-c793-4a2d-8a12-b33900187097";
205 const TEST_USER_ID: &str = "550e8400-e29b-41d4-a716-446655440000";
206
207 fn generate_test_cipher() -> CipherView {
208 CipherView {
209 partial: false,
210 id: Some(TEST_CIPHER_ID.parse().unwrap()),
211 organization_id: None,
212 folder_id: None,
213 collection_ids: vec![],
214 key: None,
215 name: "Test Login".to_string(),
216 notes: None,
217 r#type: CipherType::Login,
218 login: Some(LoginView {
219 username: Some("[email protected]".to_string()),
220 password: Some("password123".to_string()),
221 password_revision_date: None,
222 uris: None,
223 totp: None,
224 autofill_on_page_load: None,
225 http_authentication_enabled: None,
226 fido2_credentials: None,
227 }),
228 identity: None,
229 card: None,
230 secure_note: None,
231 ssh_key: None,
232 bank_account: None,
233 drivers_license: None,
234 passport: None,
235 favorite: false,
236 reprompt: CipherRepromptType::None,
237 organization_use_totp: true,
238 edit: true,
239 permissions: None,
240 view_password: true,
241 local_data: None,
242 attachments: None,
243 attachment_decryption_failures: None,
244 fields: None,
245 password_history: None,
246 creation_date: "2025-01-01T00:00:00Z".parse().unwrap(),
247 deleted_date: None,
248 revision_date: "2025-01-01T00:00:00Z".parse().unwrap(),
249 archived_date: None,
250 }
251 }
252
253 #[tokio::test]
254 async fn test_edit_cipher() {
255 let store: KeyStore<KeySlotIds> = KeyStore::default();
256 #[allow(deprecated)]
257 let _ = store.context_mut().set_symmetric_key(
258 SymmetricKeySlotId::User,
259 SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
260 );
261
262 let cipher_id: CipherId = TEST_CIPHER_ID.parse().unwrap();
263
264 let api_client = ApiClient::new_mocked(move |mock| {
265 mock.ciphers_api
266 .expect_put_admin()
267 .returning(move |_id, body| {
268 let body = body.unwrap();
269 Ok(CipherMiniResponseModel {
270 object: Some("cipher".to_string()),
271 id: Some(cipher_id.into()),
272 name: body.name,
273 r#type: body.r#type,
274 organization_id: body
275 .organization_id
276 .as_ref()
277 .and_then(|id| uuid::Uuid::parse_str(id).ok()),
278 reprompt: body.reprompt,
279 key: body.key,
280 notes: body.notes,
281 organization_use_totp: Some(true),
282 revision_date: Some("2025-01-01T00:00:00Z".to_string()),
283 creation_date: Some("2025-01-01T00:00:00Z".to_string()),
284 deleted_date: None,
285 login: body.login,
286 card: body.card,
287 identity: body.identity,
288 secure_note: body.secure_note,
289 ssh_key: body.ssh_key,
290 bank_account: body.bank_account,
291 drivers_license: body.drivers_license,
292 passport: body.passport,
293 fields: body.fields,
294 password_history: body.password_history,
295 attachments: None,
296 data: None,
297 partial_data: None,
298 })
299 })
300 .once();
301 });
302
303 let folder_a: crate::FolderId = "a4e13cc0-1234-5678-abcd-b181009709b8".parse().unwrap();
304 let folder_b: crate::FolderId = "b5e13cc0-1234-5678-abcd-b181009709b8".parse().unwrap();
305
306 let mut original_cipher_view = generate_test_cipher();
307 original_cipher_view.folder_id = Some(folder_a);
308 let mut cipher_view = original_cipher_view.clone();
309 cipher_view.name = "New Cipher Name".to_string();
310 cipher_view.folder_id = Some(folder_b);
312
313 let request: CipherEditRequest = cipher_view.try_into().unwrap();
314
315 let result = edit_cipher(
316 &store,
317 &api_client,
318 TEST_USER_ID.parse().unwrap(),
319 original_cipher_view,
320 request,
321 false,
322 false,
323 )
324 .await
325 .unwrap();
326
327 assert_eq!(result.id, Some(cipher_id));
328 assert_eq!(result.name, "New Cipher Name");
329 assert_eq!(result.folder_id, Some(folder_b));
331 }
332
333 #[tokio::test]
336 async fn test_edit_cipher_blob_uses_echoed_data() {
337 let store: KeyStore<KeySlotIds> = KeyStore::default();
338 #[allow(deprecated)]
339 let _ = store.context_mut().set_symmetric_key(
340 SymmetricKeySlotId::User,
341 SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
342 );
343
344 let cipher_id: CipherId = TEST_CIPHER_ID.parse().unwrap();
345
346 let api_client = ApiClient::new_mocked(move |mock| {
348 mock.ciphers_api
349 .expect_put_admin()
350 .returning(move |_id, body| {
351 let body = body.unwrap();
352 Ok(CipherMiniResponseModel {
353 id: Some(cipher_id.into()),
354 r#type: body.r#type,
355 key: body.key,
356 data: body.data,
357 creation_date: Some("2025-01-01T00:00:00Z".to_string()),
358 revision_date: Some("2025-01-01T00:00:00Z".to_string()),
359 ..Default::default()
360 })
361 })
362 .once();
363 });
364
365 let original_cipher_view = generate_test_cipher();
366 let mut cipher_view = original_cipher_view.clone();
367 cipher_view.name = "New Cipher Name".to_string();
368
369 let request: CipherEditRequest = cipher_view.try_into().unwrap();
370
371 let result = edit_cipher(
372 &store,
373 &api_client,
374 TEST_USER_ID.parse().unwrap(),
375 original_cipher_view,
376 request,
377 false,
378 true, )
380 .await
381 .unwrap();
382
383 assert_eq!(result.name, "New Cipher Name");
386 }
387
388 #[tokio::test]
391 async fn test_edit_refuses_a_partial_original() {
392 let store: KeyStore<KeySlotIds> = KeyStore::default();
393 #[allow(deprecated)]
394 let _ = store.context_mut().set_symmetric_key(
395 SymmetricKeySlotId::User,
396 SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
397 );
398
399 let api_client = ApiClient::new_mocked(|_mock| {});
401
402 let mut original_cipher_view = generate_test_cipher();
403 original_cipher_view.partial = true;
404 let cipher_view = original_cipher_view.clone();
405 let request: CipherEditRequest = cipher_view.try_into().unwrap();
407
408 let result = edit_cipher(
409 &store,
410 &api_client,
411 TEST_USER_ID.parse().unwrap(),
412 original_cipher_view,
413 request,
414 false,
415 false,
416 )
417 .await;
418
419 assert!(matches!(result, Err(EditCipherAdminError::PartialOriginal)));
420 }
421
422 #[tokio::test]
423 async fn test_edit_cipher_http_error() {
424 let store: KeyStore<KeySlotIds> = KeyStore::default();
425 #[allow(deprecated)]
426 let _ = store.context_mut().set_symmetric_key(
427 SymmetricKeySlotId::User,
428 SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
429 );
430
431 let api_client = ApiClient::new_mocked(move |mock| {
432 mock.ciphers_api
433 .expect_put_admin()
434 .returning(move |_id, _body| Err(std::io::Error::other("Simulated error").into()));
435 });
436 let orig_cipher_view = generate_test_cipher();
437 let cipher_view = orig_cipher_view.clone();
438 let request: CipherEditRequest = cipher_view.try_into().unwrap();
439 let result = edit_cipher(
440 &store,
441 &api_client,
442 TEST_USER_ID.parse().unwrap(),
443 orig_cipher_view,
444 request,
445 false,
446 false,
447 )
448 .await;
449
450 assert!(result.is_err());
451 assert!(matches!(result.unwrap_err(), EditCipherAdminError::Api(_)));
452 }
453}