Wip json export for Apple

Author: Hinton

crates/bitwarden-exporters/src/client_exporter.rs

@@ -2,7 +2,7 @@ use bitwarden_core::Client;
 use bitwarden_vault::{Cipher, Collection, Folder};
 
 use crate::{
-    export::{export_organization_vault, export_vault},
+    export::{export_cxf, export_organization_vault, export_vault},
     ExportError, ExportFormat,
 };
 
@@ -32,6 +32,10 @@ impl<'a> ClientExporters<'a> {
     ) -> Result<String, ExportError> {
         export_organization_vault(collections, ciphers, format)
     }
+
+    pub fn export_cxf(&self, ciphers: Vec<Cipher>) -> Result<String, ExportError> {
+        export_cxf(self.client, ciphers)
+    }
 }
 
 pub trait ClientExportersExt<'a> {

crates/bitwarden-exporters/src/cxp/error.rs

@@ -0,0 +1,7 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum CxpError {
+    #[error("JSON error: {0}")]
+    Serde(#[from] serde_json::Error),
+}

crates/bitwarden-exporters/src/cxp.rs renamed to crates/bitwarden-exporters/src/cxp/mod.rs

@@ -1,10 +1,38 @@
 use bitwarden_crypto::generate_random_bytes;
+use chrono::Utc;
 use credential_exchange_types::{
-    format::{BasicAuthCredential, Credential, EditableField, FieldType, Item, ItemType},
+    format::{
+        Account, BasicAuthCredential, Credential, EditableField, FieldType, Header, Item, ItemType,
+    },
     B64Url,
 };
 
-use crate::{Cipher, CipherType, Login, LoginUri};
+use crate::{Cipher, CipherType, Login};
+
+mod error;
+pub use error::CxpError;
+
+pub(crate) fn build_cxf(ciphers: Vec<Cipher>) -> Result<String, CxpError> {
+    let items: Vec<Item> = ciphers.into_iter().map(|cipher| cipher.into()).collect();
+
+    let header = Header {
+        version: 0,
+        exporter: "Bitwarden".to_string(),
+        timestamp: Utc::now().timestamp() as u64,
+        accounts: vec![Account {
+            id: todo!(),
+            user_name: todo!(),
+            email: todo!(),
+            full_name: todo!(),
+            icon: todo!(),
+            collections: todo!(),
+            items,
+            extensions: todo!(),
+        }],
+    };
+
+    Ok(serde_json::to_string(&header)?)
+}
 
 impl From<Cipher> for Item {
     fn from(value: Cipher) -> Self {

crates/bitwarden-exporters/src/error.rs

@@ -9,6 +9,8 @@ pub enum ExportError {
 
     #[error("CSV error: {0}")]
     Csv(#[from] crate::csv::CsvError),
+    #[error("Credential Exchange error: {0}")]
+    CxpError(#[from] crate::cxp::CxpError),
     #[error("JSON error: {0}")]
     Json(#[from] crate::json::JsonError),
     #[error("Encrypted JSON error: {0}")]

crates/bitwarden-exporters/src/export.rs

@@ -3,8 +3,8 @@ use bitwarden_crypto::KeyDecryptable;
 use bitwarden_vault::{Cipher, CipherView, Collection, Folder, FolderView};
 
 use crate::{
-    csv::export_csv, encrypted_json::export_encrypted_json, json::export_json, ExportError,
-    ExportFormat,
+    csv::export_csv, cxp::build_cxf, encrypted_json::export_encrypted_json, json::export_json,
+    ExportError, ExportFormat,
 };
 
 pub(crate) fn export_vault(
@@ -41,3 +41,13 @@ pub(crate) fn export_organization_vault(
 ) -> Result<String, ExportError> {
     todo!();
 }
+
+pub(crate) fn export_cxf(client: &Client, ciphers: Vec<Cipher>) -> Result<String, ExportError> {
+    let enc = client.internal.get_encryption_settings()?;
+    let key = enc.get_key(&None)?;
+
+    let ciphers: Vec<CipherView> = ciphers.decrypt_with_key(key)?;
+    let ciphers: Vec<crate::Cipher> = ciphers.into_iter().flat_map(|c| c.try_into()).collect();
+
+    Ok(build_cxf(ciphers)?)
+}

crates/bitwarden-uniffi/src/tool/mod.rs

@@ -86,4 +86,17 @@ impl ClientExporters {
             .export_organization_vault(collections, ciphers, format)
             .map_err(Error::ExportError)?)
     }
+
+    /// Credential Exchange Format (CXF)
+    ///
+    /// For use with Apple using [ASCredentialExportManager](https://developer.apple.com/documentation/authenticationservices/ascredentialexportmanager).
+    /// Ideally the output should be immediately deserialized to [ASExportedCredentialData](https://developer.apple.com/documentation/authenticationservices/asexportedcredentialdata).
+    pub fn export_cxf(&self, ciphers: Vec<Cipher>) -> Result<String> {
+        Ok(self
+            .0
+             .0
+            .exporters()
+            .export_cxf(ciphers)
+            .map_err(Error::ExportError)?)
+    }
 }