Initial implementation for converting passwords to BasicAuth

Author: Hinton

Cargo.lock

@@ -23,7 +23,7 @@ bitwarden-core = { workspace = true }
 bitwarden-crypto = { workspace = true }
 bitwarden-vault = { workspace = true }
 chrono = { workspace = true, features = ["std"] }
-credential-exchange-types = { git = "https://github.com/bitwarden/credential-exchange.git", rev = "224243dd996d7e7cfa22b1bae05cdc7db85b3b3b" }
+credential-exchange-types = { git = "https://github.com/bitwarden/credential-exchange.git", rev = "e37495428d0a0486df3f8be95b895f3dc0d9eb42" }
 csv = "1.3.0"
 schemars = { workspace = true }
 serde = { workspace = true }

crates/bitwarden-exporters/Cargo.toml

@@ -0,0 +1,189 @@
+use bitwarden_crypto::generate_random_bytes;
+use credential_exchange_types::{
+    format::{BasicAuthCredential, Credential, EditableField, FieldType, Item, ItemType},
+    B64Url,
+};
+
+use crate::{Cipher, CipherType, Login, LoginUri};
+
+impl From<Cipher> for Item {
+    fn from(value: Cipher) -> Self {
+        let credentials = value.r#type.clone().into();
+        Self {
+            id: value.id.as_bytes().as_slice().into(),
+            creation_at: value.creation_date.timestamp() as u64,
+            modified_at: value.revision_date.timestamp() as u64,
+            ty: value.r#type.into(),
+            title: value.name,
+            subtitle: None,
+            credentials,
+            tags: None,
+            extensions: None,
+        }
+    }
+}
+
+impl From<CipherType> for ItemType {
+    // TODO: We should probably change this to try_from, so we can ignore types
+    fn from(value: CipherType) -> Self {
+        match value {
+            CipherType::Login(_) => ItemType::Login,
+            CipherType::Card(_) => ItemType::Login,
+            CipherType::Identity(_) => ItemType::Identity,
+            CipherType::SecureNote(_) => ItemType::Document,
+            CipherType::SshKey(_) => todo!(),
+        }
+    }
+}
+
+impl From<Login> for Vec<Credential> {
+    fn from(login: Login) -> Self {
+        vec![Credential::BasicAuth(BasicAuthCredential {
+            urls: login
+                .login_uris
+                .into_iter()
+                .flat_map(|uri| uri.uri)
+                .collect(),
+            username: login.username.map(|value| EditableField {
+                id: random_id(),
+                field_type: FieldType::String,
+                value,
+                label: None,
+            }),
+            password: login.password.map(|value| EditableField {
+                id: random_id(),
+                field_type: FieldType::ConcealedString,
+                value,
+                label: None,
+            }),
+        })]
+    }
+}
+
+impl From<CipherType> for Vec<Credential> {
+    fn from(value: CipherType) -> Self {
+        match value {
+            CipherType::Login(login) => (*login).into(),
+            CipherType::Card(_) => vec![],
+            CipherType::Identity(_) => vec![],
+            CipherType::SecureNote(_) => vec![],
+            CipherType::SshKey(_) => vec![],
+        }
+    }
+}
+
+/// Generate a 32 byte random ID
+fn random_id() -> B64Url {
+    generate_random_bytes::<[u8; 32]>().as_slice().into()
+}
+
+#[cfg(test)]
+mod tests {
+    use chrono::{DateTime, Utc};
+
+    use super::*;
+    use crate::{CipherType, Field, Login, LoginUri};
+
+    #[test]
+    fn test_login_to_item() {
+        let cipher = Cipher {
+            id: "25c8c414-b446-48e9-a1bd-b10700bbd740".parse().unwrap(),
+            folder_id: Some("942e2984-1b9a-453b-b039-b107012713b9".parse().unwrap()),
+
+            name: "Bitwarden".to_string(),
+            notes: Some("My note".to_string()),
+
+            r#type: CipherType::Login(Box::new(Login {
+                username: Some("[email protected]".to_string()),
+                password: Some("asdfasdfasdf".to_string()),
+                login_uris: vec![LoginUri {
+                    uri: Some("https://vault.bitwarden.com".to_string()),
+                    r#match: None,
+                }],
+                totp: Some("ABC".to_string()),
+            })),
+
+            favorite: true,
+            reprompt: 0,
+
+            fields: vec![
+                Field {
+                    name: Some("Text".to_string()),
+                    value: Some("A".to_string()),
+                    r#type: 0,
+                    linked_id: None,
+                },
+                Field {
+                    name: Some("Hidden".to_string()),
+                    value: Some("B".to_string()),
+                    r#type: 1,
+                    linked_id: None,
+                },
+                Field {
+                    name: Some("Boolean (true)".to_string()),
+                    value: Some("true".to_string()),
+                    r#type: 2,
+                    linked_id: None,
+                },
+                Field {
+                    name: Some("Boolean (false)".to_string()),
+                    value: Some("false".to_string()),
+                    r#type: 2,
+                    linked_id: None,
+                },
+                Field {
+                    name: Some("Linked".to_string()),
+                    value: None,
+                    r#type: 3,
+                    linked_id: Some(101),
+                },
+            ],
+
+            revision_date: "2024-01-30T14:09:33.753Z".parse().unwrap(),
+            creation_date: "2024-01-30T11:23:54.416Z".parse().unwrap(),
+            deleted_date: None,
+        };
+
+        let item: Item = cipher.into();
+
+        assert_eq!(
+            item.creation_at,
+            "2024-01-30T11:23:54.416Z"
+                .parse::<DateTime<Utc>>()
+                .unwrap()
+                .timestamp() as u64
+        );
+
+        assert_eq!(item.id.to_string(), "JcjEFLRGSOmhvbEHALvXQA");
+        assert_eq!(item.creation_at, 1706613834);
+        assert_eq!(item.modified_at, 1706623773);
+        assert!(matches!(item.ty, ItemType::Login));
+        assert_eq!(item.title, "Bitwarden");
+        assert_eq!(item.subtitle, None);
+        assert_eq!(item.credentials.len(), 1);
+        assert_eq!(item.tags, None);
+        assert!(item.extensions.is_none());
+
+        let credential = &item.credentials[0];
+
+        match credential {
+            Credential::BasicAuth(basic_auth) => {
+                let username = basic_auth.username.as_ref().unwrap();
+                assert!(matches!(username.field_type, FieldType::String));
+                assert_eq!(username.value, "[email protected]");
+                assert!(username.label.is_none());
+
+                let password = basic_auth.password.as_ref().unwrap();
+                assert!(matches!(password.field_type, FieldType::ConcealedString));
+                assert_eq!(password.value, "asdfasdfasdf");
+                assert!(password.label.is_none());
+
+                assert_eq!(
+                    basic_auth.urls,
+                    vec!["https://vault.bitwarden.com".to_string()]
+                );
+            }
+            _ => panic!("Expected Credential::BasicAuth"),
+        }
+    }
+}

