[#3] Implement HCI LE Commands

.swiftlint.yml

@@ -13,6 +13,7 @@ disabled_rules: # rule identifiers to exclude from running
   - unused_optional_binding
   - redundant_discardable_let
   - todo
+  - identifier_name
 opt_in_rules: # some rules are only opt-in
   - empty_count
   # Find all the available rules by running:
@@ -38,11 +39,4 @@ type_name:
     warning: 50
     error: 60
   excluded: iPhone # excluded via string
-identifier_name:
-  min_length: # only min_length
-    error: 2 # only error
-  excluded: # excluded via string array
-    - id
-    - URL
-    - GlobalAPIKey
 reporter: "xcode"

Sources/LowEnergyCommandParameter.swift

@@ -811,6 +811,82 @@ public extension LowEnergyCommand {
             ]
         }
     }
+
+    /// LE Start Encryption Command
+    ///
+    /// command is used to authenticate the given encryption key associated with the remote device specified
+    /// by the Connection_Handle, and once authenticated will encrypt the connection.
+    ///
+    /// If the connection is already encrypted then the Controller shall pause connection encryption
+    /// before attempting to authenticate the given encryption key, and then re-encrypt the connection.
+    /// While encryption is paused no user data shall be transmitted.
+    ///
+    /// On an authentication failure, the connection shall be automatically disconnected
+    /// by the Link Layer. If this command succeeds, then the connection shall be encrypted.
+    ///
+    /// This command shall only be used when the local device’s role is Master.
+    public struct StartEncryptionParameter: HCICommandParameter {
+
+        public static let command = LowEnergyCommand.startEncryption
+
+        /// Range 0x0000-0x0EFF (all other values reserved for future use)
+        public let connectionHandle: UInt16 //Connection_Handle
+
+        /// 64 bit random number.
+        public let randomNumber: UInt64 //Random_Number
+
+        /// 16 bit encrypted diversifier.
+        public let encryptedDiversifier: UInt16 //Encrypted_Diversifier
+
+        /// 128 bit long term key.
+        public let longTermKey: UInt128 //Long_Term_Key
+
+        public init(connectionHandle: UInt16, randomNumber: UInt64, encryptedDiversifier: UInt16, longTermKey: UInt128) {
+
+            self.connectionHandle = connectionHandle
+            self.randomNumber = randomNumber
+            self.encryptedDiversifier = encryptedDiversifier
+            self.longTermKey = longTermKey
+        }
+
+        public var byteValue: [UInt8] {
+            let connectionHandleBytes = connectionHandle.littleEndian.bytes
+            let randomNumberBytes = randomNumber.littleEndian.bytes
+            let encryptedDiversifierBytes = encryptedDiversifier.littleEndian.bytes
+            let longTermKeyBytes = longTermKey.littleEndian.bytes
+
+            return [
+                connectionHandleBytes.0,
+                connectionHandleBytes.1,
+                randomNumberBytes.0,
+                randomNumberBytes.1,
+                randomNumberBytes.2,
+                randomNumberBytes.3,
+                randomNumberBytes.4,
+                randomNumberBytes.5,
+                randomNumberBytes.6,
+                randomNumberBytes.7,
+                encryptedDiversifierBytes.0,
+                encryptedDiversifierBytes.1,
+                longTermKeyBytes.0,
+                longTermKeyBytes.1,
+                longTermKeyBytes.2,
+                longTermKeyBytes.3,
+                longTermKeyBytes.4,
+                longTermKeyBytes.5,
+                longTermKeyBytes.6,
+                longTermKeyBytes.7,
+                longTermKeyBytes.8,
+                longTermKeyBytes.9,
+                longTermKeyBytes.10,
+                longTermKeyBytes.11,
+                longTermKeyBytes.12,
+                longTermKeyBytes.13,
+                longTermKeyBytes.14,
+                longTermKeyBytes.15
+            ]
+        }
+    }
 }
 
 // MARK: - Command Return Parameters

Sources/LowEnergyEncryption.swift

@@ -32,4 +32,15 @@ public extension BluetoothHostControllerInterface {
 
         return returnParameters.randomNumber
     }
+
+    /// LE Start Encryption Command
+    ///
+    /// The command is used to authenticate the given encryption key associated with the remote device specified
+    /// by the Connection_Handle, and once authenticated will encrypt the connection.
+    func lowEnergyStartEncryption(connectionHandle: UInt16, randomNumber: UInt64, encryptedDiversifier: UInt16, longTermKey: UInt128, timeout: HCICommandTimeout = .default) throws {
+
+        let command = LowEnergyCommand.StartEncryptionParameter(connectionHandle: connectionHandle,randomNumber: randomNumber, encryptedDiversifier: encryptedDiversifier, longTermKey: longTermKey)
+
+        try deviceRequest(command, timeout: timeout)
+    }
 }

Sources/LowEnergyEvent.swift

