PM-25311: CXF Map all custom fields to a CustomFieldsCredential (#414)

## 🎟️ Tracking
https://bitwarden.atlassian.net/browse/PM-25311
<!-- Paste the link to the Jira or GitHub issue or otherwise describe /
point to where this change is coming from. -->

## 📔 Objective

This PR is a quick stab at mapping all custom fields on a cipher to a
single CustomFieldCredential.

I'm not 100% sure about how to parse this from the spec:

> If the [exporting
provider](https://fidoalliance.org/specs/cx/cxf-v1.0-ps-20250814.html#exporting-provider)
allows custom fields to be added to items but does not have a grouping
concept, it SHOULD use this object without setting the label or id
fields.

From:
https://fidoalliance.org/specs/cx/cxf-v1.0-ps-20250814.html#dict-custom-fields



<!-- Describe what the purpose of this PR is, for example what bug
you're fixing or new feature you're adding. -->

## ⏰ Reminders before review

- Contributor guidelines followed
- All formatters and local linters executed and passed
- Written new unit and / or integration tests where applicable
- Protected functional changes with optionality (feature flags)
- Used internationalization (i18n) for all UI strings
- CI builds passed
- Communicated to DevOps any deployment requirements
- Updated any necessary documentation (Confluence, contributing docs) or
informed the documentation
  team

## 🦮 Reviewer guidelines

<!-- Suggested interactions but feel free to use (or not) as you desire!
-->

- 👍 (`:+1:`) or similar for great changes
- 📝 (`:memo:`) or ℹ️ (`:information_source:`) for notes or general info
- ❓ (`:question:`) for questions
- 🤔 (`:thinking:`) or 💭 (`:thought_balloon:`) for more open inquiry
that's not quite a confirmed
  issue and could potentially benefit from discussion
- 🎨 (`:art:`) for suggestions / improvements
- ❌ (`:x:`) or ⚠️ (`:warning:`) for more significant problems or
concerns needing attention
- 🌱 (`:seedling:`) or ♻️ (`:recycle:`) for future improvements or
indications of technical debt
- ⛏ (`:pick:`) for minor or nitpick changes

Author: abergs

Cargo.lock

@@ -34,7 +34,7 @@ bitwarden-fido = { workspace = true }
 bitwarden-ssh = { workspace = true }
 bitwarden-vault = { workspace = true }
 chrono = { workspace = true, features = ["std"] }
-credential-exchange-format = { git = "https://github.com/bitwarden/credential-exchange", rev = "38e8a013c13644f832c457555baaa536fe481b77" }
+credential-exchange-format = { git = "https://github.com/bitwarden/credential-exchange", rev = "12702ad62ccc2a1e3cd9bdea40fc0f6399e1fffa" }
 csv = "1.3.0"
 num-traits = ">=0.2, <0.3"
 serde = { workspace = true }

crates/bitwarden-exporters/Cargo.toml

@@ -1,8 +1,8 @@
 use bitwarden_vault::FieldType;
 use credential_exchange_format::{
     EditableField, EditableFieldBoolean, EditableFieldConcealedString, EditableFieldCountryCode,
-    EditableFieldDate, EditableFieldString, EditableFieldWifiNetworkSecurityType,
-    EditableFieldYearMonth,
+    EditableFieldDate, EditableFieldString, EditableFieldSubdivisionCode, EditableFieldValue,
+    EditableFieldWifiNetworkSecurityType, EditableFieldYearMonth,
 };
 
 use crate::Field;
@@ -24,6 +24,55 @@ where
     }
 }
 
