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.
+/// The class describing a private key used by WireGuard.
-public protocol WireGuardKey: RawRepresentable, Hashable, Codable where RawValue == Data {}
+public class PrivateKey: BaseKey {
-
-/// 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)!
-    }
-
     /// 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.
+    /// Initialize new private key
-public final class PublicKey: WireGuardKey {
+    convenience public init() {
-    public let rawValue: Data
+        var privateKeyData = Data(repeating: 0, count: Int(WG_KEY_LEN))
-
+        privateKeyData.withUnsafeMutableBytes { (rawBufferPointer: UnsafeMutableRawBufferPointer) in
-    /// Initialize the key with existing raw representation
+            let privateKeyBytes = rawBufferPointer.baseAddress!.assumingMemoryBound(to: UInt8.self)
-    public init?(rawValue: Data) {
+            curve25519_generate_private_key(privateKeyBytes)
-        if rawValue.count == WG_KEY_LEN {
-            self.rawValue = rawValue
-        } else {
-            return nil
         }
+        self.init(rawValue: privateKeyData)!
     }
 }
 
-/// Class describing a pre-shared key used by WireGuard.
+/// The class describing a public key used by WireGuard.
-public final class PreSharedKey: WireGuardKey {
+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 static func == (lhs: BaseKey, rhs: BaseKey) -> Bool {
-
-    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 {
         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,40 +255,68 @@ 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 {
-            defer {
+                self.packetTunnelProvider?.reasserting = true
-                self.packetTunnelProvider?.reasserting = false
             }
 
-            do {
+            defer {
-                let settingsGenerator = try self.makeSettingsGenerator(with: tunnelConfiguration)
+                if self.shouldHandleReasserting {
-                try self.setNetworkSettings(settingsGenerator.generateNetworkSettings())
+                    self.packetTunnelProvider?.reasserting = false
-
-                switch self.state {
-                case .started(let handle, _):
-                    let (wgConfig, resolutionResults) = settingsGenerator.uapiConfiguration()
-                    self.logEndpointResolutionResults(resolutionResults)
-
-                    wgSetConfig(handle, wgConfig)
-                    #if os(iOS)
-                    wgDisableSomeRoamingForBrokenMobileSemantics(handle)
-                    #endif
-
-                    self.state = .started(handle, settingsGenerator)
-
-                case .temporaryShutdown:
-                    self.state = .temporaryShutdown(settingsGenerator)
-
-                case .stopped:
-                    fatalError()
                 }
+            }
 
-                completionHandler(nil)
+            let settingsGenerator: PacketTunnelSettingsGenerator
+            do {
+                settingsGenerator = try self.makeSettingsGenerator(with: tunnelConfiguration)
             } catch let error as WireGuardAdapterError {
                 completionHandler(error)
+                return
             } catch {
                 fatalError()
             }
+
+            switch self.state {
+            case .started(let handle, _):
+                do {
+                    try self.setNetworkSettings(settingsGenerator.generateNetworkSettings())
+                } catch let error as WireGuardAdapterError {
+                    completionHandler(error)
+                    return
+                } catch {
+                    fatalError()
+                }
+
+                let (wgConfig, resolutionResults) = settingsGenerator.uapiConfiguration()
+                self.logEndpointResolutionResults(resolutionResults)
+
+                wgSetConfig(handle, wgConfig)
+                #if os(iOS)
+                wgDisableSomeRoamingForBrokenMobileSemantics(handle)
+                #endif
+
+                self.state = .started(handle, settingsGenerator)
+
+            case .temporaryShutdown:
+                // On iOS 15.1 or newer, updating network settings may fail when in airplane mode.
+                // Network path monitor will retry updating settings later when connectivity is
+                // back online.
+                do {
+                    try self.setNetworkSettings(settingsGenerator.generateNetworkSettings())
+                } catch let error as WireGuardAdapterError {
+                    if case .setNetworkSettings(let systemError) = error {
+                        self.logHandler(.verbose, "Failed to set network settings while offline. Will retry when connectivity is back online. Error: \(systemError.localizedDescription)")
+                    }
+                } catch {
+                    fatalError()
+                }
+
+                self.state = .temporaryShutdown(settingsGenerator)
+
+            case .stopped:
+                fatalError()
+            }
+
+            completionHandler(nil)
         }
     }