[PM-10401] Implemented SSH Key type handling

BitwardenShared/Core/Platform/Models/Enum/FeatureFlag.swift

@@ -24,6 +24,8 @@ enum FeatureFlag: String, CaseIterable, Codable {
     /// A feature flag for the create account flow.
     case nativeCreateAccountFlow = "native-create-account-flow"
 
+    case sshKeyVaultItem = "ssh-key-vault-item"
+
     // MARK: Test Flags
 
     /// A test feature flag that isn't remotely configured and has no initial value.
@@ -81,6 +83,7 @@ enum FeatureFlag: String, CaseIterable, Codable {
              .importLoginsFlow,
              .nativeCarouselFlow,
              .nativeCreateAccountFlow,
+             .sshKeyVaultItem,
              .testLocalFeatureFlag,
              .testLocalInitialBoolFlag,
              .testLocalInitialIntFlag,

BitwardenShared/Core/Platform/Models/Enum/FeatureFlagTests.swift

@@ -12,6 +12,25 @@ final class FeatureFlagTests: BitwardenTestCase {
         XCTAssertEqual(filtered, [])
     }
 
+    /// `getter:isRemotelyConfigured` returns the correct value for each flag.
+    func test_isRemotelyConfigured() {
+        XCTAssertTrue(FeatureFlag.emailVerification.isRemotelyConfigured)
+        XCTAssertTrue(FeatureFlag.testRemoteInitialBoolFlag.isRemotelyConfigured)
+        XCTAssertTrue(FeatureFlag.testRemoteInitialIntFlag.isRemotelyConfigured)
+        XCTAssertTrue(FeatureFlag.testRemoteInitialStringFlag.isRemotelyConfigured)
+
+        XCTAssertFalse(FeatureFlag.enableAuthenticatorSync.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.enableCipherKeyEncryption.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.importLoginsFlow.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.nativeCarouselFlow.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.nativeCreateAccountFlow.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.sshKeyVaultItem.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.testLocalFeatureFlag.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.testLocalInitialBoolFlag.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.testLocalInitialIntFlag.isRemotelyConfigured)
+        XCTAssertFalse(FeatureFlag.testLocalInitialStringFlag.isRemotelyConfigured)
+    }
+
     /// `name` formats the raw value of a feature flag
     func test_name() {
         XCTAssertEqual(FeatureFlag.testLocalFeatureFlag.name, "Test Local Feature Flag")

BitwardenShared/Core/Vault/Extensions/BitwardenSdk+Vault.swift

@@ -40,7 +40,7 @@
     }
 }
 
 extension AttachmentView: Identifiable {}
 
 extension CipherCardModel {
     init(card: BitwardenSdk.Card) {
@@ -330,9 +330,9 @@
     }
 }
 
 extension BitwardenSdk.CipherListView: Identifiable {}
 
 extension BitwardenSdk.CipherView: Identifiable {
     /// Initializes a new `CipherView` based on a `Fido2CredentialNewView`
     /// - Parameters:
     ///   - fido2CredentialNewView: The `Fido2CredentialNewView` for the Fido2 creation flow
@@ -390,8 +390,7 @@
         case .identity:
             self = .identity
         case .sshKey:
-            // TODO: PM-10401 set self = .sshKey when SDK is ready.
-            self = .init(rawValue: 5)!
+            self = .sshKey
         }
     }
 }
@@ -407,7 +406,7 @@
     }
 }
 
 extension BitwardenSdk.Fido2Credential: Identifiable, @unchecked Sendable {
     public var id: String { credentialId }
 
     init(cipherLoginFido2Credential model: CipherLoginFido2Credential) {
@@ -429,7 +428,7 @@
     }
 }
 
 extension BitwardenSdk.Fido2CredentialView: @unchecked Sendable {}
 
 extension BitwardenSdk.Fido2CredentialAutofillView: @unchecked Sendable {}
 

BitwardenShared/Core/Vault/Extensions/BitwardenSdkVaultTests.swift

@@ -5,6 +5,21 @@ import XCTest
 
 @testable import BitwardenShared
 
