PM-23655: Map WI-FI -> Note (#358)

Maps wifi into a note on import

Co-authored-by: Hinton <[email protected]>

Author: abergs

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

@@ -0,0 +1,219 @@
+use bitwarden_vault::FieldType;
+use credential_exchange_format::{
+    EditableField, EditableFieldBoolean, EditableFieldConcealedString, EditableFieldString,
+    EditableFieldWifiNetworkSecurityType,
+};
+
+use crate::Field;
+
+/// Helper function to create a Field from any EditableField type
+pub(super) fn create_field<T>(name: impl Into<String>, field: &T) -> Field
+where
+    T: EditableFieldToField,
+{
+    Field {
+        name: Some(name.into()),
+        value: Some(field.field_value()),
+        r#type: T::FIELD_TYPE as u8,
+        linked_id: None,
+    }
+}
+
+/// Trait to convert CXP EditableField types to Bitwarden Field values and types
+pub(super) trait EditableFieldToField {
+    const FIELD_TYPE: FieldType;
+
+    fn field_value(&self) -> String;
+}
+
+impl EditableFieldToField for EditableField<EditableFieldString> {
+    const FIELD_TYPE: FieldType = FieldType::Text;
+
+    fn field_value(&self) -> String {
+        self.value.0.clone()
+    }
+}
+
+impl EditableFieldToField for EditableField<EditableFieldConcealedString> {
+    const FIELD_TYPE: FieldType = FieldType::Hidden;
+
+    fn field_value(&self) -> String {
+        self.value.0.clone()
+    }
+}
+
+impl EditableFieldToField for EditableField<EditableFieldBoolean> {
+    const FIELD_TYPE: FieldType = FieldType::Boolean;
+
+    fn field_value(&self) -> String {
+        self.value.0.to_string()
+    }
+}
+
+impl EditableFieldToField for EditableField<EditableFieldWifiNetworkSecurityType> {
+    const FIELD_TYPE: FieldType = FieldType::Text;
+
+    fn field_value(&self) -> String {
+        security_type_to_string(&self.value).to_string()
+    }
+}
+
+/// Convert WiFi security type enum to human-readable string
+fn security_type_to_string(security_type: &EditableFieldWifiNetworkSecurityType) -> &str {
+    use EditableFieldWifiNetworkSecurityType::*;
+    match security_type {
+        Unsecured => "Unsecured",
+        WpaPersonal => "WPA Personal",
+        Wpa2Personal => "WPA2 Personal",
+        Wpa3Personal => "WPA3 Personal",
+        Wep => "WEP",
+        Other(s) => s,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_field_string() {
+        let editable_field = EditableField {
+            id: None,
+            label: None,
+            value: EditableFieldString("Test Value".to_string()),
+            extensions: None,
+        };
+
+        let field = create_field("Test Name", &editable_field);
+
+        assert_eq!(
+            field,
+            Field {
+                name: Some("Test Name".to_string()),
+                value: Some("Test Value".to_string()),
+                r#type: FieldType::Text as u8,
+                linked_id: None,
+            }
+        );
+    }
+
+    #[test]
+    fn test_create_field_concealed_string() {
+        let editable_field = EditableField {
+            id: None,
+            label: None,
+            value: EditableFieldConcealedString("Secret123".to_string()),
+            extensions: None,
+        };
+
+        let field = create_field("Password", &editable_field);
+
+        assert_eq!(
+            field,
+            Field {
+                name: Some("Password".to_string()),
+                value: Some("Secret123".to_string()),
+                r#type: FieldType::Hidden as u8,
+                linked_id: None,
+            }
+        );
+    }
+
+    #[test]
+    fn test_create_field_boolean_true() {
+        let editable_field = EditableField {
+            id: None,
+            label: None,
+            value: EditableFieldBoolean(true),
+            extensions: None,
+        };
+
+        let field = create_field("Is Enabled", &editable_field);
+
+        assert_eq!(
+            field,
+            Field {
+                name: Some("Is Enabled".to_string()),
+                value: Some("true".to_string()),
+                r#type: FieldType::Boolean as u8,
+                linked_id: None,
+            }
+        );
+    }
+
+    #[test]
+    fn test_create_field_boolean_false() {
+        let editable_field = EditableField {
+            id: None,
+            label: None,
+            value: EditableFieldBoolean(false),
+            extensions: None,
+        };
+
+        let field = create_field("Is Hidden", &editable_field);
+
+        assert_eq!(
+            field,
+            Field {
+                name: Some("Is Hidden".to_string()),
+                value: Some("false".to_string()),
+                r#type: FieldType::Boolean as u8,
+                linked_id: None,
+            }
+        );
+    }
+
+    #[test]
+    fn test_create_field_wifi_security() {
+        let editable_field = EditableField {
+            id: None,
+            label: None,
+            value: EditableFieldWifiNetworkSecurityType::Wpa3Personal,
+            extensions: None,
+        };
+
+        let field = create_field("WiFi Security", &editable_field);
+
+        assert_eq!(
+            field,
+            Field {
+                name: Some("WiFi Security".to_string()),
+                value: Some("WPA3 Personal".to_string()),
+                r#type: FieldType::Text as u8,
+                linked_id: None,
+            }
+        );
+    }
+
+    #[test]
+    fn test_security_type_to_string() {
+        assert_eq!(
+            security_type_to_string(&EditableFieldWifiNetworkSecurityType::Unsecured),
+            "Unsecured"
+        );
+        assert_eq!(
+            security_type_to_string(&EditableFieldWifiNetworkSecurityType::WpaPersonal),
+            "WPA Personal"
+        );
+        assert_eq!(
+            security_type_to_string(&EditableFieldWifiNetworkSecurityType::Wpa2Personal),
+            "WPA2 Personal"
+        );
+        assert_eq!(
+            security_type_to_string(&EditableFieldWifiNetworkSecurityType::Wpa3Personal),
+            "WPA3 Personal"
+        );
+        assert_eq!(
+            security_type_to_string(&EditableFieldWifiNetworkSecurityType::Wep),
+            "WEP"
+        );
+
+        let custom_security = "WPA2 Enterprise";
+        assert_eq!(
+            security_type_to_string(&EditableFieldWifiNetworkSecurityType::Other(
+                custom_security.to_string()
+            )),
+            custom_security
+        );
+    }
+}

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

@@ -1,15 +1,16 @@
 use chrono::{DateTime, Utc};
 use credential_exchange_format::{
     Account as CxfAccount, BasicAuthCredential, Credential, CreditCardCredential, Item,
-    PasskeyCredential,
+    PasskeyCredential, WifiCredential,
 };
 
 use crate::{
     cxf::{
         login::{to_fields, to_login},
+        wifi::wifi_to_fields,
         CxfError,
     },
-    CipherType, ImportingCipher,
+    CipherType, ImportingCipher, SecureNote, SecureNoteType,
 };
 
 pub(crate) fn parse_cxf(payload: String) -> Result<Vec<ImportingCipher>, CxfError> {
@@ -79,6 +80,26 @@ fn parse_item(value: Item) -> Vec<ImportingCipher> {
         })
     }
 
+    // WiFi credentials -> Secure Note
+    if let Some(wifi) = grouped.wifi.first() {
+        let fields = wifi_to_fields(wifi);
+
+        output.push(ImportingCipher {
+            folder_id: None, // TODO: Handle folders
+            name: value.title.clone(),
+            notes: None,
+            r#type: CipherType::SecureNote(Box::new(SecureNote {
+                r#type: SecureNoteType::Generic,
+            })),
+            favorite: false,
+            reprompt: 0,
+            fields,
+            revision_date,
+            creation_date,
+            deleted_date: None,
+        })
+    }
+
     output
 }
 
@@ -112,13 +133,18 @@ fn group_credentials_by_type(credentials: Vec<Credential>) -> GroupedCredentials
             Credential::CreditCard(credit_card) => Some(credit_card.as_ref()),
             _ => None,
         }),
+        wifi: filter_credentials(&credentials, |c| match c {
+            Credential::Wifi(wifi) => Some(wifi.as_ref()),
+            _ => None,
+        }),
     }
 }
 
 struct GroupedCredentials {
     basic_auth: Vec<BasicAuthCredential>,
     passkey: Vec<PasskeyCredential>,
     credit_card: Vec<CreditCardCredential>,
+    wifi: Vec<WifiCredential>,
 }
 
 #[cfg(test)]

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

@@ -13,4 +13,6 @@ pub use export::Account;
 mod import;
 pub(crate) use import::parse_cxf;
 mod card;
+mod editable_field;
 mod login;
+mod wifi;