bitwarden_vault/cipher/cipher_client/admin/
restore.rs1use bitwarden_api_api::{apis::ApiClient, models::CipherBulkRestoreRequestModel};
2use bitwarden_core::{ApiError, OrganizationId, key_management::KeySlotIds};
3use bitwarden_crypto::{CryptoError, KeyStore};
4use bitwarden_error::bitwarden_error;
5use thiserror::Error;
6
7use crate::{
8 Cipher, CipherId, CipherView, DecryptCipherListResult, VaultParseError,
9 cipher::cipher::{PartialCipher, StrictDecrypt},
10 cipher_client::admin::CipherAdminClient,
11};
12
13#[allow(missing_docs)]
14#[bitwarden_error(flat)]
15#[derive(Debug, Error)]
16pub enum RestoreCipherAdminError {
17 #[error(transparent)]
18 Api(#[from] ApiError),
19 #[error(transparent)]
20 VaultParse(#[from] VaultParseError),
21 #[error(transparent)]
22 Crypto(#[from] CryptoError),
23}
24
25pub async fn restore_as_admin(
27 cipher_id: CipherId,
28 api_client: &ApiClient,
29 key_store: &KeyStore<KeySlotIds>,
30 use_strict_decryption: bool,
31) -> Result<CipherView, RestoreCipherAdminError> {
32 let api = api_client.ciphers_api();
33
34 let cipher: Cipher = api
35 .put_restore_admin(cipher_id.into())
36 .await?
37 .merge_with_cipher(None)?;
38
39 Ok(if use_strict_decryption {
40 key_store.decrypt(&StrictDecrypt(cipher))?
41 } else {
42 key_store.decrypt(&cipher)?
43 })
44}
45
46pub async fn restore_many_as_admin(
48 cipher_ids: Vec<CipherId>,
49 org_id: OrganizationId,
50 api_client: &ApiClient,
51 key_store: &KeyStore<KeySlotIds>,
52 use_strict_decryption: bool,
53) -> Result<DecryptCipherListResult, RestoreCipherAdminError> {
54 let api = api_client.ciphers_api();
55
56 let ciphers: Vec<Cipher> = api
57 .put_restore_many_admin(Some(CipherBulkRestoreRequestModel {
58 ids: cipher_ids.into_iter().map(|id| id.to_string()).collect(),
59 organization_id: Some(org_id.into()),
60 }))
61 .await?
62 .data
63 .into_iter()
64 .flatten()
65 .map(|c| c.merge_with_cipher(None))
66 .collect::<Result<Vec<_>, _>>()?;
67
68 Ok(if use_strict_decryption {
69 let wrapped: Vec<StrictDecrypt<Cipher>> = ciphers.into_iter().map(StrictDecrypt).collect();
70 let (successes, failures) = key_store.decrypt_list_with_failures(&wrapped);
71 DecryptCipherListResult {
72 successes,
73 failures: failures.into_iter().map(|f| f.0.clone()).collect(),
74 }
75 } else {
76 let (successes, failures) = key_store.decrypt_list_with_failures(&ciphers);
77 DecryptCipherListResult {
78 successes,
79 failures: failures.into_iter().cloned().collect(),
80 }
81 })
82}
83
84#[bitwarden_ffi::wasm_export]
85impl CipherAdminClient {
86 pub async fn restore(
88 &self,
89 cipher_id: CipherId,
90 ) -> Result<CipherView, RestoreCipherAdminError> {
91 let api_client = &self.api_configurations.api_client;
92 let key_store = &self.key_store;
93
94 restore_as_admin(
95 cipher_id,
96 api_client,
97 key_store,
98 self.is_strict_decrypt().await,
99 )
100 .await
101 }
102 pub async fn restore_many(
104 &self,
105 cipher_ids: Vec<CipherId>,
106 org_id: OrganizationId,
107 ) -> Result<DecryptCipherListResult, RestoreCipherAdminError> {
108 let api_client = &self.api_configurations.api_client;
109 let key_store = &self.key_store;
110
111 restore_many_as_admin(
112 cipher_ids,
113 org_id,
114 api_client,
115 key_store,
116 self.is_strict_decrypt().await,
117 )
118 .await
119 }
120}
121
122#[cfg(test)]
123mod tests {
124 use bitwarden_api_api::{
125 apis::ApiClient,
126 models::{CipherMiniResponseModel, CipherMiniResponseModelListResponseModel},
127 };
128 use bitwarden_core::key_management::{KeySlotIds, SymmetricKeySlotId};
129 use bitwarden_crypto::{KeyStore, SymmetricCryptoKey, SymmetricKeyAlgorithm};
130 use chrono::Utc;
131
132 use super::*;
133 use crate::{Cipher, CipherId, Login};
134
135 const TEST_CIPHER_ID: &str = "5faa9684-c793-4a2d-8a12-b33900187097";
136 const TEST_CIPHER_ID_2: &str = "6faa9684-c793-4a2d-8a12-b33900187098";
137 const TEST_ORG_ID: &str = "1bc9ac1e-f5aa-45f2-94bf-b181009709b8";
138
139 fn generate_test_cipher() -> Cipher {
140 Cipher {
141 partial_data: None,
142 id: TEST_CIPHER_ID.parse().ok(),
143 name: Some("2.pMS6/icTQABtulw52pq2lg==|XXbxKxDTh+mWiN1HjH2N1w==|Q6PkuT+KX/axrgN9ubD5Ajk2YNwxQkgs3WJM0S0wtG8=".parse().unwrap()),
144 r#type: crate::CipherType::Login,
145 notes: Default::default(),
146 organization_id: Default::default(),
147 folder_id: Default::default(),
148 favorite: Default::default(),
149 reprompt: Default::default(),
150 fields: Default::default(),
151 collection_ids: Default::default(),
152 key: Default::default(),
153 login: Some(Login{
154 username: None,
155 password: None,
156 password_revision_date: None,
157 uris: None, totp: None,
158 autofill_on_page_load: None,
159 http_authentication_enabled: None,
160 fido2_credentials: None,
161 }),
162 identity: Default::default(),
163 card: Default::default(),
164 secure_note: Default::default(),
165 ssh_key: Default::default(),
166 bank_account: Default::default(),
167 drivers_license: Default::default(),
168 passport: Default::default(),
169 organization_use_totp: Default::default(),
170 edit: Default::default(),
171 permissions: Default::default(),
172 view_password: Default::default(),
173 local_data: Default::default(),
174 attachments: Default::default(),
175 password_history: Default::default(),
176 creation_date: Default::default(),
177 deleted_date: Default::default(),
178 revision_date: Default::default(),
179 archived_date: Default::default(),
180 data: Default::default(),
181 }
182 }
183
184 #[tokio::test]
185 async fn test_restore_as_admin() {
186 let mut cipher = generate_test_cipher();
187 cipher.deleted_date = Some(Utc::now());
188
189 let api_client = {
190 let cipher = cipher.clone();
191 ApiClient::new_mocked(move |mock| {
192 mock.ciphers_api
193 .expect_put_restore_admin()
194 .returning(move |_model| {
195 Ok(CipherMiniResponseModel {
196 id: Some(TEST_CIPHER_ID.try_into().unwrap()),
197 name: cipher.name.as_ref().map(ToString::to_string),
198 r#type: Some(cipher.r#type.into()),
199 creation_date: Some(cipher.creation_date.to_string()),
200 revision_date: Some(Utc::now().to_rfc3339()),
201 login: cipher.login.clone().map(|l| Box::new(l.into())),
202 ..Default::default()
203 })
204 });
205 })
206 };
207
208 let store: KeyStore<KeySlotIds> = KeyStore::default();
209 #[allow(deprecated)]
210 let _ = store.context_mut().set_symmetric_key(
211 SymmetricKeySlotId::User,
212 SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
213 );
214 let start_time = Utc::now();
215 let updated_cipher =
216 restore_as_admin(TEST_CIPHER_ID.parse().unwrap(), &api_client, &store, false)
217 .await
218 .unwrap();
219 let end_time = Utc::now();
220
221 assert!(updated_cipher.deleted_date.is_none());
222 assert!(
223 updated_cipher.revision_date >= start_time && updated_cipher.revision_date <= end_time
224 );
225 }
226
227 #[tokio::test]
228 async fn test_restore_many_as_admin() {
229 let cipher_id_2: CipherId = TEST_CIPHER_ID_2.parse().unwrap();
230 let mut cipher_1 = generate_test_cipher();
231 cipher_1.deleted_date = Some(Utc::now());
232 let mut cipher_2 = generate_test_cipher();
233 cipher_2.deleted_date = Some(Utc::now());
234 cipher_2.id = Some(cipher_id_2);
235
236 let api_client = ApiClient::new_mocked(move |mock| {
237 mock.ciphers_api
238 .expect_put_restore_many_admin()
239 .returning(move |_model| {
240 Ok(CipherMiniResponseModelListResponseModel {
241 object: None,
242 data: Some(vec![
243 CipherMiniResponseModel {
244 id: cipher_1.id.map(|id| id.into()),
245 name: cipher_1.name.as_ref().map(ToString::to_string),
246 r#type: Some(cipher_1.r#type.into()),
247 login: cipher_1.login.clone().map(|l| Box::new(l.into())),
248 creation_date: cipher_1.creation_date.to_string().into(),
249 deleted_date: None,
250 revision_date: Some(Utc::now().to_rfc3339()),
251 ..Default::default()
252 },
253 CipherMiniResponseModel {
254 id: cipher_2.id.map(|id| id.into()),
255 name: cipher_2.name.as_ref().map(ToString::to_string),
256 r#type: Some(cipher_2.r#type.into()),
257 login: cipher_2.login.clone().map(|l| Box::new(l.into())),
258 creation_date: cipher_2.creation_date.to_string().into(),
259 deleted_date: None,
260 revision_date: Some(Utc::now().to_rfc3339()),
261 ..Default::default()
262 },
263 ]),
264 continuation_token: None,
265 })
266 });
267 });
268 let store: KeyStore<KeySlotIds> = KeyStore::default();
269 #[allow(deprecated)]
270 let _ = store.context_mut().set_symmetric_key(
271 SymmetricKeySlotId::User,
272 SymmetricCryptoKey::make(SymmetricKeyAlgorithm::Aes256CbcHmac),
273 );
274
275 let start_time = Utc::now();
276 let ciphers = restore_many_as_admin(
277 vec![
278 TEST_CIPHER_ID.parse().unwrap(),
279 TEST_CIPHER_ID_2.parse().unwrap(),
280 ],
281 TEST_ORG_ID.parse().unwrap(),
282 &api_client,
283 &store,
284 false,
285 )
286 .await
287 .unwrap();
288 let end_time = Utc::now();
289
290 assert_eq!(ciphers.successes.len(), 2,);
291 assert_eq!(ciphers.failures.len(), 0,);
292 assert_eq!(
293 ciphers.successes[0].id,
294 Some(TEST_CIPHER_ID.parse().unwrap()),
295 );
296 assert_eq!(
297 ciphers.successes[1].id,
298 Some(TEST_CIPHER_ID_2.parse().unwrap()),
299 );
300 assert_eq!(ciphers.successes[0].deleted_date, None,);
301 assert_eq!(ciphers.successes[1].deleted_date, None,);
302
303 assert!(
304 ciphers.successes[0].revision_date >= start_time
305 && ciphers.successes[0].revision_date <= end_time
306 );
307 assert!(
308 ciphers.successes[1].revision_date >= start_time
309 && ciphers.successes[1].revision_date <= end_time
310 );
311 }
312}