+/// Helper function to create an EditableField with common properties
+fn create_editable_field<T>(name: String, value: T) -> EditableField<T> {
+    EditableField {
+        id: None,
+        label: Some(name),
+        value,
+        extensions: None,
+    }
+}
+
+/// Convert Bitwarden Field to CXF EditableFieldValue with proper type mapping
+pub(super) fn field_to_editable_field_value(field: Field) -> Option<EditableFieldValue> {
+    let name = field.name?;
+
+    match field.r#type {
+        x if x == FieldType::Text as u8 => field.value.map(|value| {
+            EditableFieldValue::String(create_editable_field(name, EditableFieldString(value)))
+        }),
+
+        x if x == FieldType::Hidden as u8 => field.value.map(|value| {
+            EditableFieldValue::ConcealedString(create_editable_field(
+                name,
+                EditableFieldConcealedString(value),
+            ))
+        }),
+
+        x if x == FieldType::Boolean as u8 => field.value?.parse::<bool>().ok().map(|bool_value| {
+            EditableFieldValue::Boolean(create_editable_field(
+                name,
+                EditableFieldBoolean(bool_value),
+            ))
+        }),
+
+        x if x == FieldType::Linked as u8 => {
+            let value = field
+                .value
+                .or_else(|| field.linked_id.map(|id| id.to_string()))?;
+            Some(EditableFieldValue::String(create_editable_field(
+                name,
+                EditableFieldString(value),
+            )))
+        }
+
+        _ => field.value.map(|value| {
+            EditableFieldValue::String(create_editable_field(name, EditableFieldString(value)))
+        }),
+    }
+}
+
 /// Trait to define field type and value conversion for inner field types
 pub(super) trait InnerFieldType {
     const FIELD_TYPE: FieldType;
@@ -87,6 +136,14 @@ impl InnerFieldType for EditableFieldYearMonth {
     }
 }
 
+impl InnerFieldType for EditableFieldSubdivisionCode {
+    const FIELD_TYPE: FieldType = FieldType::Text;
+
+    fn to_field_value(&self) -> String {
+        self.0.clone()
+    }
+}
+
 /// Trait to convert CXP EditableField types to Bitwarden Field values and types
 pub(super) trait EditableFieldToField {
     const FIELD_TYPE: FieldType;

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

@@ -1,12 +1,16 @@
 use bitwarden_vault::{Totp, TotpAlgorithm};
 use credential_exchange_format::{
-    Account as CxfAccount, Credential, Item, NoteCredential, OTPHashAlgorithm, TotpCredential,
+    Account as CxfAccount, Credential, CustomFieldsCredential, EditableFieldValue, Item,
+    NoteCredential, OTPHashAlgorithm, TotpCredential,
 };
 use uuid::Uuid;
 #[cfg(feature = "wasm")]
 use {tsify::Tsify, wasm_bindgen::prelude::*};
 
-use crate::{cxf::CxfError, Cipher, CipherType, Login};
+use crate::{
+    cxf::{editable_field::field_to_editable_field_value, CxfError},
+    Cipher, CipherType, Login,
+};
 
 /// Temporary struct to hold metadata related to current account
 ///
@@ -56,6 +60,24 @@ impl TryFrom<Cipher> for Item {
             })));
         }
 
