AmneziaSync

Author: YaroCabbage

Sources/Shared/Keychain.swift

@@ -27,7 +27,7 @@ class Keychain {
         if bundleIdentifier.hasSuffix(".network-extension") {
             bundleIdentifier.removeLast(".network-extension".count)
         }
-        let itemLabel = "WireGuard Tunnel: \(name)"
+        let itemLabel = "AmneziaWG Tunnel: \(name)"
         var items: [CFString: Any] = [kSecClass: kSecClassGenericPassword,
                                     kSecAttrLabel: itemLabel,
                                     kSecAttrAccount: name + ": " + UUID().uuidString,

Sources/Shared/Logging/Logger.swift

@@ -4,7 +4,7 @@
 import Foundation
 import os.log
 
-class Logger {
+public class Logger {
     enum LoggerError: Error {
         case openFailure
     }

Sources/Shared/Model/NETunnelProviderProtocol+Extension.swift

@@ -11,7 +11,7 @@ enum PacketTunnelProviderError: String, Error {
     case couldNotSetNetworkSettings
 }
 
-public extension NETunnelProviderProtocol {
+extension NETunnelProviderProtocol {
     convenience init?(tunnelConfiguration: TunnelConfiguration, previouslyFrom old: NEVPNProtocol? = nil) {
         self.init()
 

Sources/Shared/Model/TunnelConfiguration+WgQuickConfig.swift

@@ -3,7 +3,7 @@
 
 import Foundation
 
-public extension TunnelConfiguration {
+extension TunnelConfiguration {
 
     enum ParserState {
         case inInterfaceSection
@@ -22,6 +22,7 @@ public extension TunnelConfiguration {
         case interfaceHasInvalidDNS(String)
         case interfaceHasInvalidMTU(String)
         case interfaceHasUnrecognizedKey(String)
+        case interfaceHasInvalidCustomParam(String)
         case peerHasNoPublicKey
         case peerHasInvalidPublicKey(String)
         case peerHasInvalidPreSharedKey(String)
@@ -71,7 +72,33 @@ public extension TunnelConfiguration {
                     } else {
                         attributes[key] = value
                     }
-                    let interfaceSectionKeys: Set<String> = ["privatekey", "listenport", "address", "dns", "mtu"]
+                    let interfaceSectionKeys: Set<String> = [
+                        "privatekey",
+                        "listenport",
+                        "address",
+                        "dns",
+                        "mtu",
+                        "jc",
+                        "jmin",
+                        "jmax",
+                        "s1",
+                        "s2",
+                        "s3",
+                        "s4",
+                        "h1",
+                        "h2",
+                        "h3",
+                        "h4",
+                        "i1",
+                        "i2",
+                        "i3",
+                        "i4",
+                        "i5",
+                        "j1",
+                        "j2",
+                        "j3",
+                        "itime",
+                    ]
                     let peerSectionKeys: Set<String> = ["publickey", "presharedkey", "allowedips", "endpoint", "persistentkeepalive"]
                     if parserState == .inInterfaceSection {
                         guard interfaceSectionKeys.contains(key) else {
@@ -129,6 +156,67 @@ public extension TunnelConfiguration {
         if let listenPort = interface.listenPort {
             output.append("ListenPort = \(listenPort)\n")
         }
+
+        if let junkPacketCount = interface.junkPacketCount {
+            output.append("Jc = \(junkPacketCount)\n")
+        }
+        if let junkPacketMinSize = interface.junkPacketMinSize {
+            output.append("Jmin = \(junkPacketMinSize)\n")
+        }
+        if let junkPacketMaxSize = interface.junkPacketMaxSize {
+            output.append("Jmax = \(junkPacketMaxSize)\n")
+        }
+        if let initPacketJunkSize = interface.initPacketJunkSize {
+            output.append("S1 = \(initPacketJunkSize)\n")
+        }
+        if let responsePacketJunkSize = interface.responsePacketJunkSize {
+            output.append("S2 = \(responsePacketJunkSize)\n")
+        }
+        if let cookieReplyPacketJunkSize = interface.cookieReplyPacketJunkSize {
+            output.append("S3 = \(cookieReplyPacketJunkSize)\n")
+        }
+        if let transportPacketJunkSize = interface.transportPacketJunkSize {
+            output.append("S4 = \(transportPacketJunkSize)\n")
+        }
+        if let initPacketMagicHeader = interface.initPacketMagicHeader {
+            output.append("H1 = \(initPacketMagicHeader)\n")
+        }
+        if let responsePacketMagicHeader = interface.responsePacketMagicHeader {
+            output.append("H2 = \(responsePacketMagicHeader)\n")
+        }
+        if let underloadPacketMagicHeader = interface.underloadPacketMagicHeader {
+            output.append("H3 = \(underloadPacketMagicHeader)\n")
+        }
+        if let transportPacketMagicHeader = interface.transportPacketMagicHeader {
+            output.append("H4 = \(transportPacketMagicHeader)\n")
+        }
+        if let specialJunk1 = interface.specialJunk1 {
+            output.append("I1 = \(specialJunk1)\n")
+        }
+        if let specialJunk2 = interface.specialJunk2 {
+            output.append("I2 = \(specialJunk2)\n")
+        }
+        if let specialJunk3 = interface.specialJunk3 {
+            output.append("I3 = \(specialJunk3)\n")
+        }
+        if let specialJunk4 = interface.specialJunk4 {
+            output.append("I4 = \(specialJunk4)\n")
+        }
+        if let specialJunk5 = interface.specialJunk5 {
+            output.append("I5 = \(specialJunk5)\n")
+        }
+        if let controlledJunk1 = interface.controlledJunk1 {
+            output.append("J1 = \(controlledJunk1)\n")
+        }
+        if let controlledJunk2 = interface.controlledJunk2 {
+            output.append("J2 = \(controlledJunk2)\n")
+        }
+        if let controlledJunk3 = interface.controlledJunk3 {
+            output.append("J3 = \(controlledJunk3)\n")
+        }
+        if let specialHandshakeTimeout = interface.specialHandshakeTimeout {
+            output.append("Itime = \(specialHandshakeTimeout)\n")
+        }
         if !interface.addresses.isEmpty {
             let addressString = interface.addresses.map { $0.stringRepresentation }.joined(separator: ", ")
             output.append("Address = \(addressString)\n")
@@ -207,6 +295,102 @@ public extension TunnelConfiguration {
             }
             interface.mtu = mtu
         }
+        if let junkPacketCountString = attributes["jc"] {
+            guard let junkPacketCount = UInt16(junkPacketCountString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(junkPacketCountString)
+            }
+            interface.junkPacketCount = junkPacketCount
+        }
+        if let junkPacketMinSizeString = attributes["jmin"] {
+            guard let junkPacketMinSize = UInt16(junkPacketMinSizeString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(junkPacketMinSizeString)
+            }
+            interface.junkPacketMinSize = junkPacketMinSize
+        }
+        if let junkPacketMaxSizeString = attributes["jmax"] {
+            guard let junkPacketMaxSize = UInt16(junkPacketMaxSizeString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(junkPacketMaxSizeString)
+            }
+            interface.junkPacketMaxSize = junkPacketMaxSize
+        }
+        if let initPacketJunkSizeString = attributes["s1"] {
+            guard let initPacketJunkSize = UInt16(initPacketJunkSizeString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(initPacketJunkSizeString)
+            }
+            interface.initPacketJunkSize = initPacketJunkSize
+        }
+        if let responsePacketJunkSizeString = attributes["s2"] {
+            guard let responsePacketJunkSize = UInt16(responsePacketJunkSizeString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(responsePacketJunkSizeString)
+            }
+            interface.responsePacketJunkSize = responsePacketJunkSize
+        }
+        if let cookieReplyPacketJunkSizeString = attributes["s3"] {
+            guard let cookieReplyPacketJunkSize = UInt16(cookieReplyPacketJunkSizeString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(cookieReplyPacketJunkSizeString)
+            }
+            interface.cookieReplyPacketJunkSize = cookieReplyPacketJunkSize
+        }
+        if let transportPacketJunkSizeString = attributes["s4"] {
+            guard let transportPacketJunkSize = UInt16(transportPacketJunkSizeString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(transportPacketJunkSizeString)
+            }
+            interface.transportPacketJunkSize = transportPacketJunkSize
+        }
+        if let initPacketMagicHeaderString = attributes["h1"] {
+            guard let initPacketMagicHeader = UInt32(initPacketMagicHeaderString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(initPacketMagicHeaderString)
+            }
+            interface.initPacketMagicHeader = initPacketMagicHeader
+        }
+        if let responsePacketMagicHeaderString = attributes["h2"] {
+            guard let responsePacketMagicHeader = UInt32(responsePacketMagicHeaderString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(responsePacketMagicHeaderString)
+            }
+            interface.responsePacketMagicHeader = responsePacketMagicHeader
+        }
+        if let underloadPacketMagicHeaderString = attributes["h3"] {
+            guard let underloadPacketMagicHeader = UInt32(underloadPacketMagicHeaderString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(underloadPacketMagicHeaderString)
+            }
+            interface.underloadPacketMagicHeader = underloadPacketMagicHeader
+        }
+        if let transportPacketMagicHeaderString = attributes["h4"] {
+            guard let transportPacketMagicHeader = UInt32(transportPacketMagicHeaderString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(transportPacketMagicHeaderString)
+            }
+            interface.transportPacketMagicHeader = transportPacketMagicHeader
+        }
+        if let specialJunk1String = attributes["i1"] {
+            interface.specialJunk1 = specialJunk1String
+        }
+        if let specialJunk2String = attributes["i2"] {
+            interface.specialJunk2 = specialJunk2String
+        }
+        if let specialJunk3String = attributes["i3"] {
+            interface.specialJunk3 = specialJunk3String
+        }
+        if let specialJunk4String = attributes["i4"] {
+            interface.specialJunk4 = specialJunk4String
+        }
+        if let specialJunk5String = attributes["i5"] {
+            interface.specialJunk5 = specialJunk5String
+        }
+        if let controlledJunk1String = attributes["j1"] {
+            interface.controlledJunk1 = controlledJunk1String
+        }
+        if let controlledJunk2String = attributes["j2"] {
+            interface.controlledJunk2 = controlledJunk2String
+        }
+        if let controlledJunk3String = attributes["j3"] {
+            interface.controlledJunk3 = controlledJunk3String
+        }
+        if let specialHandshakeTimeoutString = attributes["itime"] {
+            guard let specialHandshakeTimeout = Int(specialHandshakeTimeoutString) else {
+                throw ParseError.interfaceHasInvalidCustomParam(specialHandshakeTimeoutString)
+            }
+            interface.specialHandshakeTimeout = specialHandshakeTimeout
+        }
         return interface
     }