Skip to main content

bitwarden_vault/cipher/cipher_client/admin/
edit.rs

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    /// `edit` was handed a partial view as the original.
47    #[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    // CipherMiniResponseModel does not include folder_id or favorite — save them from the
62    // request before it is consumed so they can be applied to the merged result.
63    let folder_id = request.folder_id;
64    let favorite = request.favorite;
65
66    // A partial original has every secret field stripped: password history diffed against it
67    // would drop the item's real history. The encrypt of the merge original below would also
68    // refuse it (EncryptRestrictedView), but only incidentally — fail clearly and first.
69    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    // Admin endpoints operate on organization-owned ciphers, which aren't
77    // expected to use blob encryption yet — `should_use_blob_encryption`
78    // returns `false` for any `Some(org)` today. Routing through the same
79    // dispatcher means org blob support (PM-32430) flips on automatically
80    // here when the helper learns to return `true` for orgs.
81    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
118/// Adds the cipher matched by [CipherId] to any number of collections on the server.
119pub 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    /// Edit an existing [Cipher] and save it to the server.
150    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    /// Adds the cipher matched by [CipherId] to any number of collections on the server.
179    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        // Change folder: request carries folder_b, original has folder_a.
311        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        // folder_id must come from the request, not from the original cipher.
330        assert_eq!(result.folder_id, Some(folder_b));
331    }
332
333    /// A blob edit must use the `data` blob the server returns, not the stale
334    /// pre-edit blob re-sealed from the original view.
335    #[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        // Echo the request's blob (`key` + `data`) back, as the server does.
347        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, // use_blob
379        )
380        .await
381        .unwrap();
382
383        // The edited name lives inside the blob, so recovering it proves the
384        // echoed blob was used rather than the stale original.
385        assert_eq!(result.name, "New Cipher Name");
386    }
387
388    /// A partial original has every secret field stripped, so building on it would drop the
389    /// item's real password history. The guard must fire before any request is built.
390    #[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        // Deliberately no `expect_put_admin`: the guard has to fire before any request is built.
400        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        // `CipherEditRequest` carries no `partial` field, so only the original view can gate.
406        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}