Update credential exchange to latest version (#169)

Update our credential implementation to follow the latest version.

Author: Hinton

Cargo.lock

@@ -24,8 +24,9 @@ bitwarden-crypto = { workspace = true }
 bitwarden-fido = { workspace = true }
 bitwarden-vault = { workspace = true }
 chrono = { workspace = true, features = ["std"] }
-credential-exchange-types = { git = "https://github.com/bitwarden/credential-exchange.git", rev = "60bf99f097af72144b0eaa757ccb50fd46049f24" }
+credential-exchange-types = { git = "https://github.com/bitwarden/credential-exchange.git", rev = "03f29bc63cea5bc8c9c8bfe27f002b3e90f9e051" }
 csv = "1.3.0"
+num-traits = ">=0.2, <0.3"
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

crates/bitwarden-exporters/Cargo.toml

@@ -3,45 +3,56 @@
 //! Handles conversion between internal [Card] and credential exchange [CreditCardCredential].
 
 use bitwarden_vault::CardBrand;
-use credential_exchange_types::format::{Credential, CreditCardCredential};
+use chrono::Month;
+use credential_exchange_types::format::{Credential, CreditCardCredential, EditableFieldYearMonth};
+use num_traits::FromPrimitive;
 
 use crate::Card;
 
 impl From<Card> for Vec<Credential> {
     fn from(value: Card) -> Self {
+        let expiry_date = match (value.exp_year, value.exp_month) {
+            (Some(year), Some(month)) => {
+                let year_parsed = year.parse().ok();
+                let numeric_month: Option<u32> = month.parse().ok();
+                let month_parsed = numeric_month.and_then(Month::from_u32);
+                match (year_parsed, month_parsed) {
+                    (Some(year), Some(month)) => {
+                        Some(EditableFieldYearMonth { year, month }.into())
+                    }
+                    _ => None,
+                }
+            }
+            _ => None,
+        };
+
         vec![Credential::CreditCard(Box::new(CreditCardCredential {
-            number: value.number.unwrap_or_default(),
-            full_name: value.cardholder_name.unwrap_or_default(),
-            card_type: value.brand,
-            verification_number: value.code,
-            expiry_date: match (value.exp_year, value.exp_month) {
-                (Some(year), Some(month)) => Some(format!("{}-{}", year, month)),
-                _ => None,
-            },
+            number: value.number.map(|v| v.into()),
+            full_name: value.cardholder_name.map(|v| v.into()),
+            card_type: value.brand.map(|v| v.into()),
+            verification_number: value.code.map(|v| v.into()),
+            pin: None,
+            expiry_date,
             valid_from: None,
         }))]
     }
 }
 
 impl From<&CreditCardCredential> for Card {
     fn from(value: &CreditCardCredential) -> Self {
-        let (year, month) = value.expiry_date.as_ref().map_or((None, None), |date| {
-            let parts: Vec<&str> = date.split('-').collect();
-            let year = parts.first().map(|s| s.to_string());
-            let month = parts.get(1).map(|s| s.to_string());
-            (year, month)
-        });
-
         Card {
-            cardholder_name: Some(value.full_name.clone()),
-            exp_month: month,
-            exp_year: year,
-            code: value.verification_number.clone(),
+            cardholder_name: value.full_name.clone().map(|v| v.into()),
+            exp_month: value
+                .expiry_date
+                .as_ref()
+                .map(|v| v.value.month.number_from_month().to_string()),
+            exp_year: value.expiry_date.as_ref().map(|v| v.value.year.to_string()),
+            code: value.verification_number.clone().map(|v| v.into()),
             brand: value
                 .card_type
                 .as_ref()
-                .and_then(|brand| sanitize_brand(brand)),
-            number: Some(value.number.clone()),
+                .and_then(|brand| sanitize_brand(&brand.value.0)),
+            number: value.number.clone().map(|v| v.into()),
         }
     }
 }
@@ -72,6 +83,9 @@ fn sanitize_brand(value: &str) -> Option<String> {
 
 #[cfg(test)]
 mod tests {
+    use chrono::Month;
+    use credential_exchange_types::format::EditableFieldYearMonth;
+
     use super::*;
 
     #[test]
@@ -104,11 +118,26 @@ mod tests {
         assert_eq!(credentials.len(), 1);
 
         if let Credential::CreditCard(credit_card) = &credentials[0] {
-            assert_eq!(credit_card.full_name, "John Doe");
-            assert_eq!(credit_card.expiry_date, Some("2025-12".to_string()));
-            assert_eq!(credit_card.verification_number, Some("123".to_string()));
-            assert_eq!(credit_card.card_type, Some("Visa".to_string()));
-            assert_eq!(credit_card.number, "4111111111111111");
+            assert_eq!(credit_card.full_name.as_ref().unwrap().value.0, "John Doe");
+            assert_eq!(
+                credit_card.expiry_date.as_ref().unwrap().value,
+                EditableFieldYearMonth {
+                    year: 2025,
+                    month: Month::December
+                }
+            );
+            assert_eq!(
+                credit_card.verification_number.as_ref().unwrap().value.0,
+                "123".to_string()
+            );
+            assert_eq!(
+                credit_card.card_type.as_ref().unwrap().value.0,
+                "Visa".to_string()
+            );
+            assert_eq!(
+                credit_card.number.as_ref().unwrap().value.0,
+                "4111111111111111"
+            );
         } else {
             panic!("Expected CreditCardCredential");
         }
@@ -117,11 +146,18 @@ mod tests {
     #[test]
     fn test_credit_card_credential_to_card() {
         let credit_card = CreditCardCredential {
-            number: "4111111111111111".to_string(),
-            full_name: "John Doe".to_string(),
-            card_type: Some("Visa".to_string()),
-            verification_number: Some("123".to_string()),
-            expiry_date: Some("2025-12".to_string()),
+            number: Some("4111111111111111".to_string().into()),
+            full_name: Some("John Doe".to_string().into()),
+            card_type: Some("Visa".to_string().into()),
+            verification_number: Some("123".to_string().into()),
+            pin: None,
+            expiry_date: Some(
+                EditableFieldYearMonth {
+                    year: 2025,
+                    month: Month::December,
+                }
+                .into(),
+            ),
             valid_from: None,
         };
 

crates/bitwarden-exporters/src/cxf/card.rs

@@ -1,7 +1,6 @@
 use bitwarden_vault::{Totp, TotpAlgorithm};
 use credential_exchange_types::format::{
-    Account as CxfAccount, Credential, Item, ItemType, NoteCredential, OTPHashAlgorithm,
-    TotpCredential,
+    Account as CxfAccount, Credential, Item, NoteCredential, OTPHashAlgorithm, TotpCredential,
 };
 use uuid::Uuid;
 
@@ -27,10 +26,9 @@ pub(crate) fn build_cxf(account: Account, ciphers: Vec<Cipher>) -> Result<String
 
     let account = CxfAccount {
         id: account.id.as_bytes().as_slice().into(),
-        user_name: "".to_owned(),
+        username: "".to_owned(),
         email: account.email,
         full_name: account.name,
-        icon: None,
         collections: vec![], // TODO: Add support for folders
         items,
         extensions: None,
@@ -46,41 +44,29 @@ impl TryFrom<Cipher> for Item {
         let mut credentials: Vec<Credential> = value.r#type.clone().into();
 
         if let Some(note) = value.notes {
-            credentials.push(Credential::Note(Box::new(NoteCredential { content: note })));
+            credentials.push(Credential::Note(Box::new(NoteCredential {
+                content: note.into(),
+            })));
         }
 
         Ok(Self {
             id: value.id.as_bytes().as_slice().into(),
             creation_at: Some(value.creation_date.timestamp() as u64),
             modified_at: Some(value.revision_date.timestamp() as u64),
-            ty: value.r#type.try_into()?,
             title: value.name,
             subtitle: None,
             favorite: Some(value.favorite),
             credentials,
             tags: None,
             extensions: None,
+            scope: match value.r#type {
+                CipherType::Login(login) => Some((*login).into()),
+                _ => None,
+            },
         })
     }
 }
 
-impl TryFrom<CipherType> for ItemType {
-    type Error = CxfError;
-
-    fn try_from(value: CipherType) -> Result<Self, Self::Error> {
-        match value {
-            CipherType::Login(_) => Ok(ItemType::Login),
-            CipherType::Card(_) => Ok(ItemType::Identity),
-            CipherType::Identity(_) => Ok(ItemType::Identity),
-            CipherType::SecureNote(_) => Ok(ItemType::Document),
-            CipherType::SshKey(_) => {
-                // TODO(PM-15448): Add support for SSH Keys
-                Err(CxfError::Internal("Unsupported CipherType: SshKey".into()))
-            }
-        }
-    }
-}
-
 impl From<CipherType> for Vec<Credential> {
     fn from(value: CipherType) -> Self {
         match value {
@@ -131,7 +117,7 @@ fn convert_totp(totp: Totp) -> TotpCredential {
         secret: totp.secret.into(),
         period: totp.period as u8,
         digits: totp.digits as u8,
-        username: totp.account.unwrap_or("".to_string()),
+        username: totp.account,
         algorithm: match totp.algorithm {
             TotpAlgorithm::Sha1 => OTPHashAlgorithm::Sha1,
             TotpAlgorithm::Sha256 => OTPHashAlgorithm::Sha256,
@@ -144,7 +130,6 @@ fn convert_totp(totp: Totp) -> TotpCredential {
 
 #[cfg(test)]
 mod tests {
-    use credential_exchange_types::format::FieldType;
 
     use super::*;
     use crate::{Fido2Credential, Field, LoginUri};
@@ -164,7 +149,7 @@ mod tests {
         assert_eq!(String::from(credential.secret), "ONSWG4TFOQ");
         assert_eq!(credential.period, 60);
         assert_eq!(credential.digits, 4);
-        assert_eq!(credential.username, "[email protected]");
+        assert_eq!(credential.username.unwrap(), "[email protected]");
         assert_eq!(credential.algorithm, OTPHashAlgorithm::Sha1);
         assert_eq!(credential.issuer, Some("test-issuer".to_string()));
     }
@@ -249,10 +234,13 @@ mod tests {
         assert_eq!(item.id.to_string(), "JcjEFLRGSOmhvbEHALvXQA");
         assert_eq!(item.creation_at, Some(1706613834));
         assert_eq!(item.modified_at, Some(1706623773));
-        assert_eq!(item.ty, ItemType::Login);
         assert_eq!(item.title, "Bitwarden");
         assert_eq!(item.subtitle, None);
         assert_eq!(item.tags, None);
+        assert_eq!(
+            item.scope.unwrap().urls,
+            vec!["https://vault.bitwarden.com".to_string()]
+        );
         assert!(item.extensions.is_none());
 
         assert_eq!(item.credentials.len(), 4);
@@ -262,19 +250,12 @@ mod tests {
         match credential {
             Credential::BasicAuth(basic_auth) => {
                 let username = basic_auth.username.as_ref().unwrap();
-                assert_eq!(username.field_type, FieldType::String);
-                assert_eq!(username.value, "[email protected]");
+                assert_eq!(username.value.0, "[email protected]");
                 assert!(username.label.is_none());
 
                 let password = basic_auth.password.as_ref().unwrap();
-                assert_eq!(password.field_type, FieldType::ConcealedString);
-                assert_eq!(password.value, "asdfasdfasdf");
+                assert_eq!(password.value.0, "asdfasdfasdf");
                 assert!(password.label.is_none());
-
-                assert_eq!(
-                    basic_auth.urls,
-                    vec!["https://vault.bitwarden.com".to_string()]
-                );
             }
             _ => panic!("Expected Credential::BasicAuth"),
         }
@@ -286,7 +267,7 @@ mod tests {
                 assert_eq!(String::from(totp.secret.clone()), "JBSWY3DPEHPK3PXP");
                 assert_eq!(totp.period, 30);
                 assert_eq!(totp.digits, 6);
-                assert_eq!(totp.username, "");
+                assert_eq!(totp.username, None);
                 assert_eq!(totp.algorithm, OTPHashAlgorithm::Sha1);
                 assert!(totp.issuer.is_none());
             }
@@ -299,7 +280,7 @@ mod tests {
             Credential::Passkey(passkey) => {
                 assert_eq!(passkey.credential_id.to_string(), "6NiHiekW4ZY8vYHa-ucbvA");
                 assert_eq!(passkey.rp_id, "123");
-                assert_eq!(passkey.user_name, "");
+                assert_eq!(passkey.username, "");
                 assert_eq!(passkey.user_display_name, "");
                 assert_eq!(String::from(passkey.user_handle.clone()), "AAECAwQFBg");
                 assert_eq!(String::from(passkey.key.clone()), "AAECAwQFBg");
@@ -312,7 +293,7 @@ mod tests {
 
         match credential {
             Credential::Note(n) => {
-                assert_eq!(n.content, "My note");
+                assert_eq!(n.content.value.0, "My note");
             }
             _ => panic!("Expected Credential::Passkey"),
         }