1use bitwarden_api_api::models::{CipherCreateRequestModel, CipherRequestModel};
2use bitwarden_collections::collection::CollectionId;
3use bitwarden_core::{
4 ApiError, MissingFieldError, NotAuthenticatedError, OrganizationId, UserId,
5 key_management::KeySlotIds, require,
6};
7use bitwarden_crypto::{CryptoError, IdentifyKey, KeyStore};
8use bitwarden_error::bitwarden_error;
9use bitwarden_state::repository::{Repository, RepositoryError};
10use chrono::{DateTime, Utc};
11use serde::{Deserialize, Serialize};
12use thiserror::Error;
13
14use super::CiphersClient;
15use crate::{
16 Cipher, CipherRepromptType, CipherView, FieldView, FolderId, VaultParseError,
17 cipher::cipher::{EncryptMode, PartialCipher, StrictDecrypt},
18 cipher_view_type::CipherViewType,
19};
20
21#[allow(missing_docs)]
22#[bitwarden_error(flat)]
23#[derive(Debug, Error)]
24pub enum CreateCipherError {
25 #[error(transparent)]
26 Crypto(#[from] CryptoError),
27 #[error(transparent)]
28 Api(#[from] ApiError),
29 #[error(transparent)]
30 VaultParse(#[from] VaultParseError),
31 #[error(transparent)]
32 MissingField(#[from] MissingFieldError),
33 #[error(transparent)]
34 NotAuthenticated(#[from] NotAuthenticatedError),
35 #[error(transparent)]
36 Repository(#[from] RepositoryError),
37}
38
39#[derive(Serialize, Deserialize, Clone, Debug)]
41#[serde(rename_all = "camelCase")]
42#[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
43#[bitwarden_ffi::wasm_record]
44pub struct CipherCreateRequest {
45 pub organization_id: Option<OrganizationId>,
47 pub collection_ids: Vec<CollectionId>,
49 pub folder_id: Option<FolderId>,
51 pub name: String,
53 pub notes: Option<String>,
55 pub favorite: bool,
57 pub reprompt: CipherRepromptType,
59 pub r#type: CipherViewType,
61 pub fields: Vec<FieldView>,
63 #[serde(skip_serializing_if = "Option::is_none")]
65 pub archived_date: Option<DateTime<Utc>>,
66}
67
68pub(crate) fn convert_request_to_cipher_view(r: CipherCreateRequest) -> CipherView {
75 let now = chrono::Utc::now();
78 CipherView {
79 partial: false,
80 id: None,
81 organization_id: r.organization_id,
82 folder_id: r.folder_id,
83 collection_ids: r.collection_ids,
84 key: None,
85 name: r.name,
86 notes: r.notes,
87 r#type: r.r#type.get_cipher_type(),
88 login: r.r#type.as_login_view().cloned(),
89 identity: r.r#type.as_identity_view().cloned(),
90 card: r.r#type.as_card_view().cloned(),
91 secure_note: r.r#type.as_secure_note_view().cloned(),
92 ssh_key: r.r#type.as_ssh_key_view().cloned(),
93 bank_account: r.r#type.as_bank_account_view().cloned(),
94 drivers_license: r.r#type.as_drivers_license_view().cloned(),
95 passport: r.r#type.as_passport_view().cloned(),
96 favorite: r.favorite,
97 reprompt: r.reprompt,
98 organization_use_totp: false,
99 edit: true,
100 permissions: None,
101 view_password: true,
102 local_data: None,
103 attachments: None,
104 attachment_decryption_failures: None,
105 fields: Some(r.fields),
106 password_history: None,
107 creation_date: now,
108 deleted_date: None,
109 revision_date: now,
110 archived_date: r.archived_date,
111 }
112}
113
114async fn create_cipher<R: Repository<Cipher> + ?Sized>(
115 key_store: &KeyStore<KeySlotIds>,
116 api_client: &bitwarden_api_api::apis::ApiClient,
117 repository: &R,
118 encrypted_for: UserId,
119 view: CipherView,
120 use_strict_decryption: bool,
121 use_blob: bool,
122) -> Result<CipherView, CreateCipherError> {
123 let collection_ids = view.collection_ids.clone();
124 let encrypted_by_key_id = key_store
125 .context()
126 .get_symmetric_key_id(view.key_identifier())
127 .map(|id| id.to_string());
128 let mode = if use_blob {
129 EncryptMode::Blob(view)
130 } else {
131 EncryptMode::Legacy(view)
132 };
133 let cipher: Cipher = key_store.encrypt(mode)?;
134 let mut cipher_request: CipherRequestModel = cipher.try_into()?;
135 cipher_request.encrypted_for = Some(encrypted_for.into());
136 cipher_request.encrypted_by_key_id = encrypted_by_key_id;
137
138 let mut cipher: Cipher;
139 if !collection_ids.is_empty() {
140 cipher = api_client
141 .ciphers_api()
142 .post_create(Some(CipherCreateRequestModel {
143 collection_ids: Some(collection_ids.iter().cloned().map(Into::into).collect()),
144 cipher: Box::new(cipher_request),
145 }))
146 .await?
147 .merge_with_cipher(None)?;
148 cipher.collection_ids = collection_ids;
149 repository.set(require!(cipher.id), cipher.clone()).await?;
150 } else {
151 cipher = api_client
152 .ciphers_api()
153 .post(Some(cipher_request))
154 .await?
155 .merge_with_cipher(None)?;
156 repository.set(require!(cipher.id), cipher.clone()).await?;
157 }
158
159 Ok(if use_strict_decryption {
160 key_store.decrypt(&StrictDecrypt(cipher))?
161 } else {
162 key_store.decrypt(&cipher)?
163 })
164}
165
166#[allow(deprecated)]
167#[bitwarden_ffi::wasm_export]
168impl CiphersClient {
169 pub async fn create(
171 &self,
172 request: CipherCreateRequest,
173 ) -> Result<CipherView, CreateCipherError> {
174 let key_store = self.client.internal.get_key_store();
175 let config = self.client.internal.get_api_configurations();
176 let repository = self.get_repository()?;
177
178 let user_id = self
179 .client
180 .internal
181 .get_user_id()
182 .ok_or(NotAuthenticatedError)?;
183
184 let view: CipherView = convert_request_to_cipher_view(request);
185
186 let use_blob = self.should_use_blob_encryption(view.organization_id);
187
188 create_cipher(
189 key_store,
190 &config.api_client,
191 repository.as_ref(),
192 user_id,
193 view,
194 self.is_strict_decrypt().await,
195 use_blob,
196 )
197 .await
198 }
199}
200
201#[cfg(test)]
202mod tests {
203 use bitwarden_api_api::{apis::ApiClient, models::CipherResponseModel};
204 use bitwarden_core::key_management::SymmetricKeySlotId;
205 use bitwarden_crypto::SymmetricKeyAlgorithm;
206 use bitwarden_test::MemoryRepository;
207 use chrono::Utc;
208
209 use super::*;
210 use crate::{CipherId, LoginView};
211
212 const TEST_CIPHER_ID: &str = "5faa9684-c793-4a2d-8a12-b33900187097";
213 const TEST_COLLECTION_ID: &str = "73546b86-8802-4449-ad2a-69ea981b4ffd";
214 const TEST_USER_ID: &str = "550e8400-e29b-41d4-a716-446655440000";
215 const TEST_ORG_ID: &str = "1bc9ac1e-f5aa-45f2-94bf-b181009709b8";
216
217 fn generate_test_cipher_create_request() -> CipherCreateRequest {
218 CipherCreateRequest {
219 name: "Test Login".to_string(),
220 notes: Some("Test notes".to_string()),
221 r#type: CipherViewType::Login(LoginView {
222 username: Some("[email protected]".to_string()),
223 password: Some("password123".to_string()),
224 password_revision_date: None,
225 uris: None,
226 totp: None,
227 autofill_on_page_load: None,
228 http_authentication_enabled: None,
229 fido2_credentials: None,
230 }),
231 organization_id: Default::default(),
232 folder_id: Default::default(),
233 favorite: Default::default(),
234 reprompt: Default::default(),
235 fields: Default::default(),
236 collection_ids: vec![],
237 archived_date: None,
238 }
239 }
240
241 #[tokio::test]
242 async fn test_create_cipher() {
243 let store: KeyStore<KeySlotIds> = KeyStore::default();
244 {
245 let mut ctx = store.context_mut();
246 let local_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
247 ctx.persist_symmetric_key(local_key_id, SymmetricKeySlotId::User)
248 .unwrap();
249 }
250
251 let cipher_id: CipherId = TEST_CIPHER_ID.parse().unwrap();
252
253 let api_client = ApiClient::new_mocked(move |mock| {
254 mock.ciphers_api
255 .expect_post()
256 .returning(move |body| {
257 let body = body.unwrap();
258 Ok(CipherResponseModel {
259 object: Some("cipher".to_string()),
260 id: Some(cipher_id.into()),
261 name: body.name.clone(),
262 r#type: body.r#type,
263 organization_id: body
264 .organization_id
265 .as_ref()
266 .and_then(|id| uuid::Uuid::parse_str(id).ok()),
267 folder_id: body
268 .folder_id
269 .as_ref()
270 .and_then(|id| uuid::Uuid::parse_str(id).ok()),
271 favorite: body.favorite,
272 reprompt: body.reprompt,
273 key: body.key.clone(),
274 notes: body.notes.clone(),
275 view_password: Some(true),
276 edit: Some(true),
277 organization_use_totp: Some(true),
278 revision_date: Some("2025-01-01T00:00:00Z".to_string()),
279 creation_date: Some("2025-01-01T00:00:00Z".to_string()),
280 deleted_date: None,
281 login: body.login,
282 card: body.card,
283 identity: body.identity,
284 secure_note: body.secure_note,
285 ssh_key: body.ssh_key,
286 bank_account: body.bank_account,
287 drivers_license: body.drivers_license,
288 passport: body.passport,
289 fields: body.fields,
290 password_history: body.password_history,
291 attachments: None,
292 permissions: None,
293 data: None,
294 partial_data: None,
295 archived_date: None,
296 })
297 })
298 .once();
299 });
300
301 let repository = MemoryRepository::<Cipher>::default();
302 let request = generate_test_cipher_create_request();
303
304 let result = create_cipher(
305 &store,
306 &api_client,
307 &repository,
308 TEST_USER_ID.parse().unwrap(),
309 convert_request_to_cipher_view(request),
310 false,
311 false,
312 )
313 .await
314 .unwrap();
315
316 assert_eq!(result.id, Some(cipher_id));
317 assert_eq!(result.name, "Test Login");
318 assert_eq!(
319 result.login,
320 Some(LoginView {
321 username: Some("[email protected]".to_string()),
322 password: Some("password123".to_string()),
323 password_revision_date: None,
324 uris: None,
325 totp: None,
326 autofill_on_page_load: None,
327 http_authentication_enabled: None,
328 fido2_credentials: None,
329 })
330 );
331
332 let stored_cipher_view: CipherView = store
334 .decrypt(&repository.get(cipher_id).await.unwrap().unwrap())
335 .unwrap();
336 assert_eq!(stored_cipher_view.id, result.id);
337 assert_eq!(stored_cipher_view.name, result.name);
338 assert_eq!(stored_cipher_view.r#type, result.r#type);
339 assert!(stored_cipher_view.login.is_some());
340 assert_eq!(stored_cipher_view.favorite, result.favorite);
341 }
342
343 #[tokio::test]
344 async fn test_create_cipher_http_error() {
345 let store: KeyStore<KeySlotIds> = KeyStore::default();
346 {
347 let mut ctx = store.context_mut();
348 let local_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
349 ctx.persist_symmetric_key(local_key_id, SymmetricKeySlotId::User)
350 .unwrap();
351 }
352
353 let api_client = ApiClient::new_mocked(move |mock| {
354 mock.ciphers_api
355 .expect_post()
356 .returning(move |_body| Err(std::io::Error::other("Simulated error").into()));
357 });
358
359 let repository = MemoryRepository::<Cipher>::default();
360
361 let request = generate_test_cipher_create_request();
362
363 let result = create_cipher(
364 &store,
365 &api_client,
366 &repository,
367 TEST_USER_ID.parse().unwrap(),
368 convert_request_to_cipher_view(request),
369 false,
370 false,
371 )
372 .await;
373
374 assert!(result.is_err());
375 assert!(matches!(result.unwrap_err(), CreateCipherError::Api(_)));
376 }
377
378 #[tokio::test]
379 async fn test_create_org_cipher() {
380 let api_client = ApiClient::new_mocked(move |mock| {
381 mock.ciphers_api
382 .expect_post_create()
383 .returning(move |body| {
384 let request_body = body.unwrap();
385
386 Ok(CipherResponseModel {
387 id: Some(TEST_CIPHER_ID.try_into().unwrap()),
388 organization_id: request_body
389 .cipher
390 .organization_id
391 .and_then(|id| id.parse().ok()),
392 name: request_body.cipher.name.clone(),
393 r#type: request_body.cipher.r#type,
394 key: request_body.cipher.key.clone(),
395 creation_date: Some(Utc::now().to_string()),
396 revision_date: Some(Utc::now().to_string()),
397 ..Default::default()
398 })
399 })
400 .once();
401 });
402
403 let store: KeyStore<KeySlotIds> = KeyStore::default();
404 {
405 let mut ctx = store.context_mut();
406 let local_key_id = ctx.make_symmetric_key(SymmetricKeyAlgorithm::Aes256CbcHmac);
407 ctx.persist_symmetric_key(
408 local_key_id,
409 SymmetricKeySlotId::Organization(TEST_ORG_ID.parse().unwrap()),
410 )
411 .unwrap();
412 }
413 let repository = MemoryRepository::<Cipher>::default();
414 let request = CipherCreateRequest {
415 organization_id: Some(TEST_ORG_ID.parse().unwrap()),
416 collection_ids: vec![TEST_COLLECTION_ID.parse().unwrap()],
417 folder_id: None,
418 name: "Test Cipher".into(),
419 notes: None,
420 favorite: false,
421 reprompt: CipherRepromptType::None,
422 r#type: CipherViewType::Login(LoginView {
423 username: None,
424 password: None,
425 password_revision_date: None,
426 uris: None,
427 totp: None,
428 autofill_on_page_load: None,
429 http_authentication_enabled: None,
430 fido2_credentials: None,
431 }),
432 fields: vec![],
433 archived_date: None,
434 };
435
436 let response = create_cipher(
437 &store,
438 &api_client,
439 &repository,
440 TEST_USER_ID.parse().unwrap(),
441 convert_request_to_cipher_view(request),
442 false,
443 false,
444 )
445 .await
446 .unwrap();
447
448 let cipher: Cipher = repository
449 .get(TEST_CIPHER_ID.parse().unwrap())
450 .await
451 .unwrap()
452 .unwrap();
453 let cipher_view: CipherView = store.decrypt(&cipher).unwrap();
454
455 assert_eq!(response.id, cipher_view.id);
456 assert_eq!(response.organization_id, cipher_view.organization_id);
457 assert_eq!(cipher_view.name, "Test Cipher");
458
459 assert_eq!(response.id, Some(TEST_CIPHER_ID.parse().unwrap()));
460 assert_eq!(response.organization_id, Some(TEST_ORG_ID.parse().unwrap()));
461 }
462}