Merge branch 'km/cose-content-format' of github.com:bitwarden/sdk-internal into km/cose-content-format

Author: quexten

.github/workflows/lint.yml

@@ -6,6 +6,8 @@ on:
     branches: ["main"]
   pull_request:
 
+permissions: {}
+
 env:
   CARGO_TERM_COLOR: always
 
@@ -15,6 +17,10 @@ jobs:
 
     runs-on: ubuntu-24.04
 
+    permissions:
+      contents: read
+      security-events: write
+
     steps:
       - name: Checkout
         uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
@@ -54,7 +60,7 @@ jobs:
         run: cargo install clippy-sarif sarif-fmt --locked --git https://github.com/psastras/sarif-rs.git --rev 11c33a53f6ffeaed736856b86fb6b7b09fabdfd8
 
       - name: Cargo clippy-sarif
-        run: cargo clippy --all-features --tests --message-format=json |
+        run: cargo clippy --all-features --all-targets --message-format=json |
           clippy-sarif | tee clippy_result.sarif | sarif-fmt
         env:
           RUSTFLAGS: "-D warnings"
@@ -70,7 +76,7 @@ jobs:
       # status code of the command is caught and reported as failed in GitHub.
       # This should be cached from the previous step and should be fast.
       - name: Cargo clippy
-        run: cargo clippy --all-features --tests
+        run: cargo clippy --all-features --all-targets
         env:
           RUSTFLAGS: "-D warnings"
 

README.md

@@ -144,7 +144,7 @@ export RUSTFLAGS="-D warnings"
 
 cargo +nightly fmt --check
 cargo +nightly udeps --workspace --all-features