crates/bitwarden-exporters/src/cxp.rs

@@ -9,6 +9,7 @@ uniffi::setup_scaffolding!();
 
 mod client_exporter;
 mod csv;
+mod cxp;
 mod encrypted_json;
 mod json;
 mod models;
@@ -38,6 +39,7 @@ pub struct Folder {
 ///
 /// These are mostly duplicated from the `bitwarden` vault models to facilitate a stable export API
 /// that is not tied to the internal vault models. We may revisit this in the future.
+#[derive(Clone)]
 pub struct Cipher {
     pub id: Uuid,
     pub folder_id: Option<Uuid>,
@@ -65,6 +67,7 @@ pub struct Field {
     pub linked_id: Option<u32>,
 }
 
+#[derive(Clone)]
 pub enum CipherType {
     Login(Box<Login>),
     SecureNote(Box<SecureNote>),
@@ -85,18 +88,21 @@ impl fmt::Display for CipherType {
     }
 }
 
+#[derive(Clone)]
 pub struct Login {
     pub username: Option<String>,
     pub password: Option<String>,
     pub login_uris: Vec<LoginUri>,
     pub totp: Option<String>,
 }
 
+#[derive(Clone)]
 pub struct LoginUri {
     pub uri: Option<String>,
     pub r#match: Option<u8>,
 }
 
+#[derive(Clone)]
 pub struct Card {
     pub cardholder_name: Option<String>,
     pub exp_month: Option<String>,
@@ -106,14 +112,17 @@ pub struct Card {
     pub number: Option<String>,
 }
 
+#[derive(Clone)]
 pub struct SecureNote {
     pub r#type: SecureNoteType,
 }
 
+#[derive(Clone)]
 pub enum SecureNoteType {
     Generic = 0,
 }
 
+#[derive(Clone)]
 pub struct Identity {
     pub title: Option<String>,
     pub first_name: Option<String>,
@@ -135,6 +144,7 @@ pub struct Identity {
     pub license_number: Option<String>,
 }
 
+#[derive(Clone)]
 pub struct SshKey {
     /// [OpenSSH private key](https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.key), in PEM encoding.
     pub private_key: String,