PM-23639: Add CXF Import mappings (#361)

Adds multiple CXF mappings

Author: abergs

Cargo.lock

@@ -31,9 +31,10 @@ bitwarden-core = { workspace = true }
 bitwarden-crypto = { workspace = true }
 bitwarden-error = { workspace = true }
 bitwarden-fido = { workspace = true }
+bitwarden-ssh = { workspace = true }
 bitwarden-vault = { workspace = true }
 chrono = { workspace = true, features = ["std"] }
-credential-exchange-format = ">=0.1, <0.2"
+credential-exchange-format = { git = "https://github.com/bitwarden/credential-exchange", rev = "38e8a013c13644f832c457555baaa536fe481b77" }
 csv = "1.3.0"
 num-traits = ">=0.2, <0.3"
 serde = { workspace = true }

crates/bitwarden-exporters/Cargo.toml

@@ -3,7 +3,7 @@ use credential_exchange_format::ApiKeyCredential;
 use crate::{cxf::editable_field::create_field, Field};
 
 /// Convert API key credentials to custom fields
-pub fn api_key_to_fields(api_key: &ApiKeyCredential) -> Vec<Field> {
+pub(super) fn api_key_to_fields(api_key: &ApiKeyCredential) -> Vec<Field> {
     [
         api_key.key.as_ref().map(|key| create_field("API Key", key)),
         api_key

crates/bitwarden-exporters/resources/cxf_example.json

@@ -7,7 +7,7 @@ use chrono::Month;
 use credential_exchange_format::{Credential, CreditCardCredential, EditableFieldYearMonth};
 use num_traits::FromPrimitive;
 
-use crate::Card;
+use crate::{cxf::editable_field::create_field, Card, Field};
 
 impl From<Card> for Vec<Credential> {
     fn from(value: Card) -> Self {
@@ -57,6 +57,23 @@ impl From<&CreditCardCredential> for Card {
     }
 }
 
+pub(super) fn to_card(credential: &CreditCardCredential) -> (Card, Vec<Field>) {
+    let card = credential.into();
+
+    let fields = [
+        credential.pin.as_ref().map(|v| create_field("PIN", v)),
+        credential
+            .valid_from
+            .as_ref()
+            .map(|v| create_field("Valid From", v)),
+    ]
+    .into_iter()
+    .flatten()
+    .collect();
+
+    (card, fields)
+}
+
 /// Sanitize credit card brand
 ///
 /// Performs a fuzzy match on the string to find a matching brand. By converting to lowercase and
@@ -83,6 +100,7 @@ fn sanitize_brand(value: &str) -> Option<String> {
 
 #[cfg(test)]
 mod tests {
+    use bitwarden_vault::FieldType;
     use chrono::Month;
     use credential_exchange_format::EditableFieldYearMonth;
 
@@ -150,23 +168,47 @@ mod tests {
             full_name: Some("John Doe".to_string().into()),
             card_type: Some("Visa".to_string().into()),
             verification_number: Some("123".to_string().into()),
-            pin: None,
+            pin: Some("4567".to_string().into()),
             expiry_date: Some(
                 EditableFieldYearMonth {
                     year: 2025,
                     month: Month::December,
                 }
                 .into(),
             ),
-            valid_from: None,
+            valid_from: Some(
+                EditableFieldYearMonth {
+                    year: 2024,
+                    month: Month::January,
+                }
+                .into(),
+            ),
         };
 
-        let card: Card = (&credit_card).into();
+        let (card, fields) = to_card(&credit_card);
         assert_eq!(card.cardholder_name, Some("John Doe".to_string()));
         assert_eq!(card.exp_month, Some("12".to_string()));
         assert_eq!(card.exp_year, Some("2025".to_string()));
         assert_eq!(card.code, Some("123".to_string()));
         assert_eq!(card.brand, Some("Visa".to_string()));
         assert_eq!(card.number, Some("4111111111111111".to_string()));
+
+        assert_eq!(
+            fields,
+            vec![
+                Field {
+                    name: Some("PIN".to_string()),
+                    value: Some("4567".to_string()),
+                    r#type: FieldType::Hidden as u8,
+                    linked_id: None,
+                },
+                Field {
+                    name: Some("Valid From".to_string()),
+                    value: Some("2024-01".to_string()),
+                    r#type: FieldType::Text as u8,
+                    linked_id: None,
+                },
+            ]
+        )
     }
 }

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

@@ -1,7 +1,8 @@
 use bitwarden_vault::FieldType;
 use credential_exchange_format::{
-    EditableField, EditableFieldBoolean, EditableFieldConcealedString, EditableFieldDate,
-    EditableFieldString, EditableFieldWifiNetworkSecurityType,
+    EditableField, EditableFieldBoolean, EditableFieldConcealedString, EditableFieldCountryCode,
+    EditableFieldDate, EditableFieldString, EditableFieldWifiNetworkSecurityType,
+    EditableFieldYearMonth,
 };
 
 use crate::Field;
@@ -58,6 +59,14 @@ impl EditableFieldToField for EditableField<EditableFieldWifiNetworkSecurityType
     }
 }
 
+impl EditableFieldToField for EditableField<EditableFieldCountryCode> {
+    const FIELD_TYPE: FieldType = FieldType::Text;
+
+    fn field_value(&self) -> String {
+        self.value.0.clone()
+    }
+}
+
 impl EditableFieldToField for EditableField<EditableFieldDate> {
     const FIELD_TYPE: FieldType = FieldType::Text;
 
@@ -66,6 +75,18 @@ impl EditableFieldToField for EditableField<EditableFieldDate> {
     }
 }
 
+impl EditableFieldToField for EditableField<EditableFieldYearMonth> {
+    const FIELD_TYPE: FieldType = FieldType::Text;
+
+    fn field_value(&self) -> String {
+        format!(
+            "{:04}-{:02}",
+            self.value.year,
+            self.value.month.number_from_month()
+        )
+    }
+}
+
 /// Convert WiFi security type enum to human-readable string
 fn security_type_to_string(security_type: &EditableFieldWifiNetworkSecurityType) -> &str {
     use EditableFieldWifiNetworkSecurityType::*;
@@ -76,6 +97,7 @@ fn security_type_to_string(security_type: &EditableFieldWifiNetworkSecurityType)
         Wpa3Personal => "WPA3 Personal",
         Wep => "WEP",
         Other(s) => s,
+        _ => "Unknown",
     }
 }
 
@@ -248,4 +270,31 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn test_create_field_year_month() {
+        use chrono::Month;
+
+        let editable_field = EditableField {
+            id: None,
+            label: None,
+            value: EditableFieldYearMonth {
+                year: 2025,
+                month: Month::December,
+            },
+            extensions: None,
+        };
+
+        let field = create_field("Card Expiry", &editable_field);
+
+        assert_eq!(
+            field,
+            Field {
+                name: Some("Card Expiry".to_string()),
+                value: Some("2025-12".to_string()),
+                r#type: FieldType::Text as u8,
+                linked_id: None,
+            }
+        );
+    }
 }