+        // Convert Bitwarden custom fields to CustomFieldsCredential
+        if !value.fields.is_empty() {
+            let custom_fields: Vec<EditableFieldValue> = value
+                .fields
+                .into_iter()
+                .filter_map(field_to_editable_field_value)
+                .collect();
+
+            if !custom_fields.is_empty() {
+                credentials.push(Credential::CustomFields(Box::new(CustomFieldsCredential {
+                    id: None,
+                    label: None,
+                    fields: custom_fields,
+                    extensions: vec![],
+                })));
+            }
+        }
+
         Ok(Self {
             id: value.id.as_bytes().as_slice().into(),
             creation_at: Some(value.creation_date.timestamp() as u64),
@@ -247,7 +269,7 @@ mod tests {
         );
         assert!(item.extensions.is_none());
 
-        assert_eq!(item.credentials.len(), 4);
+        assert_eq!(item.credentials.len(), 5);
 
         let credential = &item.credentials[0];
 
@@ -299,7 +321,61 @@ mod tests {
             Credential::Note(n) => {
                 assert_eq!(n.content.value.0, "My note");
             }
-            _ => panic!("Expected Credential::Passkey"),
+            _ => panic!("Expected Credential::Note"),
+        }
+
+        let credential = &item.credentials[4];
+
+        match credential {
+            Credential::CustomFields(custom_fields) => {
+                assert_eq!(custom_fields.fields.len(), 5); // Text, Hidden, Boolean true, Boolean false, Linked
+
+                // Check Text field
+                match &custom_fields.fields[0] {
+                    EditableFieldValue::String(field) => {
+                        assert_eq!(field.label.as_ref().unwrap(), "Text");
+                        assert_eq!(field.value.0, "A");
+                    }
+                    _ => panic!("Expected String field"),
+                }
+
+                // Check Hidden field
+                match &custom_fields.fields[1] {
+                    EditableFieldValue::ConcealedString(field) => {
+                        assert_eq!(field.label.as_ref().unwrap(), "Hidden");
+                        assert_eq!(field.value.0, "B");
+                    }
+                    _ => panic!("Expected ConcealedString field"),
+                }
+
+                // Check Boolean true field
+                match &custom_fields.fields[2] {
+                    EditableFieldValue::Boolean(field) => {
+                        assert_eq!(field.label.as_ref().unwrap(), "Boolean (true)");
+                        assert!(field.value.0);
+                    }
+                    _ => panic!("Expected Boolean field"),
+                }
+
+                // Check Boolean false field
+                match &custom_fields.fields[3] {
+                    EditableFieldValue::Boolean(field) => {
+                        assert_eq!(field.label.as_ref().unwrap(), "Boolean (false)");
+                        assert!(!field.value.0);
+                    }
+                    _ => panic!("Expected Boolean field"),
+                }
+
+                // Check Linked field
+                match &custom_fields.fields[4] {
+                    EditableFieldValue::String(field) => {
+                        assert_eq!(field.label.as_ref().unwrap(), "Linked");
+                        assert_eq!(field.value.0, "101"); // linked_id as string
+                    }
+                    _ => panic!("Expected String field for Linked"),
+                }
+            }
+            _ => panic!("Expected Credential::CustomFields"),
         }
     }
 }

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

@@ -1,9 +1,10 @@
 use chrono::{DateTime, Utc};
 use credential_exchange_format::{
     Account as CxfAccount, AddressCredential, ApiKeyCredential, BasicAuthCredential, Credential,
-    CreditCardCredential, CustomFieldsCredential, DriversLicenseCredential,
-    IdentityDocumentCredential, Item, NoteCredential, PasskeyCredential, PassportCredential,
-    PersonNameCredential, SshKeyCredential, TotpCredential, WifiCredential,
+    CreditCardCredential, CustomFieldsCredential, DriversLicenseCredential, EditableField,
+    EditableFieldString, EditableFieldValue, IdentityDocumentCredential, Item, NoteCredential,
+    PasskeyCredential, PassportCredential, PersonNameCredential, SshKeyCredential, TotpCredential,
+    WifiCredential,
 };
 
 use crate::{
@@ -49,7 +50,27 @@ fn custom_fields_to_fields(custom_fields: &CustomFieldsCredential) -> Vec<Field>
     custom_fields
         .fields
         .iter()
-        .map(|f| create_field(f, None::<String>))
+        .map(|field_value| match field_value {
+            EditableFieldValue::String(field) => create_field(field, None::<String>),
+            EditableFieldValue::ConcealedString(field) => create_field(field, None::<String>),
+            EditableFieldValue::Boolean(field) => create_field(field, None::<String>),
+            EditableFieldValue::Date(field) => create_field(field, None::<String>),
+            EditableFieldValue::YearMonth(field) => create_field(field, None::<String>),
+            EditableFieldValue::SubdivisionCode(field) => create_field(field, None::<String>),
+            EditableFieldValue::CountryCode(field) => create_field(field, None::<String>),
+            EditableFieldValue::WifiNetworkSecurityType(field) => {
+                create_field(field, None::<String>)
+            }
+            _ => create_field(
+                &EditableField {
+                    id: None,
+                    label: Some("Unknown Field".to_string()),
+                    value: EditableFieldString("".to_string()),
+                    extensions: None,
+                },
+                None::<String>,
+            ),
+        })
         .collect()
 }