Correct capacity argument when casting memory to sockaddr_* type.

The capacity argument indicates the number of instances of sockaddr_* and not
number of bytes within the pointer.

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

Sources/WireGuardKit/IPAddress+AddrInfo.swift

@@ -8,7 +8,10 @@ extension IPv4Address {
     init?(addrInfo: addrinfo) {
         guard addrInfo.ai_family == AF_INET else { return nil }
 
-        let addressData = addrInfo.ai_addr.withMemoryRebound(to: sockaddr_in.self, capacity: MemoryLayout<sockaddr_in>.size) { ptr -> Data in
+        let addressData = addrInfo.ai_addr.withMemoryRebound(
+            to: sockaddr_in.self,
+            capacity: 1
+        ) { ptr -> Data in
             return Data(bytes: &ptr.pointee.sin_addr, count: MemoryLayout<in_addr>.size)
         }
 
@@ -20,7 +23,10 @@ extension IPv6Address {
     init?(addrInfo: addrinfo) {
         guard addrInfo.ai_family == AF_INET6 else { return nil }
 
-        let addressData = addrInfo.ai_addr.withMemoryRebound(to: sockaddr_in6.self, capacity: MemoryLayout<sockaddr_in6>.size) { ptr -> Data in
+        let addressData = addrInfo.ai_addr.withMemoryRebound(
+            to: sockaddr_in6.self,
+            capacity: 1
+        ) { ptr -> Data in
             return Data(bytes: &ptr.pointee.sin6_addr, count: MemoryLayout<in6_addr>.size)
         }
 

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(