Kit: make it possible to opt-out from automatically raising the reasserting flag.

Signed-off-by: Andrej Mihajlov <and@mullvad.net>

Sources/WireGuardKit/PrivateKey.swift

@@ -7,32 +7,8 @@ import Foundation
 import WireGuardKitC
 #endif
 
-/// Umbrella protocol for all kinds of keys.
-public protocol WireGuardKey: RawRepresentable, Hashable, Codable where RawValue == Data {}
-
-/// Class describing a private key used by WireGuard.
-public final class PrivateKey: WireGuardKey {
-    public let rawValue: Data
-
-    /// Initialize the key with existing raw representation
-    public init?(rawValue: Data) {
-        if rawValue.count == WG_KEY_LEN {
-            self.rawValue = rawValue
-        } else {
-            return nil
-        }
-    }
-
-    /// Initialize new private key
-    convenience public init() {
-        var privateKeyData = Data(repeating: 0, count: Int(WG_KEY_LEN))
-        privateKeyData.withUnsafeMutableBytes { (rawBufferPointer: UnsafeMutableRawBufferPointer) in
-            let privateKeyBytes = rawBufferPointer.baseAddress!.assumingMemoryBound(to: UInt8.self)
-            curve25519_generate_private_key(privateKeyBytes)
-        }
-        self.init(rawValue: privateKeyData)!
-    }
-
+/// The class describing a private key used by WireGuard.
+public class PrivateKey: BaseKey {
     /// Derived public key
     public var publicKey: PublicKey {
         return rawValue.withUnsafeBytes { (privateKeyBufferPointer: UnsafeRawBufferPointer) -> PublicKey in
@@ -47,38 +23,29 @@ public final class PrivateKey: WireGuardKey {
             return PublicKey(rawValue: publicKeyData)!
         }
     }
-}
 
-/// Class describing a public key used by WireGuard.
-public final class PublicKey: WireGuardKey {
-    public let rawValue: Data
-
-    /// Initialize the key with existing raw representation
-    public init?(rawValue: Data) {
-        if rawValue.count == WG_KEY_LEN {
-            self.rawValue = rawValue
-        } else {
-            return nil
+    /// Initialize new private key
+    convenience public init() {
+        var privateKeyData = Data(repeating: 0, count: Int(WG_KEY_LEN))
+        privateKeyData.withUnsafeMutableBytes { (rawBufferPointer: UnsafeMutableRawBufferPointer) in
+            let privateKeyBytes = rawBufferPointer.baseAddress!.assumingMemoryBound(to: UInt8.self)
+            curve25519_generate_private_key(privateKeyBytes)
         }
+        self.init(rawValue: privateKeyData)!
     }
 }
 
-/// Class describing a pre-shared key used by WireGuard.
-public final class PreSharedKey: WireGuardKey {
+/// The class describing a public key used by WireGuard.
+public class PublicKey: BaseKey {}
+
+/// The class describing a pre-shared key used by WireGuard.
+public class PreSharedKey: BaseKey {}
+
+/// The base key implementation. Should not be used directly.
+public class BaseKey: RawRepresentable, Equatable, Hashable {
+    /// Raw key representation
     public let rawValue: Data
 
-    /// Initialize the key with existing raw representation
-    public init?(rawValue: Data) {
-        if rawValue.count == WG_KEY_LEN {
-            self.rawValue = rawValue
-        } else {
-            return nil
-        }
-    }
-}
-
-// Default implementation
-extension WireGuardKey {
     /// Hex encoded representation
     public var hexKey: String {
         return rawValue.withUnsafeBytes { (rawBufferPointer: UnsafeRawBufferPointer) -> String in
@@ -99,8 +66,17 @@ extension WireGuardKey {
         }
     }
 
+    /// Initialize the key with existing raw representation
+    required public init?(rawValue: Data) {
+        if rawValue.count == WG_KEY_LEN {
+            self.rawValue = rawValue
+        } else {
+            return nil
+        }
+    }
+
     /// Initialize the key with hex representation
-    public init?(hexKey: String) {
+    public convenience init?(hexKey: String) {
         var bytes = Data(repeating: 0, count: Int(WG_KEY_LEN))
         let success = bytes.withUnsafeMutableBytes { (bufferPointer: UnsafeMutableRawBufferPointer) -> Bool in
             return key_from_hex(bufferPointer.baseAddress!.assumingMemoryBound(to: UInt8.self), hexKey)
@@ -113,7 +89,7 @@ extension WireGuardKey {
     }
 
     /// Initialize the key with base64 representation
-    public init?(base64Key: String) {
+    public convenience init?(base64Key: String) {
         var bytes = Data(repeating: 0, count: Int(WG_KEY_LEN))
         let success = bytes.withUnsafeMutableBytes { (bufferPointer: UnsafeMutableRawBufferPointer) -> Bool in
             return key_from_base64(bufferPointer.baseAddress!.assumingMemoryBound(to: UInt8.self), base64Key)
@@ -125,31 +101,7 @@ extension WireGuardKey {
         }
     }
 
-    // MARK: - Codable
-
-    public init(from decoder: Decoder) throws {
-        let container = try decoder.singleValueContainer()
-        let data = try container.decode(Data.self)
-
-        if let instance = Self.init(rawValue: data) {
-            self = instance
-        } else {
-            throw DecodingError.dataCorruptedError(
-                in: container,
-                debugDescription: "Corrupt key data."
-            )
-        }
-    }
-
-    public func encode(to encoder: Encoder) throws {
-        var container = encoder.singleValueContainer()
-
-        try container.encode(rawValue)
-    }
-
-    // MARK: - Equatable
-
-    public static func == (lhs: Self, rhs: Self) -> Bool {
+    public static func == (lhs: BaseKey, rhs: BaseKey) -> Bool {
         return lhs.rawValue.withUnsafeBytes { (lhsBytes: UnsafeRawBufferPointer) -> Bool in
             return rhs.rawValue.withUnsafeBytes { (rhsBytes: UnsafeRawBufferPointer) -> Bool in
                 return key_eq(

Sources/WireGuardKit/WireGuardAdapter.swift

@@ -56,6 +56,10 @@ public class WireGuardAdapter {
     /// Adapter state.
     private var state: State = .stopped
 
+    /// Whether adapter should automatically raise the `reasserting` flag when updating
+    /// tunnel configuration.
+    private let shouldHandleReasserting: Bool
+
     /// Tunnel device file descriptor.
     private var tunnelFileDescriptor: Int32? {
         var ctlInfo = ctl_info()
@@ -128,9 +132,12 @@ public class WireGuardAdapter {
     /// Designated initializer.
     /// - Parameter packetTunnelProvider: an instance of `NEPacketTunnelProvider`. Internally stored
     ///   as a weak reference.
+    /// - Parameter shouldHandleReasserting: whether adapter should automatically raise the
+    ///   `reasserting` flag when updating tunnel configuration.
     /// - Parameter logHandler: a log handler closure.
-    public init(with packetTunnelProvider: NEPacketTunnelProvider, logHandler: @escaping LogHandler) {
+    public init(with packetTunnelProvider: NEPacketTunnelProvider, shouldHandleReasserting: Bool = true, logHandler: @escaping LogHandler) {
         self.packetTunnelProvider = packetTunnelProvider
+        self.shouldHandleReasserting = shouldHandleReasserting
         self.logHandler = logHandler
 
         setupLogHandler()
@@ -248,9 +255,14 @@ public class WireGuardAdapter {
             // Tell the system that the tunnel is going to reconnect using new WireGuard
             // configuration.
             // This will broadcast the `NEVPNStatusDidChange` notification to the GUI process.
-            self.packetTunnelProvider?.reasserting = true
+            if self.shouldHandleReasserting {
+                self.packetTunnelProvider?.reasserting = true
+            }
+
             defer {
-                self.packetTunnelProvider?.reasserting = false
+                if self.shouldHandleReasserting {
+                    self.packetTunnelProvider?.reasserting = false
+                }
             }
 
             do {