+// MARK: - BitwardenSdk.CipherType
+
+class BitwardenSdkVaultBitwardenCipherTypeTests: BitwardenTestCase { // swiftlint:disable:this type_name
+    // MARK: Tests
+
+    /// `init(type:)` initializes the SDK cipher type based on the cipher type.
+    func test_init_byCipherType() {
+        XCTAssertEqual(BitwardenSdk.CipherType(.login), .login)
+        XCTAssertEqual(BitwardenSdk.CipherType(.card), .card)
+        XCTAssertEqual(BitwardenSdk.CipherType(.identity), .identity)
+        XCTAssertEqual(BitwardenSdk.CipherType(.secureNote), .secureNote)
+        XCTAssertEqual(BitwardenSdk.CipherType(.sshKey), .sshKey)
+    }
+}
+
 // MARK: - Cipher
 
 class BitwardenSdkVaultCipherTests: BitwardenTestCase {

BitwardenShared/Core/Vault/Models/Enum/CipherType.swift

@@ -32,6 +32,8 @@ extension CipherType {
             self = .login
         case .secureNote:
             self = .secureNote
+        case .sshKey:
+            self = .sshKey
         case .collection,
              .folder,
              .noFolder,
@@ -61,4 +63,14 @@ extension CipherType: Menuable {
 extension CipherType {
     /// These are the cases of `CipherType` that the user can use to create a cipher.
     static let canCreateCases: [CipherType] = [.login, .card, .identity, .secureNote]
+
+    /// The allowed custom field types per cipher type.
+    var allowedFieldTypes: [FieldType] {
+        switch self {
+        case .card, .identity, .login:
+            return [.text, .hidden, .boolean, .linked]
+        case .secureNote, .sshKey:
+            return [.text, .hidden, .boolean]
+        }
+    }
 }

BitwardenShared/Core/Vault/Models/Enum/CipherTypeTests.swift

@@ -5,12 +5,22 @@ import XCTest
 class CipherTypeTests: BitwardenTestCase {
     // MARK: Tests
 
+    /// `getter:allowedFieldTypes` return the correct `FielldType` array for the given cipher type..
+    func test_allowedFieldTypes() {
+        XCTAssertEqual(CipherType.login.allowedFieldTypes, [.text, .hidden, .boolean, .linked])
+        XCTAssertEqual(CipherType.card.allowedFieldTypes, [.text, .hidden, .boolean, .linked])
+        XCTAssertEqual(CipherType.identity.allowedFieldTypes, [.text, .hidden, .boolean, .linked])
+        XCTAssertEqual(CipherType.secureNote.allowedFieldTypes, [.text, .hidden, .boolean])
+        XCTAssertEqual(CipherType.sshKey.allowedFieldTypes, [.text, .hidden, .boolean])
+    }
+
     /// `localizedName` returns the correct values.
     func test_localizedName() {
         XCTAssertEqual(CipherType.card.localizedName, Localizations.typeCard)
         XCTAssertEqual(CipherType.identity.localizedName, Localizations.typeIdentity)
         XCTAssertEqual(CipherType.login.localizedName, Localizations.typeLogin)
         XCTAssertEqual(CipherType.secureNote.localizedName, Localizations.typeSecureNote)
+        XCTAssertEqual(CipherType.sshKey.localizedName, Localizations.sshKey)
     }
 
     /// `init` with a `VaultListGroup` produces the correct value.
@@ -21,6 +31,7 @@ class CipherTypeTests: BitwardenTestCase {
         XCTAssertEqual(CipherType(group: .identity), .identity)
         XCTAssertEqual(CipherType(group: .login), .login)
         XCTAssertEqual(CipherType(group: .secureNote), .secureNote)
+        XCTAssertEqual(CipherType(group: .sshKey), .sshKey)
         XCTAssertNil(CipherType(group: .trash))
     }
 

BitwardenShared/Core/Vault/Models/Request/CipherRequestModel.swift

@@ -56,6 +56,9 @@ struct CipherRequestModel: JSONRequestBody {
     /// Secure note data if the cipher is a secure note.
     let secureNote: CipherSecureNoteModel?
 
+    /// SSH key data if the cipher is an SSH Key.
+    let sshKey: CipherSSHKeyModel?
+
     /// The type of the cipher.
     let type: CipherType
 }
@@ -85,6 +88,7 @@ extension CipherRequestModel {
             passwordHistory: cipher.passwordHistory?.map(CipherPasswordHistoryModel.init),
             reprompt: CipherRepromptType(type: cipher.reprompt),
             secureNote: cipher.secureNote.map(CipherSecureNoteModel.init),
+            sshKey: cipher.sshKey.map(CipherSSHKeyModel.init),
             type: CipherType(type: cipher.type)
         )
     }

BitwardenShared/Core/Vault/Repositories/VaultRepository.swift

@@ -514,6 +514,11 @@ class DefaultVaultRepository { // swiftlint:disable:this type_body_length
             ? { $0.deletedDate == nil }
             : { $0.deletedDate != nil }
 
+        let isSSHKeyVaultItemEnabled: Bool = await configService.getFeatureFlag(.sshKeyVaultItem)
+        let sshKeyFilter: (CipherView) -> Bool = { cipher in
+            cipher.type != .sshKey || isSSHKeyVaultItemEnabled
+        }
+
         return try await cipherService.ciphersPublisher().asyncTryMap { ciphers -> [CipherView] in
             // Convert the Ciphers to CipherViews and filter appropriately.
             let matchingCiphers = try await ciphers.asyncMap { cipher in
@@ -522,6 +527,7 @@ class DefaultVaultRepository { // swiftlint:disable:this type_body_length
             .filter { cipher in
                 filterType.cipherFilter(cipher) &&
                     isMatchingCipher(cipher) &&
+                    sshKeyFilter(cipher) &&
                     (cipherFilter?(cipher) ?? true)
             }
 
@@ -739,6 +745,8 @@ class DefaultVaultRepository { // swiftlint:disable:this type_body_length
             items = activeCiphers.filter { $0.folderId == nil }.compactMap(VaultListItem.init)
         case .secureNote:
             items = activeCiphers.filter { $0.type == .secureNote }.compactMap(VaultListItem.init)
+        case .sshKey:
+            items = activeCiphers.filter { $0.type == .sshKey }.compactMap(VaultListItem.init)
         case .totp:
             items = try await totpListItems(from: activeCiphers, filter: filter)
         case .trash:
@@ -830,7 +838,11 @@ class DefaultVaultRepository { // swiftlint:disable:this type_body_length
         .filter(filter.cipherFilter)
         .sorted { $0.name.localizedStandardCompare($1.name) == .orderedAscending }
 
-        let activeCiphers = ciphers.filter { $0.deletedDate == nil }
+        let isSSHKeyVaultItemFlagEnabled: Bool = await configService.getFeatureFlag(.sshKeyVaultItem)
+        let activeCiphers = ciphers.filter { cipher in
+            cipher.deletedDate == nil
+                && (isSSHKeyVaultItemFlagEnabled || cipher.type != .sshKey)
+        }
 
         let folders = try await clientService.vault().folders()
             .decryptList(folders: folders)
@@ -882,13 +894,18 @@ class DefaultVaultRepository { // swiftlint:disable:this type_body_length
         let typesLoginCount = activeCiphers.lazy.filter { $0.type == .login }.count
         let typesSecureNoteCount = activeCiphers.lazy.filter { $0.type == .secureNote }.count
 
-        let types = [
+        var types = [
             VaultListItem(id: "Types.Logins", itemType: .group(.login, typesLoginCount)),
             VaultListItem(id: "Types.Cards", itemType: .group(.card, typesCardCount)),
             VaultListItem(id: "Types.Identities", itemType: .group(.identity, typesIdentityCount)),
             VaultListItem(id: "Types.SecureNotes", itemType: .group(.secureNote, typesSecureNoteCount)),
         ]
 
+        if isSSHKeyVaultItemFlagEnabled {
+            let typesSSHKeyCount = activeCiphers.lazy.filter { $0.type == .sshKey }.count
+            types.append(VaultListItem(id: "Types.SSHKeys", itemType: .group(.sshKey, typesSSHKeyCount)))
+        }
+
         return [
             VaultListSection(id: "TOTP", items: totpItems, name: Localizations.totp),
             VaultListSection(id: "Favorites", items: ciphersFavorites, name: Localizations.favorites),
@@ -1292,6 +1309,8 @@ extension DefaultVaultRepository: VaultRepository {
                 return cipher.folderId == nil
             case .secureNote:
                 return cipher.type == .secureNote
+            case .sshKey:
+                return cipher.type == .sshKey
             case .totp:
                 return cipher.type == .login
                     && cipher.login?.totp != nil