Skip to main content

bitwarden_vault/cipher/cipher_client/
restore.rs

1use bitwarden_api_api::{apis::ApiClient, models::CipherBulkRestoreRequestModel};
2use bitwarden_core::{ApiError, key_management::KeySlotIds};
3use bitwarden_crypto::{CryptoError, KeyStore};
4use bitwarden_error::bitwarden_error;
5use bitwarden_state::repository::{Repository, RepositoryError};
6use futures::future::OptionFuture;
7use thiserror::Error;
8
9use crate::{
10    Cipher, CipherId, CipherView, CiphersClient, DecryptCipherListResult, VaultParseError,
11    cipher::cipher::{PartialCipher, StrictDecrypt},
12};
13
14#[allow(missing_docs)]
15#[bitwarden_error(flat)]
16#[derive(Debug, Error)]
17pub enum RestoreCipherError {
18    #[error(transparent)]
19    Api(#[from] ApiError),
20    #[error(transparent)]
21    VaultParse(#[from] VaultParseError),
22    #[error(transparent)]
23    Repository(#[from] RepositoryError),
24    #[error(transparent)]
25    Crypto(#[from] CryptoError),
26}
27
28/// Restores a soft-deleted cipher on the server.
29pub async fn restore<R: Repository<Cipher> + ?Sized>(
30    cipher_id: CipherId,
31    api_client: &ApiClient,
32    repository: &R,
33    key_store: &KeyStore<KeySlotIds>,
34    use_strict_decryption: bool,
35) -> Result<CipherView, RestoreCipherError> {
36    let api = api_client.ciphers_api();
37
38    let existing_cipher = repository.get(cipher_id).await?;
39    let cipher: Cipher = api
40        .put_restore(cipher_id.into())
41        .await?
42        .merge_with_cipher(existing_cipher)?;
43    repository.set(cipher_id, cipher.clone()).await?;
44
45    Ok(if use_strict_decryption {
46        key_store.decrypt(&StrictDecrypt(cipher))?
47    } else {
48        key_store.decrypt(&cipher)?
49    })
50}
51
52/// Restores multiple soft-deleted ciphers on the server.
53pub async fn restore_many<R: Repository<Cipher> + ?Sized>(
54    cipher_ids: Vec<CipherId>,
55    api_client: &ApiClient,
56    repository: &R,
57    key_store: &KeyStore<KeySlotIds>,
58    use_strict_decryption: bool,
59) -> Result<DecryptCipherListResult, RestoreCipherError> {
60    let api = api_client.ciphers_api();
61
62    let response_models: Vec<_> = api
63        .put_restore_many(Some(CipherBulkRestoreRequestModel {
64            ids: cipher_ids.into_iter().map(|id| id.to_string()).collect(),
65            organization_id: None,
66        }))
67        .await?
68        .data
69        .into_iter()
70        .flatten()
71        .collect();
72
73    let mut ciphers = Vec::with_capacity(response_models.len());
74    for model in response_models {
75        let existing = OptionFuture::from(model.id.map(|id| repository.get(CipherId::new(id))))
76            .await
77            .transpose()?
78            .flatten();
79        ciphers.push(model.merge_with_cipher(existing)?);
80    }
81
82    for cipher in &ciphers {
83        if let Some(id) = cipher.id {
84            repository.set(id, cipher.clone()).await?;
85        }
86    }
87
88    Ok(if use_strict_decryption {
89        let wrapped: Vec<StrictDecrypt<Cipher>> = ciphers.into_iter().map(StrictDecrypt).collect();
90        let (successes, failures) = key_store.decrypt_list_with_failures(&wrapped);
91        DecryptCipherListResult {
92            successes,
93            failures: failures.into_iter().map(|f| f.0.clone()).collect(),
94        }
95    } else {
96        let (successes, failures) = key_store.decrypt_list_with_failures(&ciphers);
97        DecryptCipherListResult {
98            successes,
99            failures: failures.into_iter().cloned().collect(),
100        }
101    })
102}
103
104#[allow(deprecated)]
105#[bitwarden_ffi::wasm_export]
106impl CiphersClient {
107    /// Restores a soft-deleted cipher on the server.
108    pub async fn restore(&self, cipher_id: CipherId) -> Result<CipherView, RestoreCipherError> {
109        let api_client = &self.client.internal.get_api_configurations().api_client;
110        let key_store = self.client.internal.get_key_store();
111
112        restore(
113            cipher_id,
114            api_client,
115            &*self.get_repository()?,
116            key_store,
117            self.is_strict_decrypt().await,
118        )
119        .await
120    }
121
122    /// Restores multiple soft-deleted ciphers on the server.
123    pub async fn restore_many(
124        &self,
125        cipher_ids: Vec<CipherId>,
126    ) -> Result<DecryptCipherListResult, RestoreCipherError> {
127        let api_client = &self.client.internal.get_api_configurations().api_client;
128        let key_store = self.client.internal.get_key_store();
129        let repository = &*self.get_repository()?;
130
131        restore_many(
132            cipher_ids,
133            api_client,
134            repository,
135            key_store,
136            self.is_strict_decrypt().await,
137        )
138        .await
139    }
140}
141
142#[cfg(test)]
143mod tests {
144    use bitwarden_api_api::{
145        apis::ApiClient,
146        models::{
147            CipherMiniResponseModel, CipherMiniResponseModelListResponseModel, CipherResponseModel,
148        },
149    };
150    use bitwarden_collections::collection::CollectionId;
151    use bitwarden_core::key_management::{KeySlotIds, SymmetricKeySlotId};
152    use bitwarden_crypto::{KeyStore, SymmetricCryptoKey, SymmetricKeyAlgorithm};
153    use bitwarden_state::repository::Repository;
154    use bitwarden_test::MemoryRepository;
155    use chrono::Utc;
156
157    use super::*;
158    use crate::{Cipher, CipherId, Login};
159
160    const TEST_CIPHER_ID: &str = "5faa9684-c793-4a2d-8a12-b33900187097";
161    const TEST_CIPHER_ID_2: &str = "6faa9684-c793-4a2d-8a12-b33900187098";
162
163    fn setup_key_store() -> KeyStore<KeySlotIds> {
164        let store: KeyStore<KeySlotIds> = KeyStore::default();
165        #[allow(deprecated)]
166        let _ = store.context_mut().set_symmetric_key(
167            SymmetricKeySlotId::User,
168            SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
169        );
170        store
171    }
172
173    fn generate_test_cipher() -> Cipher {
174        Cipher {
175            partial_data: None,
176            id: TEST_CIPHER_ID.parse().ok(),
177            name: Some("2.pMS6/icTQABtulw52pq2lg==|XXbxKxDTh+mWiN1HjH2N1w==|Q6PkuT+KX/axrgN9ubD5Ajk2YNwxQkgs3WJM0S0wtG8=".parse().unwrap()),
178            r#type: crate::CipherType::Login,
179            notes: Default::default(),
180            organization_id: Default::default(),
181            folder_id: Default::default(),
182            favorite: Default::default(),
183            reprompt: Default::default(),
184            fields: Default::default(),
185            collection_ids: Default::default(),
186            key: Default::default(),
187            login: Some(Login{
188                username: None,
189                password: None,
190                password_revision_date: None,
191                uris: None, totp: None,
192                autofill_on_page_load: None,
193                http_authentication_enabled: None,
194                fido2_credentials: None,
195            }),
196            identity: Default::default(),
197            card: Default::default(),
198            secure_note: Default::default(),
199            ssh_key: Default::default(),
200            bank_account: Default::default(),
201            drivers_license: Default::default(),
202            passport: Default::default(),
203            organization_use_totp: Default::default(),
204            edit: Default::default(),
205            permissions: Default::default(),
206            view_password: Default::default(),
207            local_data: Default::default(),
208            attachments: Default::default(),
209            password_history: Default::default(),
210            creation_date: Default::default(),
211            deleted_date: Default::default(),
212            revision_date: Default::default(),
213            archived_date: Default::default(),
214            data: Default::default(),
215        }
216    }
217
218    #[tokio::test]
219    async fn test_restore() {
220        // Set up test ciphers in the repository.
221        let mut cipher_1 = generate_test_cipher();
222        cipher_1.deleted_date = Some(Utc::now());
223
224        let api_client = ApiClient::new_mocked(move |mock| {
225            mock.ciphers_api
226                .expect_put_restore()
227                .returning(move |_model| {
228                    Ok(CipherResponseModel {
229                        id: Some(TEST_CIPHER_ID.try_into().unwrap()),
230                        name: cipher_1.name.as_ref().map(ToString::to_string),
231                        r#type: Some(cipher_1.r#type.into()),
232                        creation_date: Some(cipher_1.creation_date.to_string()),
233                        revision_date: Some(Utc::now().to_string()),
234                        ..Default::default()
235                    })
236                });
237        });
238
239        let repository: MemoryRepository<Cipher> = Default::default();
240        let store: KeyStore<KeySlotIds> = KeyStore::default();
241        #[allow(deprecated)]
242        let _ = store.context_mut().set_symmetric_key(
243            SymmetricKeySlotId::User,
244            SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
245        );
246
247        let collection_id: CollectionId = "a4e13cc0-1234-5678-abcd-b181009709b8".parse().unwrap();
248        let mut cipher = generate_test_cipher();
249        cipher.deleted_date = Some(Utc::now());
250        cipher.collection_ids = vec![collection_id];
251
252        repository
253            .set(TEST_CIPHER_ID.parse().unwrap(), cipher)
254            .await
255            .unwrap();
256
257        let start_time = Utc::now();
258        let updated_cipher = restore(
259            TEST_CIPHER_ID.parse().unwrap(),
260            &api_client,
261            &repository,
262            &store,
263            false,
264        )
265        .await
266        .unwrap();
267
268        let end_time = Utc::now();
269        assert!(updated_cipher.deleted_date.is_none());
270        assert!(
271            updated_cipher.revision_date >= start_time && updated_cipher.revision_date <= end_time
272        );
273        // collection_ids are not returned by the server's restore response — they must be
274        // preserved.
275        assert_eq!(updated_cipher.collection_ids, vec![collection_id]);
276
277        let repo_cipher = repository
278            .get(TEST_CIPHER_ID.parse().unwrap())
279            .await
280            .unwrap()
281            .unwrap();
282        assert!(repo_cipher.deleted_date.is_none());
283        assert!(
284            repo_cipher.revision_date >= start_time && updated_cipher.revision_date <= end_time
285        );
286    }
287
288    #[tokio::test]
289    async fn test_restore_many() {
290        let cipher_id: CipherId = TEST_CIPHER_ID.parse().unwrap();
291        let cipher_id_2: CipherId = TEST_CIPHER_ID_2.parse().unwrap();
292        let collection_id: CollectionId = "a4e13cc0-1234-5678-abcd-b181009709b8".parse().unwrap();
293        let collection_id_2: CollectionId = "b5e13cc0-1234-5678-abcd-b181009709b8".parse().unwrap();
294        let mut cipher_1 = generate_test_cipher();
295        cipher_1.deleted_date = Some(Utc::now());
296        cipher_1.collection_ids = vec![collection_id];
297        let mut cipher_2 = generate_test_cipher();
298        cipher_2.deleted_date = Some(Utc::now());
299        cipher_2.id = Some(cipher_id_2);
300        cipher_2.collection_ids = vec![collection_id_2];
301
302        let api_client = {
303            let cipher_1 = cipher_1.clone();
304            let cipher_2 = cipher_2.clone();
305            ApiClient::new_mocked(move |mock| {
306                mock.ciphers_api.expect_put_restore_many().returning({
307                    move |_model| {
308                        Ok(CipherMiniResponseModelListResponseModel {
309                            object: None,
310                            data: Some(vec![
311                                CipherMiniResponseModel {
312                                    id: cipher_1.id.map(|id| id.into()),
313                                    name: cipher_1.name.as_ref().map(ToString::to_string),
314                                    r#type: Some(cipher_1.r#type.into()),
315                                    login: cipher_1.login.clone().map(|l| Box::new(l.into())),
316                                    creation_date: cipher_1.creation_date.to_string().into(),
317                                    deleted_date: None,
318                                    revision_date: Some(Utc::now().to_string()),
319                                    ..Default::default()
320                                },
321                                CipherMiniResponseModel {
322                                    id: cipher_2.id.map(|id| id.into()),
323                                    name: cipher_2.name.as_ref().map(ToString::to_string),
324                                    r#type: Some(cipher_2.r#type.into()),
325                                    login: cipher_2.login.clone().map(|l| Box::new(l.into())),
326                                    creation_date: cipher_2.creation_date.to_string().into(),
327                                    deleted_date: None,
328                                    revision_date: Some(Utc::now().to_string()),
329                                    ..Default::default()
330                                },
331                            ]),
332                            continuation_token: None,
333                        })
334                    }
335                });
336            })
337        };
338
339        let repository: MemoryRepository<Cipher> = Default::default();
340        let store: KeyStore<KeySlotIds> = KeyStore::default();
341        #[allow(deprecated)]
342        let _ = store.context_mut().set_symmetric_key(
343            SymmetricKeySlotId::User,
344            SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
345        );
346
347        repository.set(cipher_id, cipher_1).await.unwrap();
348        repository.set(cipher_id_2, cipher_2).await.unwrap();
349
350        let start_time = Utc::now();
351        let ciphers = restore_many(
352            vec![cipher_id, cipher_id_2],
353            &api_client,
354            &repository,
355            &store,
356            false,
357        )
358        .await
359        .unwrap();
360        let end_time = Utc::now();
361
362        assert_eq!(ciphers.successes.len(), 2,);
363        assert_eq!(ciphers.failures.len(), 0,);
364        assert_eq!(ciphers.successes[0].deleted_date, None,);
365        assert_eq!(ciphers.successes[1].deleted_date, None,);
366
367        // Confirm repository was updated
368        let cipher_1 = repository.get(cipher_id).await.unwrap().unwrap();
369        let cipher_2 = repository.get(cipher_id_2).await.unwrap().unwrap();
370        assert!(cipher_1.deleted_date.is_none());
371        assert!(cipher_2.deleted_date.is_none());
372        assert!(cipher_1.revision_date >= start_time && cipher_1.revision_date <= end_time);
373        assert!(cipher_2.revision_date >= start_time && cipher_2.revision_date <= end_time);
374    }
375
376    #[tokio::test]
377    async fn test_restore_preserves_collection_ids() {
378        let store = setup_key_store();
379        let collection_id: CollectionId = "a4e13cc0-1234-5678-abcd-b181009709b8".parse().unwrap();
380
381        let mut cipher = generate_test_cipher();
382        cipher.deleted_date = Some(Utc::now());
383        cipher.collection_ids = vec![collection_id];
384
385        let cipher_name = cipher
386            .name
387            .as_ref()
388            .map(ToString::to_string)
389            .unwrap_or_default();
390        let cipher_type = cipher.r#type;
391
392        let api_client = ApiClient::new_mocked(move |mock| {
393            mock.ciphers_api.expect_put_restore().returning(move |_| {
394                Ok(CipherResponseModel {
395                    id: Some(TEST_CIPHER_ID.try_into().unwrap()),
396                    name: Some(cipher_name.clone()),
397                    r#type: Some(cipher_type.into()),
398                    creation_date: Some("2025-01-01T00:00:00Z".to_string()),
399                    revision_date: Some(Utc::now().to_string()),
400                    ..Default::default()
401                })
402            });
403        });
404
405        let repository: MemoryRepository<Cipher> = Default::default();
406        repository
407            .set(TEST_CIPHER_ID.parse().unwrap(), cipher)
408            .await
409            .unwrap();
410
411        let result = restore(
412            TEST_CIPHER_ID.parse().unwrap(),
413            &api_client,
414            &repository,
415            &store,
416            false,
417        )
418        .await
419        .unwrap();
420
421        // collection_ids are not returned by the server's restore response — they must
422        // be preserved from the existing cipher in the repository.
423        assert_eq!(result.collection_ids, vec![collection_id]);
424    }
425
426    #[tokio::test]
427    async fn test_restore_many_preserves_collection_ids() {
428        let store = setup_key_store();
429        let cipher_id: CipherId = TEST_CIPHER_ID.parse().unwrap();
430        let cipher_id_2: CipherId = TEST_CIPHER_ID_2.parse().unwrap();
431        let collection_id: CollectionId = "a4e13cc0-1234-5678-abcd-b181009709b8".parse().unwrap();
432        let collection_id_2: CollectionId = "b5e13cc0-1234-5678-abcd-b181009709b8".parse().unwrap();
433
434        let mut cipher_1 = generate_test_cipher();
435        cipher_1.deleted_date = Some(Utc::now());
436        cipher_1.collection_ids = vec![collection_id];
437
438        let mut cipher_2 = generate_test_cipher();
439        cipher_2.id = Some(cipher_id_2);
440        cipher_2.deleted_date = Some(Utc::now());
441        cipher_2.collection_ids = vec![collection_id_2];
442
443        let api_client = {
444            let cipher_1 = cipher_1.clone();
445            let cipher_2 = cipher_2.clone();
446            ApiClient::new_mocked(move |mock| {
447                mock.ciphers_api.expect_put_restore_many().returning({
448                    move |_| {
449                        Ok(CipherMiniResponseModelListResponseModel {
450                            object: None,
451                            data: Some(vec![
452                                CipherMiniResponseModel {
453                                    id: cipher_1.id.map(|id| id.into()),
454                                    name: cipher_1.name.as_ref().map(ToString::to_string),
455                                    r#type: Some(cipher_1.r#type.into()),
456                                    login: cipher_1.login.clone().map(|l| Box::new(l.into())),
457                                    creation_date: cipher_1.creation_date.to_string().into(),
458                                    deleted_date: None,
459                                    revision_date: Some(Utc::now().to_string()),
460                                    ..Default::default()
461                                },
462                                CipherMiniResponseModel {
463                                    id: cipher_2.id.map(|id| id.into()),
464                                    name: cipher_2.name.as_ref().map(ToString::to_string),
465                                    r#type: Some(cipher_2.r#type.into()),
466                                    login: cipher_2.login.clone().map(|l| Box::new(l.into())),
467                                    creation_date: cipher_2.creation_date.to_string().into(),
468                                    deleted_date: None,
469                                    revision_date: Some(Utc::now().to_string()),
470                                    ..Default::default()
471                                },
472                            ]),
473                            continuation_token: None,
474                        })
475                    }
476                });
477            })
478        };
479
480        let repository: MemoryRepository<Cipher> = Default::default();
481        repository.set(cipher_id, cipher_1).await.unwrap();
482        repository.set(cipher_id_2, cipher_2).await.unwrap();
483
484        let ciphers = restore_many(
485            vec![cipher_id, cipher_id_2],
486            &api_client,
487            &repository,
488            &store,
489            false,
490        )
491        .await
492        .unwrap();
493
494        assert_eq!(ciphers.successes.len(), 2);
495
496        // collection_ids are not returned by the server's restore response — they must
497        // be preserved from the existing ciphers in the repository.
498        let result_1 = ciphers
499            .successes
500            .iter()
501            .find(|c| c.id == Some(cipher_id))
502            .unwrap();
503        let result_2 = ciphers
504            .successes
505            .iter()
506            .find(|c| c.id == Some(cipher_id_2))
507            .unwrap();
508        assert_eq!(result_1.collection_ids, vec![collection_id]);
509        assert_eq!(result_2.collection_ids, vec![collection_id_2]);
510    }
511}