@@ -23,6 +23,12 @@ public enum LowEnergyEvent: UInt8, HCIEvent {
 
     /// LE Long Term Key Request
     case longTermKeyRequest                 = 0x05
+
+    /// LE Encryption Change
+    case encryptionChange                   = 0x08
+
+    /// LE Encryption Key Refresh Complete
+    case encryptionKeyRefreshComplete       = 0x30
 }
 
 // MARK: - Name

Sources/LowEnergyEventParameter.swift

@@ -426,4 +426,105 @@ public extension LowEnergyEvent {
             self.features = LowEnergyFeatureSet(rawValue: featuresRawValue)
         }
     }
+
+    /// LE Encryption Change Event
+    ///
+    /// The Encryption Change event is used to indicate that the change of the encryption mode has been completed.
+    ///
+    /// This event will occur on both devices to notify the Hosts when Encryption has changed for all connections between the two devices.
+    /// Note: This event shall not be generated if encryption is paused or resumed; during a role switch, for example.
+    public struct EncryptionChangeParameter: HCIEventParameter {
+        public static let event = LowEnergyEvent.encryptionChange // 0x08
+
+        public static let length: Int = 4
+
+        public let status: HCIStatus
+
+        /// The Connection_Handle will be a Connection_Handle for an ACL connection and is used to identify the remote device.
+        public let handle: UInt16 // Connection_Handle
+
+        /// The Encryption_Enabled event parameter specifies the new Encryption_Enabled parameter
+        /// for the Connection_Handle specified by the Connection_Handle event parameter.
+        ///
+        /// The meaning of the Encryption_Enabled parameter depends on whether the Host has indicated support for Secure Connections in the Secure_Connections_Host_Support parameter.
+        /// When Secure_Connections_Host_Support is ‘disabled’ or the Connection_Handle refers to an LE link, the Controller
+        /// shall only use Encryption_Enabled values 0x00 (OFF) and 0x01 (ON). When Secure_Connections_Host_Support is ‘enabled’ and
+        /// the Connection_Handle refers to a BR/EDR link, the Controller shall set Encryption_Enabled to 0x00 when encryption is off,
+        /// to 0x01 when encryption is on and using E0 and to 0x02 when encryption is on and using AES-CCM.
+        public let encryptionEnabled: EncryptionEnabled
+
+        public init?(byteValue: [UInt8]) {
+            guard byteValue.count == EncryptionChangeParameter.length
+                else { return nil }
+
+            let statusByte = byteValue[0]
+
+            let handle = UInt16(littleEndian: UInt16(bytes: (byteValue[1], byteValue[2])))
+
+            let encryptionEnabledByte = byteValue[3]
+
+            guard let status = HCIStatus(rawValue: statusByte)
+                else { return nil }
+
+            guard let encryptionEnabled = EncryptionEnabled(rawValue: encryptionEnabledByte)
+                else { return nil }
+
+            self.status = status
+            self.handle = handle
+            self.encryptionEnabled = encryptionEnabled
+        }
+
+        public enum EncryptionEnabled: UInt8 { // Encryption_Enabled
+
+            /// Link Level Encryption is OFF.
+            case off         = 0x00
+
+            /// Link Level Encryption is ON with E0 for BR/EDR.
+            /// Link Level Encryption is ON with AES-CCM for LE.
+            case e0          = 0x01
+
+            /// Link Level Encryption is ON with AES-CCM for BR/EDR.
+            case aes         = 0x02
+        }
+    }
+
+    /// LE Encryption Key Refresh Complete Event
+    ///
+    /// The Encryption Key Refresh Complete event is used to indicate to the Host that the encryption key was
+    /// refreshed on the given Connection_Handle any time encryption is paused and then resumed.
+    /// The BR/EDR Controller shall send this event when the encryption key has been refreshed
+    /// due to encryption being started or resumed.
+    ///
+    /// If the Encryption Key Refresh Complete event was generated due to an encryption pause
+    /// and resume operation embedded within a change connection link key procedure, t
+    /// he Encryption Key Refresh Complete event shall be sent prior to the Change Connection Link Key Complete event.
+    ///
+    /// If the Encryption Key Refresh Complete event was generated due to an encryption pause and
+    /// resume operation embedded within a role switch procedure,
+    /// the Encryption Key Refresh Complete event shall be sent prior to the Role Change event.
+    public struct EncryptionKeyRefreshCompleteParameter: HCIEventParameter {
+
+        public static let event = LowEnergyEvent.encryptionKeyRefreshComplete // 0x30
+
+        public static let length: Int = 3
+
+        public let status: HCIStatus
+
+        public let handle: UInt16 // Connection_Handle
+
+        public init?(byteValue: [UInt8]) {
+            guard byteValue.count == EncryptionKeyRefreshCompleteParameter.length
+                else { return nil }
+
+            let statusByte = byteValue[0]
+
+            let handle = UInt16(littleEndian: UInt16(bytes: (byteValue[1], byteValue[2])))
+
+            guard let status = HCIStatus(rawValue: statusByte)
+                else { return nil }
+
+            self.status = status
+            self.handle = handle
+        }
+    }
 }