Merge branch 'joao/prefix-smartcard-connections'

Author: jdmoreira

FullStackTests/AllowedConnections.swift

@@ -46,9 +46,9 @@ enum TestableConnections {
         #endif
     }
 
-    static func create(with kind: Kind = .default) async throws -> Connection {
+    static func create(with kind: Kind = .default) async throws -> SmartCardConnection {
 
-        let connection: Connection?
+        let connection: SmartCardConnection?
         switch kind {
         case .smartCard:
             connection = try await smartCard()
@@ -77,8 +77,8 @@ enum TestableConnections {
         return connection
     }
 
-    private static func smartCard() async throws -> Connection? {
-        let smartCardConnections = try await SmartCardConnection.all
+    private static func smartCard() async throws -> SmartCardConnection? {
+        let smartCardConnections = try await USBSmartCardConnection.all
         for connection in smartCardConnections {
             if try await connection.isAllowed {
                 return connection
@@ -90,35 +90,35 @@ enum TestableConnections {
     }
 
     #if os(iOS)
-    private static func lightning() async throws -> Connection? {
-        let connection = try await LightningConnection.connection()
+    private static func lightning() async throws -> SmartCardConnection? {
+        let connection = try await LightningSmartCardConnection.connection()
         guard try await connection.isAllowed else { return nil }
         return connection
     }
 
-    private static func nfc(alertMessage: String? = nil) async throws -> Connection? {
-        let connection = try await NFCConnection.connection(alertMessage: alertMessage)
+    private static func nfc(alertMessage: String? = nil) async throws -> SmartCardConnection? {
+        let connection = try await NFCSmartCardConnection.connection(alertMessage: alertMessage)
         guard try await connection.isAllowed else { return nil }
         return connection
     }
     #endif
 }
 
-extension SmartCardConnection {
-    fileprivate static var all: [Connection] {
+extension USBSmartCardConnection {
+    fileprivate static var all: [SmartCardConnection] {
         get async throws {
-            let slots = try await SmartCardConnection.availableSlots
+            let slots = try await USBSmartCardConnection.availableSlots
 
-            var connections: [Connection?] = []
+            var connections: [SmartCardConnection?] = []
             for slot in slots {
-                connections.append(try? await SmartCardConnection.connection(slot: slot))
+                connections.append(try? await USBSmartCardConnection.connection(slot: slot))
             }
             return connections.compactMap { $0 }
         }
     }
 }
 
-extension Connection {
+extension SmartCardConnection {
     fileprivate var isAllowed: Bool {
         get async throws {
             let session = try await ManagementSession.session(withConnection: self)

FullStackTests/Tests/ConnectionFullStackTests.swift

@@ -20,7 +20,7 @@ import XCTest
 
 class ConnectionFullStackTests: XCTestCase {
 
-    typealias Connection = SmartCardConnection
+    typealias Connection = USBSmartCardConnection
 
     func testSingleConnection() throws {
         runAsyncTest {
@@ -169,15 +169,15 @@ class SmartCardConnectionFullStackTests: XCTestCase {
 
     func testSmartCardConnectionWithSlot() throws {
         runAsyncTest {
-            let allSlots = try await SmartCardConnection.availableSlots
+            let allSlots = try await USBSmartCardConnection.availableSlots
             allSlots.enumerated().forEach { index, slot in
                 print("\(index): \(slot.name)")
             }
             let random = allSlots.randomElement()
             // we need at least one YubiKey connected
             XCTAssertNotNil(random)
             guard let random else { return }
-            let connection = try await SmartCardConnection.connection(slot: random)
+            let connection = try await USBSmartCardConnection.connection(slot: random)
             print("✅ Got connection \(connection)")
             XCTAssertNotNil(connection)
         }

FullStackTests/Tests/ManagementFullStackTests.swift

@@ -256,13 +256,13 @@ extension XCTestCase {
         in file: StaticString = #file,
         at line: UInt = #line,
         withTimeout timeout: TimeInterval = 20,
-        test: @escaping (Connection, ManagementSession, DeviceTransport) async throws -> Void
+        test: @escaping (SmartCardConnection, ManagementSession, DeviceTransport) async throws -> Void
     ) {
         runAsyncTest(named: testName, in: file, at: line, withTimeout: timeout) {
             let connection = try await TestableConnections.create()
             let transport: DeviceTransport
             #if os(iOS)
-            if connection as? NFCConnection != nil {
+            if connection as? NFCSmartCardConnection != nil {
                 transport = .nfc
             } else {
                 transport = .usb

FullStackTests/Tests/SCP/SCP11FullStackTests.swift

@@ -147,7 +147,7 @@ final class SCP11aFullStackTests: XCTestCase {
         }
     }
 
-    private func importScp03Key(connection: Connection) async throws -> SCPKeyParams {
+    private func importScp03Key(connection: SmartCardConnection) async throws -> SCPKeyParams {
         let scp03Ref = SCPKeyRef(kid: 0x01, kvn: 0x01)
 
         let staticKeys = StaticKeys(

FullStackTests/Tests/SCP/XCTestCase+SCP.swift

@@ -18,7 +18,7 @@ import XCTest
 @testable import YubiKit
 
 extension XCTestCase: HasTestLogger {
-    var connection: Connection {
+    var connection: SmartCardConnection {
         _connection!
     }
 
@@ -48,7 +48,7 @@ extension XCTestCase: HasTestLogger {
     }
 }
 
-private var _connection: Connection!
+private var _connection: SmartCardConnection!
 
 private let _defaultKeyParams: SCP03KeyParams = {
     let defaultKeyRef = SCPKeyRef(kid: .scp03, kvn: 0xff)

README.md

@@ -9,7 +9,7 @@ in Swift and SwiftUI based applications. The async/await syntax provides an easy
 creating connections and sending commands to the different applications on the YubiKey.
 
 ```swift
-let connection = try await NFCConnection.connection()
+let connection = try await NFCSmartCardConnection.connection()
 let session = try await OATHSession.session(withConnection: connection)
 let codes = try await session.calculateCodes()
 ```

Samples/OATHSample/OATHSample/OATHListModel.swift

@@ -44,7 +44,7 @@ class OATHListModel: OATHListModelProtocol {
                     error = nil
                     guard !Task.isCancelled else { return }
                     // Wait for a suitable wired connection for the current device.
-                    let connection = try await WiredConnection.connection()
+                    let connection = try await WiredSmartCardConnection.connection()
                     guard !Task.isCancelled else { return }
                     try await calculateCodes(connection: connection)
                     // Wait for the connection to close, i.e the YubiKey to be unplugged from the device.
@@ -68,7 +68,7 @@ class OATHListModel: OATHListModelProtocol {
         Task { @MainActor in
             do {
                 self.error = nil
-                let connection = try await NFCConnection.connection()
+                let connection = try await NFCSmartCardConnection.connection()
                 try await calculateCodes(connection: connection)
                 await connection.nfcConnection?.close(message: "Code calculated")
             } catch {
@@ -80,7 +80,7 @@ class OATHListModel: OATHListModelProtocol {
     func calculateNFCCodes() {}  // do nothing on macOS
     #endif
 
-    @MainActor private func calculateCodes(connection: Connection) async throws {
+    @MainActor private func calculateCodes(connection: SmartCardConnection) async throws {
         self.error = nil
         let session = try await OATHSession.session(withConnection: connection)
         let result = try await session.calculateCodes()
@@ -95,20 +95,20 @@ struct Account: Identifiable {
     let code: String
 }
 
-extension Connection {
+extension SmartCardConnection {
     var connectionType: String {
         #if os(iOS)
-        if self as? NFCConnection != nil {
+        if self as? NFCSmartCardConnection != nil {
             return "NFC"
-        } else if self as? LightningConnection != nil {
+        } else if self as? LightningSmartCardConnection != nil {
             return "Lightning"
-        } else if self as? SmartCardConnection != nil {
+        } else if self as? USBSmartCardConnection != nil {
             return "SmartCard"
         } else {
             return "Unknown"
         }
         #else
-        if self as? SmartCardConnection != nil {
+        if self as? USBSmartCardConnection != nil {
             return "SmartCard"
         } else {
             return "Unknown"

Samples/OATHSample/OATHSample/SettingsModel.swift

@@ -32,15 +32,15 @@ class SettingsModel: SettingsModelProtocol {
         Task { @MainActor in
             self.error = nil
             do {
-                let connection = try await AnyConnection.connection()
+                let connection = try await AnySmartCardConnection.connection()
                 let session = try await ManagementSession.session(withConnection: connection)
                 self.keyVersion = session.version.description
                 #if os(iOS)
                 if let nfcConnection = connection.nfcConnection {
                     self.connection = "NFC"
                     await nfcConnection.close(message: "YubiKey version read")
                 } else {
-                    self.connection = connection as? SmartCardConnection != nil ? "SmartCard" : "Lightning"
+                    self.connection = connection as? USBSmartCardConnection != nil ? "SmartCard" : "Lightning"
                 }
                 #else
                 self.connection = "SmartCard"

YubiKit/YubiKit/Connection.swift

@@ -18,11 +18,11 @@ import Foundation
 ///
 /// Use a connection to create a ``Session``. The connection can also be used for sending raw ``APDU``'s to the YubiKey.
 ///
-/// Protocol implemented in ``LightningConnection``, ``NFCConnection`` and ``SmartCardConnection``.
+/// Protocol implemented in ``LightningSmartCardConnection``, ``NFCSmartCardConnection`` and ``USBSmartCardConnection``.
 
-public protocol Connection: Sendable {
+public protocol SmartCardConnection: Sendable {
 
-    /// Create a new Connection to the YubiKey.
+    /// Create a new SmartCardConnection to the YubiKey.
     ///
     /// Call this method to get a connection to a YubiKey. The method will wait
     /// until a connection to a YubiKey has been established and then return it.
@@ -33,9 +33,9 @@ public protocol Connection: Sendable {
     /// If a connection has been established and this method is called again the
     /// first connection will be closed and ``connectionDidClose()`` will return for
     /// the previous connection.
-    static func connection() async throws -> Connection
+    static func connection() async throws -> SmartCardConnection
 
-    /// Close the current Connection.
+    /// Close the current SmartCardConnection.
     ///
     /// This closes the connection sending the optional error to the ``connectionDidClose()`` method.
     func close(error: Error?) async
@@ -46,9 +46,9 @@ public protocol Connection: Sendable {
     /// error will be returned.
     func connectionDidClose() async -> Error?
 
-    /// Send an APDU to the Connection.
+    /// Send an APDU to the SmartCardConnection.
     ///
-    /// This will send the APDU to the YubiKey using the Connection. Commands returning data to big
+    /// This will send the APDU to the YubiKey using the SmartCardConnection. Commands returning data to big
     /// to be handled by a single read operation will be handled automatically by the SDK and the
     /// complete result will be returned by the function. Only operations returning a 0x9000 status
     /// code will return data. Operations returning a 0x61XX (more data) status code will be handled
@@ -57,16 +57,16 @@ public protocol Connection: Sendable {
     @discardableResult
     func send(apdu: APDU) async throws -> Data
 
-    /// Send a command as Data to the Connection and handle the result manually.
+    /// Send a command as Data to the SmartCardConnection and handle the result manually.
     ///
-    /// This will send the Data to the YubiKey using the Connection. The full result will be
+    /// This will send the Data to the YubiKey using the SmartCardConnection. The full result will be
     /// returned as Data. If the returned data is to big for a single read operation this has
     /// to be handled manually.
     @discardableResult
     func send(data: Data) async throws -> Data
 }
 
-/// Connection Errors.
+/// SmartCardConnection Errors.
 public enum ConnectionError: Error {
     /// No current connection.
     case noConnection
@@ -76,7 +76,7 @@ public enum ConnectionError: Error {
     case missingResult
     /// Awaiting call to connect() was cancelled.
     case cancelled
-    /// Connection was closed.
+    /// SmartCardConnection was closed.
     case closed
 }
 

YubiKit/YubiKit/LightningConnection.swift renamed to YubiKit/YubiKit/LightningSmartCardConnection.swift

@@ -20,11 +20,11 @@ import OSLog
 
 /// A connection to the YubiKey utilizing the Lightning port and External Accessory framework.
 @available(iOS 16.0, *)
-public struct LightningConnection: Connection, Sendable {
+public struct LightningSmartCardConnection: SmartCardConnection, Sendable {
     let accessoryConnectionID: Int
 
     // Starts lightning and wait for a connection
-    public static func connection() async throws -> Connection {
+    public static func connection() async throws -> SmartCardConnection {
         trace(message: "requesting new connection")
         return try await LightningConnectionManager.shared.connect()
     }
@@ -56,13 +56,13 @@ public struct LightningConnection: Connection, Sendable {
 // MARK: - Internal helpers / extensions
 
 // Downcast helper
-extension Connection {
-    public var lightningConnection: LightningConnection? {
-        self as? LightningConnection
+extension SmartCardConnection {
+    public var lightningConnection: LightningSmartCardConnection? {
+        self as? LightningSmartCardConnection
     }
 }
 
-extension LightningConnection: HasLightningLogger {}
+extension LightningSmartCardConnection: HasLightningLogger {}
 extension LightningConnectionManager: HasLightningLogger {}
 extension EAAccessoryWrapper: HasLightningLogger {}
 
@@ -72,13 +72,13 @@ private actor LightningConnectionManager {
 
     static let shared = LightningConnectionManager()
 
-    private var connectionTask: Task<LightningConnection, Error>?
-    private var pendingConnectionPromise: Promise<LightningConnection>?
+    private var connectionTask: Task<LightningSmartCardConnection, Error>?
+    private var pendingConnectionPromise: Promise<LightningSmartCardConnection>?
     private var connectionState: (connectionID: ConnectionID, didCloseConnection: (Promise<Error?>))?
 
     private init() {}
 
-    func connect() async throws -> LightningConnection {
+    func connect() async throws -> LightningSmartCardConnection {
         // If a connection task is already running, await its result
         if let connectionTask {
             trace(message: "awaiting existing connection task")
@@ -89,7 +89,7 @@ private actor LightningConnectionManager {
         }
 
         // Otherwise, create and store a new connection task.
-        let task = Task { () -> LightningConnection in
+        let task = Task { () -> LightningSmartCardConnection in
             // When the task finishes (on any path), clear it to allow a new connection.
             defer { self.connectionTask = nil }
 
@@ -103,7 +103,7 @@ private actor LightningConnectionManager {
                 }
 
                 // Create a promise to bridge the callback from EAAccessoryWrapper
-                let connectionPromise: Promise<LightningConnection> = .init()
+                let connectionPromise: Promise<LightningSmartCardConnection> = .init()
                 self.pendingConnectionPromise = connectionPromise
 
                 // Connect to YubiKeys that are already plugged in
@@ -130,7 +130,7 @@ private actor LightningConnectionManager {
         return try await task.value
     }
 
-    func transmit(request: Data, for connection: LightningConnection) async throws -> Data {
+    func transmit(request: Data, for connection: LightningSmartCardConnection) async throws -> Data {
         let connectionID = connection.accessoryConnectionID
         trace(message: "\(request.count) bytes to connection \(connectionID)")
 
@@ -144,7 +144,7 @@ private actor LightningConnectionManager {
         return try await EAAccessoryWrapper.shared.transmit(id: connectionID, data: request)
     }
 
-    func close(for connection: LightningConnection, error: Error?) async {
+    func close(for connection: LightningSmartCardConnection, error: Error?) async {
         guard let state = connectionState,
             state.connectionID == connection.accessoryConnectionID
         else { return }
@@ -155,7 +155,7 @@ private actor LightningConnectionManager {
         connectionState = nil
     }
 
-    func didClose(for connection: LightningConnection) async -> Error? {
+    func didClose(for connection: LightningSmartCardConnection) async -> Error? {
         guard let state = connectionState,
             state.connectionID == connection.accessoryConnectionID
         else { return nil }
@@ -169,7 +169,7 @@ private actor LightningConnectionManager {
         guard let promise = pendingConnectionPromise else { return }
 
         connectionState = (connectionID: connectionID, didCloseConnection: Promise<Error?>())
-        let connection = LightningConnection(accessoryConnectionID: connectionID)
+        let connection = LightningSmartCardConnection(accessoryConnectionID: connectionID)
         await promise.fulfill(connection)
     }