-cargo clippy --all-features --tests
+cargo clippy --all-features --all-targets
 cargo sort --workspace --check
 npm run lint
 ```

crates/bitwarden-vault/src/cipher/card.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use tsify_next::Tsify;
 
 use super::cipher::CipherKind;
-use crate::VaultParseError;
+use crate::{cipher::cipher::CopyableCipherFields, Cipher, VaultParseError};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
@@ -146,6 +146,20 @@ impl CipherKind for Card {
 
         Ok(build_subtitle_card(brand, number))
     }
+
+    fn get_copyable_fields(&self, _: Option<&Cipher>) -> Vec<CopyableCipherFields> {
+        [
+            self.number
+                .as_ref()
+                .map(|_| CopyableCipherFields::CardNumber),
+            self.code
+                .as_ref()
+                .map(|_| CopyableCipherFields::CardSecurityCode),
+        ]
+        .into_iter()
+        .flatten()
+        .collect()
+    }
 }
 
 /// Builds the subtitle for a card cipher
@@ -236,4 +250,38 @@ mod tests {
         let subtitle = build_subtitle_card(brand, number);
         assert_eq!(subtitle, "*4444");
     }
+    #[test]
+    fn test_get_copyable_fields_code() {
+        let card = Card {
+            cardholder_name: None,
+            exp_month: None,
+            exp_year: None,
+            code: Some("2.6TpmzzaQHgYr+mXjdGLQlg==|vT8VhfvMlWSCN9hxGYftZ5rjKRsZ9ofjdlUCx5Gubnk=|uoD3/GEQBWKKx2O+/YhZUCzVkfhm8rFK3sUEVV84mv8=".parse().unwrap()),
+            brand: None,
+            number: None,
+        };
+
+        let copyable_fields = card.get_copyable_fields(None);
+
+        assert_eq!(
+            copyable_fields,
+            vec![CopyableCipherFields::CardSecurityCode]
+        );
+    }
+
+    #[test]
+    fn test_get_copyable_fields_number() {
+        let card = Card {
+            cardholder_name: None,
+            exp_month: None,
+            exp_year: None,
+            code: None,
+            brand: None,
+            number: Some("2.6TpmzzaQHgYr+mXjdGLQlg==|vT8VhfvMlWSCN9hxGYftZ5rjKRsZ9ofjdlUCx5Gubnk=|uoD3/GEQBWKKx2O+/YhZUCzVkfhm8rFK3sUEVV84mv8=".parse().unwrap()),
+        };
+
+        let copyable_fields = card.get_copyable_fields(None);
+
+        assert_eq!(copyable_fields, vec![CopyableCipherFields::CardNumber]);
+    }
 }

crates/bitwarden-vault/src/cipher/cipher.rs

@@ -54,6 +54,9 @@ pub(super) trait CipherKind {
         ctx: &mut KeyStoreContext<KeyIds>,
         key: SymmetricKeyId,
     ) -> Result<String, CryptoError>;
+
+    /// Returns a list of populated fields for the cipher.
+    fn get_copyable_fields(&self, cipher: Option<&Cipher>) -> Vec<CopyableCipherFields>;
 }
 
 #[allow(missing_docs)]
@@ -187,6 +190,24 @@ pub enum CipherListViewType {
     SshKey,
 }
 
+/// Available fields on a cipher and can be copied from a the list view in the UI.
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]
+#[cfg_attr(feature = "uniffi", derive(uniffi::Enum))]
+pub enum CopyableCipherFields {
+    LoginUsername,
+    LoginPassword,
+    LoginTotp,
+    CardNumber,
+    CardSecurityCode,
+    IdentityUsername,
+    IdentityEmail,
+    IdentityPhone,
+    IdentityAddress,
+    SshKey,
+    SecureNotes,
+}
+
 #[allow(missing_docs)]
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
@@ -216,10 +237,17 @@ pub struct CipherListView {
 
     /// The number of attachments
     pub attachments: u32,
+    /// Indicates if the cipher has old attachments that need to be re-uploaded
+    pub has_old_attachments: bool,
 
     pub creation_date: DateTime<Utc>,
     pub deleted_date: Option<DateTime<Utc>>,
     pub revision_date: DateTime<Utc>,
+
+    /// Hints for the presentation layer for which fields can be copied.
+    pub copyable_fields: Vec<CopyableCipherFields>,
+
+    pub local_data: Option<LocalDataView>,
 }
 
 impl CipherListView {
@@ -373,7 +401,7 @@ impl Cipher {
             CipherType::Card => self.card.as_ref().map(|v| v as _),
             CipherType::Identity => self.identity.as_ref().map(|v| v as _),
             CipherType::SshKey => self.ssh_key.as_ref().map(|v| v as _),
-            _ => None,
+            CipherType::SecureNote => self.secure_note.as_ref().map(|v| v as _),
         }
     }
 
@@ -387,6 +415,14 @@ impl Cipher {
             .map(|sub| sub.decrypt_subtitle(ctx, key))
             .unwrap_or_else(|| Ok(String::new()))
     }
+
+    /// Returns a list of copyable field names for this cipher,
+    /// based on the cipher type and populated properties.
+    fn get_copyable_fields(&self) -> Vec<CopyableCipherFields> {
+        self.get_kind()
+            .map(|kind| kind.get_copyable_fields(Some(self)))
+            .unwrap_or_default()
+    }
 }
 
 impl CipherView {
@@ -596,9 +632,16 @@ impl Decryptable<KeyIds, SymmetricKeyId, CipherListView> for Cipher {
                 .as_ref()
                 .map(|a| a.len() as u32)
                 .unwrap_or(0),
+            has_old_attachments: self
+                .attachments
+                .as_ref()
+                .map(|a| a.iter().any(|att| att.key.is_none()))
+                .unwrap_or(false),
             creation_date: self.creation_date,
             deleted_date: self.deleted_date,
             revision_date: self.revision_date,
+            copyable_fields: self.get_copyable_fields(),
+            local_data: self.local_data.decrypt(ctx, ciphers_key)?,
         })
     }
 }
@@ -847,9 +890,16 @@ mod tests {
                 permissions: cipher.permissions,
                 view_password: cipher.view_password,
                 attachments: 0,
+                has_old_attachments: false,
                 creation_date: cipher.creation_date,
                 deleted_date: cipher.deleted_date,
-                revision_date: cipher.revision_date
+                revision_date: cipher.revision_date,
+                copyable_fields: vec![
+                    CopyableCipherFields::LoginUsername,
+                    CopyableCipherFields::LoginPassword,
+                    CopyableCipherFields::LoginTotp
+                ],
+                local_data: None,
             }
         )
     }

crates/bitwarden-vault/src/cipher/identity.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use tsify_next::Tsify;
 
 use super::cipher::CipherKind;
-use crate::VaultParseError;
+use crate::{cipher::cipher::CopyableCipherFields, Cipher, VaultParseError};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
@@ -166,6 +166,31 @@ impl CipherKind for Identity {
 
         Ok(build_subtitle_identity(first_name, last_name))
     }
+
+    fn get_copyable_fields(&self, _: Option<&Cipher>) -> Vec<CopyableCipherFields> {
+        [
+            self.username
+                .as_ref()
+                .map(|_| CopyableCipherFields::IdentityUsername),
+            self.email
+                .as_ref()
+                .map(|_| CopyableCipherFields::IdentityEmail),
+            self.phone
+                .as_ref()
+                .map(|_| CopyableCipherFields::IdentityPhone),
+            self.address1
+                .as_ref()
+                .or(self.address2.as_ref())
+                .or(self.address3.as_ref())
+                .or(self.city.as_ref())
+                .or(self.state.as_ref())
+                .or(self.postal_code.as_ref())
+                .map(|_| CopyableCipherFields::IdentityAddress),
+        ]
+        .into_iter()
+        .flatten()
+        .collect()
+    }
 }
 
 /// Builds the subtitle for a card cipher
@@ -196,6 +221,30 @@ fn build_subtitle_identity(first_name: Option<String>, last_name: Option<String>
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::cipher::cipher::CopyableCipherFields;
+
+    fn create_identity() -> Identity {
+        Identity {
+            title: None,
+            first_name: None,
+            middle_name: None,
+            last_name: None,
+            address1: None,
+            address2: None,
+            address3: None,
+            city: None,
+            state: None,
+            postal_code: None,
+            country: None,
+            company: None,
+            email: None,
+            phone: None,
+            ssn: None,
+            username: None,
+            passport_number: None,
+            license_number: None,
+        }
+    }
 
     #[test]
     fn test_build_subtitle_identity() {
@@ -232,4 +281,59 @@ mod tests {
         let subtitle = build_subtitle_identity(first_name, last_name);
         assert_eq!(subtitle, "");
     }
+
+    #[test]
+    fn test_get_copyable_fields_identity_empty() {
+        let identity = create_identity();
+
+        let copyable_fields = identity.get_copyable_fields(None);
+        assert_eq!(copyable_fields, vec![]);
+    }
+
+    #[test]
+    fn test_get_copyable_fields_identity_has_username() {
+        let mut identity = create_identity();
+        identity.username = Some("2.yXXpPbsf6NZhLVkNe/i4Bw==|ol/HTI++aMO1peBBBhSR7Q==|awNmmj31efIXTzaru42/Ay+bQ6V+1MrKxXh1Uo5gca8=".parse().unwrap());
+
+        let copyable_fields = identity.get_copyable_fields(None);
+        assert_eq!(
+            copyable_fields,
+            vec![CopyableCipherFields::IdentityUsername]
+        );
+    }
+
+    #[test]
+    fn test_get_copyable_fields_identity_has_email() {
+        let mut identity = create_identity();
+        identity.email = Some("2.yXXpPbsf6NZhLVkNe/i4Bw==|ol/HTI++aMO1peBBBhSR7Q==|awNmmj31efIXTzaru42/Ay+bQ6V+1MrKxXh1Uo5gca8=".parse().unwrap());
+
+        let copyable_fields = identity.get_copyable_fields(None);
+        assert_eq!(copyable_fields, vec![CopyableCipherFields::IdentityEmail]);
+    }
+
+    #[test]
+    fn test_get_copyable_fields_identity_has_phone() {
+        let mut identity = create_identity();
+        identity.phone = Some("2.yXXpPbsf6NZhLVkNe/i4Bw==|ol/HTI++aMO1peBBBhSR7Q==|awNmmj31efIXTzaru42/Ay+bQ6V+1MrKxXh1Uo5gca8=".parse().unwrap());
+
+        let copyable_fields = identity.get_copyable_fields(None);
+        assert_eq!(copyable_fields, vec![CopyableCipherFields::IdentityPhone]);
+    }
+
+    #[test]
+    fn test_get_copyable_fields_identity_has_address() {
+        let mut identity = create_identity();
+
+        identity.address1 = Some("2.yXXpPbsf6NZhLVkNe/i4Bw==|ol/HTI++aMO1peBBBhSR7Q==|awNmmj31efIXTzaru42/Ay+bQ6V+1MrKxXh1Uo5gca8=".parse().unwrap());
+
+        let mut copyable_fields = identity.get_copyable_fields(None);
+
+        assert_eq!(copyable_fields, vec![CopyableCipherFields::IdentityAddress]);
+
+        identity.state = Some("2.yXXpPbsf6NZhLVkNe/i4Bw==|ol/HTI++aMO1peBBBhSR7Q==|awNmmj31efIXTzaru42/Ay+bQ6V+1MrKxXh1Uo5gca8=".parse().unwrap());
+        identity.address1 = None;
+
+        copyable_fields = identity.get_copyable_fields(None);
+        assert_eq!(copyable_fields, vec![CopyableCipherFields::IdentityAddress]);
+    }
 }

crates/bitwarden-vault/src/cipher/local_data.rs

@@ -14,7 +14,7 @@ pub struct LocalData {
     last_launched: Option<DateTime<Utc>>,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 #[cfg_attr(feature = "uniffi", derive(uniffi::Record))]
 #[cfg_attr(feature = "wasm", derive(Tsify), tsify(into_wasm_abi, from_wasm_abi))]