Compare commits

..

2 Commits

Author SHA1 Message Date
1e74de12aa fix views 2025-08-05 14:06:35 +08:00
ed45954127 remove files 2025-08-03 22:27:57 +08:00
30 changed files with 208 additions and 4132 deletions

View File

@ -1,113 +0,0 @@
//
// ARPPacket.swift
// Tun
//
// Created by on 2024/8/25.
//
import Foundation
struct ARPPacket {
// ARP
enum Opcode: UInt16 {
case request = 0x01
case response = 0x02
func isRequest() -> Bool {
return self == .request
}
func isResponse() -> Bool {
return self == .response
}
}
var hardwareType: UInt16
var protocolType: UInt16
var hardwareSize: UInt8
var protocolSize: UInt8
var opcode: Opcode
var senderMAC: Data
var senderIP: UInt32
var targetMAC: Data
var targetIP: UInt32
init(hardwareType: UInt16, protocolType: UInt16, hardwareSize: UInt8, protocolSize: UInt8, opcode: Opcode,
senderMAC: Data, senderIP: UInt32, targetMAC: Data, targetIP: UInt32) {
self.hardwareType = hardwareType
self.protocolType = protocolType
self.hardwareSize = hardwareSize
self.protocolSize = protocolSize
self.opcode = opcode
self.senderMAC = senderMAC
self.senderIP = senderIP
self.targetMAC = targetMAC
self.targetIP = targetIP
}
init?(data: Data) {
guard data.count >= 28 else {
NSLog("length < 28: len: \(data.count)")
return nil
}
self.hardwareType = UInt16(data[0]) << 8 | UInt16(data[1])
self.protocolType = UInt16(data[2]) << 8 | UInt16(data[3])
self.hardwareSize = data[4]
self.protocolSize = data[5]
guard let opcode = Opcode(rawValue: UInt16(data[6]) << 8 | UInt16(data[7])) else {
NSLog("opcode error")
return nil
}
self.opcode = opcode
self.senderMAC = Data(data[8..<14])
self.senderIP = UInt32(data: Data(data[14..<18]))
self.targetMAC = Data(data[18..<24])
self.targetIP = UInt32(data: Data(data[24..<28]))
}
func marshal() -> Data {
var data = Data()
data.append(self.hardwareType.data())
data.append(self.protocolType.data())
data.append(self.hardwareSize)
data.append(self.protocolSize)
data.append(self.opcode.rawValue.data())
data.append(self.senderMAC)
data.append(Data(uint32: self.senderIP))
data.append(self.targetMAC)
data.append(Data(uint32: self.targetIP))
return data
}
}
extension ARPPacket {
static func arpRequest(senderIP: UInt32, senderMAC: Data, targetIP: UInt32) -> ARPPacket {
return ARPPacket(hardwareType: 0x01,
protocolType: 0x0800,
hardwareSize: 0x06,
protocolSize: 0x04,
opcode: .request,
senderMAC: senderMAC,
senderIP: senderIP,
targetMAC: Data([0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
targetIP: targetIP)
}
static func arpResponse(for arp: ARPPacket, mac: Data, ip: UInt32) -> ARPPacket {
return ARPPacket(hardwareType: arp.hardwareType,
protocolType: arp.protocolType,
hardwareSize: arp.hardwareSize,
protocolSize: arp.protocolSize,
opcode: .response,
senderMAC: mac,
senderIP: ip,
targetMAC: arp.senderMAC,
targetIP: arp.senderIP)
}
}

View File

@ -1,39 +0,0 @@
//
// DataExtension.swift
// Tun
//
// Created by on 2024/2/29.
//
import Foundation
extension Data {
init(uint32: UInt32) {
var bytes: [UInt8] = [UInt8](repeating: 0, count: 4)
bytes[0] = (UInt8)(uint32 >> 24 & 0xFF)
bytes[1] = (UInt8)(uint32 >> 16 & 0xFF)
bytes[2] = (UInt8)(uint32 >> 8 & 0xFF)
bytes[3] = (UInt8)(uint32 & 0xFF)
self.init(bytes)
}
init(uint16: UInt16) {
var bytes: [UInt8] = [UInt8](repeating: 0, count: 2)
bytes[0] = (UInt8)(uint16 >> 8 & 0xFF)
bytes[1] = (UInt8)(uint16 & 0xFF)
self.init(bytes)
}
init(components: Data...) {
var data = Data()
for component in components {
data.append(component)
}
self = data
}
}

View File

@ -1,83 +0,0 @@
//
// IPPacket.swift
// Tun
//
// Created by on 2024/1/18.
//
import Foundation
struct IPHeader {
let version: UInt8
let headerLength: UInt8
let typeOfService: UInt8
let totalLength: UInt16
let id: UInt16
let offset: UInt16
let timeToLive: UInt8
let proto:UInt8
let checksum: UInt16
let source: UInt32
let destination: UInt32
var source_ip: String {
return intToIp(source)
}
var destination_ip: String {
return intToIp(destination)
}
private func intToIp(_ num: UInt32) -> String {
let ip0 = (UInt8) (num >> 24 & 0xFF)
let ip1 = (UInt8) (num >> 16 & 0xFF)
let ip2 = (UInt8) (num >> 8 & 0xFF)
let ip3 = (UInt8) (num & 0xFF)
return "\(ip0).\(ip1).\(ip2).\(ip3)"
}
public var description: String {
"""
IPHeader version: \(version), header length: \(headerLength), type of service: \(typeOfService), total length: \(totalLength),
id: \(id), offset: \(offset), time ot live: \(timeToLive), proto: \(proto), checksum: \(checksum), source ip: \(source_ip), destination ip:\(destination_ip)
"""
}
}
enum IPVersion: UInt8 {
case ipv4 = 4
case ipv6 = 6
}
enum TransportProtocol: UInt8 {
case icmp = 1
case tcp = 6
case udp = 17
}
struct IPPacket {
let header: IPHeader
let data: Data
init?(_ data: Data) {
guard data.count >= 20 else {
return nil
}
self.header = IPHeader(version: data[0] >> 4,
headerLength: (data[0] & 0b1111) * 4,
typeOfService: data[1],
totalLength: UInt16(bytes: (data[2], data[3])),
id: UInt16(bytes: (data[4], data[5])),
offset: 1,
timeToLive: data[8],
proto: data[9],
checksum: UInt16(bytes: (data[10], data[11])),
source: UInt32(bytes: (data[12], data[13], data[14], data[15])),
destination: UInt32(bytes: (data[16], data[17], data[18], data[19])))
self.data = data
}
}

View File

@ -1,117 +0,0 @@
//
// LayerPacket.swift
// Tun
//
// Created by on 2024/8/21.
//
import Foundation
import zlib
struct LayerPacket {
//
enum PacketType: UInt16 {
case arp = 0x0806
case ipv4 = 0x0800
case ipv6 = 0x86DD
case taggedFrame = 0x8100
}
enum LayerPacketError: Error {
case invalidLength
case crcError
case invaldPacketType
}
struct MacAddress {
let data: Data
init(data: Data) {
self.data = data
}
func isBroadcast() -> Bool {
return data.count == 6 && self.data.allSatisfy { $0 == 0xFF}
}
func isMulticast() -> Bool {
return data.count == 6 && (data[0] == 0x01 && data[1] == 0x00 && data[2] == 0x5E)
}
func format() -> String {
// mac
let bytes = [UInt8](data)
return bytes.map { String(format: "%02X", $0) }.joined(separator: ":").lowercased()
}
static func description(data: Data) -> String {
// mac
let bytes = [UInt8](data)
return bytes.map { String(format: "%02X", $0) }.joined(separator: ":").lowercased()
}
}
let dstMac: Data
let srcMac: Data
let type: PacketType
let data: Data
init(dstMac: Data, srcMac: Data, type: PacketType, data: Data) {
self.dstMac = dstMac
self.srcMac = srcMac
self.type = type
self.data = data
}
init(layerData playload: Data) throws {
guard playload.count >= 14 else {
throw LayerPacketError.invalidLength
}
/*
let idx = layerData.count - 4
let playload = layerData.subdata(in: 0..<idx)
let crc = layerData.subdata(in: idx..<layerData.count)
guard Self.crc32(data: playload) == UInt32(data: crc) else {
NSLog("play crc32: \(Self.crc32(data: playload)), get: \(UInt32(data: crc))")
throw LayerPacketError.crcError
}
*/
self.dstMac = Data(playload[0..<6])
self.srcMac = Data(playload[6..<12])
guard let type = PacketType(rawValue: UInt16(bytes: (playload[12], playload[13]))) else {
throw LayerPacketError.invaldPacketType
}
self.type = type
self.data = Data(playload[14...])
}
func marshal() -> Data {
var packet = Data()
packet.append(dstMac)
packet.append(srcMac)
packet.append(self.type.rawValue.data())
packet.append(self.data)
// crc32
//let crc32 = data.crc32()
//packet.append(Data(uint32: Self.crc32(data: packet)))
return packet
}
private static func crc32(data: Data) -> UInt32 {
let crc = data.withUnsafeBytes { buffer in
return zlib.crc32(0, buffer.bindMemory(to: UInt8.self).baseAddress, uInt(buffer.count))
}
return UInt32(crc)
}
}

View File

@ -1,3 +1,11 @@
//
// NetworkInterface.swift
// punchnet
//
// Created by on 2025/8/3.
//
// //
// NetworkInterface.swift // NetworkInterface.swift
// Tun // Tun
@ -7,13 +15,13 @@
import Foundation import Foundation
struct NetworkInterface { public struct NetworkInterface {
let name: String public let name: String
let ip: String public let ip: String
let netmask: String public let netmask: String
} }
struct NetworkInterfaceManager { public struct NetworkInterfaceManager {
/** /**
, (let name: String let ip: String let netmask: String) , (let name: String let ip: String let netmask: String)
*/ */
@ -44,6 +52,7 @@ struct NetworkInterfaceManager {
if (getnameinfo(&addr, socklen_t(addr.sa_len), &hostname, socklen_t(hostname.count), if (getnameinfo(&addr, socklen_t(addr.sa_len), &hostname, socklen_t(hostname.count),
nil, socklen_t(0), NI_NUMERICHOST) == 0) { nil, socklen_t(0), NI_NUMERICHOST) == 0) {
let address = String(cString: hostname) let address = String(cString: hostname)
let name = ptr!.pointee.ifa_name! let name = ptr!.pointee.ifa_name!
let ifname = String(cString: name) let ifname = String(cString: name)

View File

@ -1,3 +1,11 @@
//
// PacketTunnelProvider.swift
// punchnet
//
// Created by on 2025/8/3.
//
// //
// PacketTunnelProvider.swift // PacketTunnelProvider.swift
// Tun // Tun
@ -6,6 +14,7 @@
// //
import NetworkExtension import NetworkExtension
import Punchnet
class PacketTunnelProvider: NEPacketTunnelProvider { class PacketTunnelProvider: NEPacketTunnelProvider {
var context: SDLContext? var context: SDLContext?
@ -16,38 +25,65 @@ class PacketTunnelProvider: NEPacketTunnelProvider {
return return
} }
let token = options["token"] as! String //
//let version = options["version"] as! Int guard self.context == nil else {
return
}
// let token = options["token"] as! String
let installed_channel = options["installed_channel"] as! String let installed_channel = options["installed_channel"] as! String
let superIp = options["super_ip"] as! String let superIp = options["super_ip"] as! String
Task { let superPort = options["super_port"] as! Int
SDLLogger.logLevel = .debug let stunServersStr = options["stun_servers"] as! String
do {
self.context = try SDLContext(provider: self, config: .init(
version: 1,
installedChannel: installed_channel,
//superHost: "118.178.229.213",
superHost: superIp,
superPort: 18083,
stunServers: [.init(host: superIp, ports: [1265, 1266]), .init(host: "118.178.229.213", ports: [1265, 1266])],
clientId: SDLContext.getUUID(),
token: ""
//token: token
))
let stunServers = stunServersStr.split(separator: ";").compactMap { server -> SDLConfiguration.StunServer? in
let parts = server.split(separator: ":", maxSplits: 2)
guard parts.count == 2 else {
return nil
}
let ports = parts[1].split(separator: ",", maxSplits: 2)
guard ports.count == 2, let port1 = Int(String(ports[0])), let port2 = Int(String(ports[1])) else {
return nil
}
return .init(host: String(parts[0]), ports: [port1, port2])
}
guard stunServers.count >= 2 else {
NSLog("stunServers配置错误")
return
}
let config = SDLConfiguration(version: 1,
installedChannel: installed_channel,
superHost: superIp,
superPort: superPort,
stunServers: stunServers,
clientId: SDLContext.getUUID(),
token: "")
//
let rsaCipher = try! CCRSACipher(keySize: 1024)
let aesChiper = CCAESChiper()
Task {
do {
self.context = SDLContext(provider: self, config: config, rsaCipher: rsaCipher, aesCipher: aesChiper, logger: SDLLogger(level: .warning))
try await self.context?.start() try await self.context?.start()
completionHandler(nil) completionHandler(nil)
} catch let err { } catch let err {
NSLog("SDLContext start get error: \(err)")
completionHandler(err) completionHandler(err)
} }
} }
} }
override func stopTunnel(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) { override func stopTunnel(with reason: NEProviderStopReason, completionHandler: @escaping () -> Void) {
// Add code here to start the process of stopping the tunnel. // Add code here to start the process of stopping the tunnel.
Task {
await self.context?.stop()
self.context = nil
}
completionHandler() completionHandler()
} }
@ -78,4 +114,51 @@ extension PacketTunnelProvider {
return interfaces.first {$0.name == "en0"} return interfaces.first {$0.name == "en0"}
}() }()
struct CCRSACipher: RSACipher {
var pubKey: String
let privateKeyDER: Data
init(keySize: Int) throws {
let (privateKey, publicKey) = try Self.loadKeys(keySize: keySize)
let privKeyStr = SwKeyConvert.PrivateKey.derToPKCS1PEM(privateKey)
self.pubKey = SwKeyConvert.PublicKey.derToPKCS8PEM(publicKey)
self.privateKeyDER = try SwKeyConvert.PrivateKey.pemToPKCS1DER(privKeyStr)
}
public func decode(data: Data) throws -> Data {
let tag = Data()
let (decryptedData, _) = try CC.RSA.decrypt(data, derKey: self.privateKeyDER, tag: tag, padding: .pkcs1, digest: .none)
return decryptedData
}
private static func loadKeys(keySize: Int) throws -> (Data, Data) {
if let privateKey = UserDefaults.standard.data(forKey: "privateKey"),
let publicKey = UserDefaults.standard.data(forKey: "publicKey") {
return (privateKey, publicKey)
} else {
let (privateKey, publicKey) = try CC.RSA.generateKeyPair(keySize)
UserDefaults.standard.setValue(privateKey, forKey: "privateKey")
UserDefaults.standard.setValue(publicKey, forKey: "publicKey")
return (privateKey, publicKey)
}
}
}
struct CCAESChiper: AESCipher {
func decypt(aesKey: Data, data: Data) throws -> Data {
let ivData = Data(aesKey.prefix(16))
return try CC.crypt(.decrypt, blockMode: .cbc, algorithm: .aes, padding: .pkcs7Padding, data: data, key: aesKey, iv: ivData)
}
func encrypt(aesKey: Data, data: Data) throws -> Data {
let ivData = Data(aesKey.prefix(16))
return try CC.crypt(.encrypt, blockMode: .cbc, algorithm: .aes, padding: .pkcs7Padding, data: data, key: aesKey, iv: ivData)
}
}
} }

View File

@ -1,833 +0,0 @@
//
// SDLContext.swift
// Tun
//
// Created by on 2024/2/29.
//
import Foundation
import NetworkExtension
import NIOCore
import Combine
//
/*
1. rsa的加解密逻辑
*/
class SDLContext {
//
struct Route {
let dstAddress: String
let subnetMask: String
var debugInfo: String {
return "\(dstAddress):\(subnetMask)"
}
}
//
final class Configuration {
struct StunServer {
let host: String
let ports: [Int]
}
//
let version: UInt8
//
let installedChannel: String
let superHost: String
let superPort: Int
let stunServers: [StunServer]
lazy var stunSocketAddress: SocketAddress = {
let stunServer = stunServers[0]
return try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[0])
}()
//
lazy var stunProbeSocketAddressArray: [[SocketAddress]] = {
return stunServers.map { stunServer in
[
try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[0]),
try! SocketAddress.makeAddressResolvingHost(stunServer.host, port: stunServer.ports[1])
]
}
}()
let clientId: String
let token: String
init(version: UInt8, installedChannel: String, superHost: String, superPort: Int, stunServers: [StunServer], clientId: String, token: String) {
self.version = version
self.installedChannel = installedChannel
self.superHost = superHost
self.superPort = superPort
self.stunServers = stunServers
self.clientId = clientId
self.token = token
}
}
let config: Configuration
// tun
var devAddr: SDLDevAddr
// nat,
//var natAddress: SDLNatAddress?
// nat
var natType: NatType = .blocked
// AES
var aesCipher: AESCipher?
// rsa, public_key
let rsaCipher: RSACipher
//
var udpHole: SDLUDPHole?
private var udpCancel: AnyCancellable?
var superClient: SDLSuperClient?
private var superCancel: AnyCancellable?
//
private var readTask: Task<(), Never>?
let provider: PacketTunnelProvider
private var sessionManager: SessionManager
private var holerManager: HolerManager
private var arpServer: ArpServer
// stunRequestcookie
private var lastCookie: UInt32? = 0
//
private var stunCancel: AnyCancellable?
//
private var monitor = SDLNetworkMonitor()
private var monitorCancel: AnyCancellable?
// socket
private var noticeClient: SDLNoticeClient
//
private var flowTracer = SDLFlowTracerActor()
private var flowTracerCancel: AnyCancellable?
init(provider: PacketTunnelProvider, config: Configuration) throws {
self.config = config
self.rsaCipher = try RSACipher(keySize: 1024)
// mac
var devAddr = SDLDevAddr()
devAddr.mac = Self.getMacAddress()
self.devAddr = devAddr
self.provider = provider
self.sessionManager = SessionManager()
self.holerManager = HolerManager()
self.arpServer = ArpServer(known_macs: [:])
self.noticeClient = SDLNoticeClient()
}
func start() async throws {
try await self.startSuperClient()
try await self.startUDPHole()
self.noticeClient.start()
//
self.monitorCancel = self.monitor.eventFlow.sink { event in
switch event {
case .changed:
// nat
Task {
self.natType = await self.getNatType()
NSLog("didNetworkPathChanged, nat type is: \(self.natType)")
}
case .unreachable:
NSLog("didNetworkPathUnreachable")
}
}
self.monitor.start()
}
private func startSuperClient() async throws {
self.superClient = SDLSuperClient(host: config.superHost, port: config.superPort)
// super
self.superCancel?.cancel()
self.superCancel = self.superClient?.eventFlow.sink { event in
Task.detached {
await self.handleSuperEvent(event: event)
}
}
try await self.superClient?.start()
}
private func handleSuperEvent(event: SDLSuperClient.SuperEvent) async {
switch event {
case .ready:
NSLog("[SDLContext] get registerSuper, mac address: \(Self.formatMacAddress(mac: self.devAddr.mac))")
guard let message = await self.superClient?.registerSuper(context: self) else {
return
}
switch message.packet {
case .registerSuperAck(let registerSuperAck):
// rsa
let aesKey = try! self.rsaCipher.decode(data: Data(registerSuperAck.aesKey))
let upgradeType = SDLUpgradeType(rawValue: registerSuperAck.upgradeType)
NSLog("[SDLContext] get registerSuperAck, aes_key len: \(aesKey.count)")
self.devAddr = registerSuperAck.devAddr
if upgradeType == .force {
let forceUpgrade = NoticeMessage.UpgradeMessage(prompt: registerSuperAck.upgradePrompt, address: registerSuperAck.upgradeAddress)
self.noticeClient.send(data: forceUpgrade.binaryData)
exit(-1)
}
// tun
await self.didNetworkConfigChanged(devAddr: self.devAddr)
self.aesCipher = AESCipher(aesKey: aesKey)
if upgradeType == .normal {
let normalUpgrade = NoticeMessage.UpgradeMessage(prompt: registerSuperAck.upgradePrompt, address: registerSuperAck.upgradeAddress)
self.noticeClient.send(data: normalUpgrade.binaryData)
}
case .registerSuperNak(let nakPacket):
let errorMessage = nakPacket.errorMessage
guard let errorCode = SDLNAKErrorCode(rawValue: UInt8(nakPacket.errorCode)) else {
return
}
switch errorCode {
case .invalidToken, .nodeDisabled:
let alertNotice = NoticeMessage.AlertMessage(alert: errorMessage)
self.noticeClient.send(data: alertNotice.binaryData)
exit(-1)
case .noIpAddress, .networkFault, .internalFault:
let alertNotice = NoticeMessage.AlertMessage(alert: errorMessage)
self.noticeClient.send(data: alertNotice.binaryData)
}
SDLLogger.log("Get a SuperNak message exit", level: .error)
default:
()
}
case .closed:
SDLLogger.log("[SDLContext] super client closed", level: .debug)
await self.arpServer.clear()
DispatchQueue.global().asyncAfter(deadline: .now() + 5) {
Task {
try await self.startSuperClient()
}
}
case .event(let evt):
switch evt {
case .natChanged(let natChangedEvent):
let dstMac = natChangedEvent.mac
NSLog("natChangedEvent, dstMac: \(dstMac)")
await sessionManager.removeSession(dstMac: dstMac)
case .sendRegister(let sendRegisterEvent):
NSLog("sendRegisterEvent, ip: \(sendRegisterEvent)")
let address = SDLUtil.int32ToIp(sendRegisterEvent.natIp)
if let remoteAddress = try? SocketAddress.makeAddressResolvingHost(address, port: Int(sendRegisterEvent.natPort)) {
// register
self.udpHole?.sendRegister(context: self, remoteAddress: remoteAddress, dst_mac: sendRegisterEvent.dstMac)
}
case .networkShutdown(let shutdownEvent):
let alertNotice = NoticeMessage.AlertMessage(alert: shutdownEvent.message)
self.noticeClient.send(data: alertNotice.binaryData)
exit(-1)
}
case .command(let packetId, let command):
switch command {
case .changeNetwork(let changeNetworkCommand):
// rsa
let aesKey = try! self.rsaCipher.decode(data: Data(changeNetworkCommand.aesKey))
NSLog("[SDLContext] change network command get aes_key len: \(aesKey.count)")
self.devAddr = changeNetworkCommand.devAddr
// tun
await self.didNetworkConfigChanged(devAddr: self.devAddr)
self.aesCipher = AESCipher(aesKey: aesKey)
var commandAck = SDLCommandAck()
commandAck.status = true
self.superClient?.commandAck(packetId: packetId, ack: commandAck)
}
}
}
private func startUDPHole() async throws {
self.udpHole = SDLUDPHole()
self.udpCancel?.cancel()
self.udpCancel = self.udpHole?.eventFlow.sink { event in
Task.detached {
await self.handleUDPEvent(event: event)
}
}
try await self.udpHole?.start()
}
private func handleUDPEvent(event: SDLUDPHole.UDPEvent) async {
switch event {
case .ready:
//
self.natType = await self.getNatType()
SDLLogger.log("[SDLContext] nat type is: \(self.natType)", level: .debug)
let timer = Timer.publish(every: 5.0, on: .main, in: .common).autoconnect()
self.stunCancel = Just(Date()).merge(with: timer).sink { _ in
self.lastCookie = self.udpHole?.stunRequest(context: self)
}
case .closed:
DispatchQueue.global().asyncAfter(deadline: .now() + 5) {
Task {
try await self.startUDPHole()
}
}
case .message(let remoteAddress, let message):
switch message {
case .register(let register):
NSLog("register packet: \(register), dev_addr: \(self.devAddr)")
// tun,
if register.dstMac == self.devAddr.mac && register.networkID == self.devAddr.networkID {
// ack
self.udpHole?.sendRegisterAck(context: self, remoteAddress: remoteAddress, dst_mac: register.srcMac)
// , super-nodenatudpnat
let session = Session(dstMac: register.srcMac, natAddress: remoteAddress)
await self.sessionManager.addSession(session: session)
} else {
SDLLogger.log("SDLContext didReadRegister get a invalid packet, because dst_ip not matched: \(register.dstMac)", level: .warning)
}
case .registerAck(let registerAck):
// tun,
if registerAck.dstMac == self.devAddr.mac && registerAck.networkID == self.devAddr.networkID {
let session = Session(dstMac: registerAck.srcMac, natAddress: remoteAddress)
await self.sessionManager.addSession(session: session)
} else {
SDLLogger.log("SDLContext didReadRegisterAck get a invalid packet, because dst_mac not matched: \(registerAck.dstMac)", level: .warning)
}
case .stunReply(let stunReply):
let cookie = stunReply.cookie
if cookie == self.lastCookie {
// nat
//self.natAddress = stunReply.natAddress
SDLLogger.log("[SDLContext] get a stunReply: \(try! stunReply.jsonString())")
}
default:
()
}
case .data(let data):
let mac = LayerPacket.MacAddress(data: data.dstMac)
guard (data.dstMac == self.devAddr.mac || mac.isBroadcast() || mac.isMulticast()) else {
NSLog("[SDLContext] didReadData 1")
return
}
guard let decyptedData = try? self.aesCipher?.decypt(data: Data(data.data)) else {
NSLog("[SDLContext] didReadData 2")
return
}
do {
let layerPacket = try LayerPacket(layerData: decyptedData)
await self.flowTracer.inc(num: decyptedData.count, type: .inbound)
// arp
switch layerPacket.type {
case .arp:
// arp
if let arpPacket = ARPPacket(data: layerPacket.data) {
if arpPacket.targetIP == self.devAddr.netAddr {
switch arpPacket.opcode {
case .request:
NSLog("[SDLContext] get arp request packet")
let response = ARPPacket.arpResponse(for: arpPacket, mac: self.devAddr.mac, ip: self.devAddr.netAddr)
await self.routeLayerPacket(dstMac: arpPacket.senderMAC, type: .arp, data: response.marshal())
case .response:
NSLog("[SDLContext] get arp response packet")
await self.arpServer.append(ip: arpPacket.senderIP, mac: arpPacket.senderMAC)
}
} else {
NSLog("[SDLContext] get invalid arp packet, target_ip: \(arpPacket)")
}
} else {
NSLog("[SDLContext] get invalid arp packet")
}
case .ipv4:
NSLog("[SDLContext] get ipv4 packet")
guard let ipPacket = IPPacket(layerPacket.data), ipPacket.header.destination == self.devAddr.netAddr else {
return
}
let packet = NEPacket(data: ipPacket.data, protocolFamily: 2)
self.provider.packetFlow.writePacketObjects([packet])
default:
NSLog("[SDLContext] get invalid packet")
}
} catch let err {
NSLog("[SDLContext] didReadData err: \(err)")
}
}
}
//
func flowReportTask() {
Task {
//
self.flowTracerCancel = Timer.publish(every: 60.0, on: .main, in: .common).autoconnect()
.sink { _ in
Task {
let (forwardNum, p2pNum, inboundNum) = await self.flowTracer.reset()
self.superClient?.flowReport(forwardNum: forwardNum, p2pNum: p2pNum, inboundNum: inboundNum)
}
}
}
}
//
private func didNetworkConfigChanged(devAddr: SDLDevAddr, dnsServers: [String]? = nil) async {
let netAddress = SDLNetAddress(ip: devAddr.netAddr, maskLen: UInt8(devAddr.netBitLen))
let routes = [Route(dstAddress: netAddress.networkAddress, subnetMask: netAddress.maskAddress)]
// Add code here to start the process of connecting the tunnel.
let networkSettings = NEPacketTunnelNetworkSettings(tunnelRemoteAddress: "8.8.8.8")
networkSettings.mtu = 1460
// DNS
if let dnsServers {
networkSettings.dnsSettings = NEDNSSettings(servers: dnsServers)
} else {
networkSettings.dnsSettings = NEDNSSettings(servers: ["8.8.8.8", "114.114.114.114"])
}
let ipv4Settings = NEIPv4Settings(addresses: [netAddress.ipAddress], subnetMasks: [netAddress.maskAddress])
//
//NEIPv4Route.default()
ipv4Settings.includedRoutes = routes.map { route in
NEIPv4Route(destinationAddress: route.dstAddress, subnetMask: route.subnetMask)
}
networkSettings.ipv4Settings = ipv4Settings
//
do {
try await self.provider.setTunnelNetworkSettings(networkSettings)
await self.holerManager.cleanup()
self.startReader()
} catch let err {
SDLLogger.log("[SDLContext] setTunnelNetworkSettings get error: \(err)", level: .error)
exit(-1)
}
}
// , 线packetFlow
private func startReader() {
//
self.readTask?.cancel()
//
self.readTask = Task(priority: .high) {
repeat {
if Task.isCancelled {
break
}
let (packets, numbers) = await self.provider.packetFlow.readPackets()
for (data, number) in zip(packets, numbers) where number == 2 {
if let packet = IPPacket(data) {
Task.detached {
let dstIp = packet.header.destination
// , ip
if dstIp == self.devAddr.netAddr {
let nePacket = NEPacket(data: packet.data, protocolFamily: 2)
self.provider.packetFlow.writePacketObjects([nePacket])
return
}
// arpmac
if let dstMac = await self.arpServer.query(ip: dstIp) {
await self.routeLayerPacket(dstMac: dstMac, type: .ipv4, data: packet.data)
}
else {
// arp
let broadcastMac = Data([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF])
let arpReqeust: ARPPacket = ARPPacket.arpRequest(senderIP: self.devAddr.netAddr, senderMAC: self.devAddr.mac, targetIP: dstIp)
await self.routeLayerPacket(dstMac: broadcastMac, type: .arp, data: arpReqeust.marshal())
NSLog("[SDLContext] dstIp: \(dstIp) arp query not found")
}
}
}
}
} while true
}
}
private func routeLayerPacket(dstMac: Data, type: LayerPacket.PacketType, data: Data) async {
// 2
let layerPacket = LayerPacket(dstMac: dstMac, srcMac: self.devAddr.mac, type: type, data: data)
guard let encodedPacket = try? self.aesCipher?.encrypt(data: layerPacket.marshal()) else {
return
}
// session
if let session = await self.sessionManager.getSession(toAddress: dstMac) {
NSLog("[SDLContext] send packet by session: \(session)")
self.udpHole?.sendPacket(context: self, session: session, data: encodedPacket)
await self.flowTracer.inc(num: data.count, type: .p2p)
} else {
// super_node
self.udpHole?.forwardPacket(context: self, dst_mac: dstMac, data: encodedPacket)
//
await self.flowTracer.inc(num: data.count, type: .forward)
//
await self.holerManager.addHoler(dstMac: dstMac) {
self.holerTask(dstMac: dstMac)
}
}
}
deinit {
self.stunCancel?.cancel()
self.udpHole = nil
self.superClient = nil
}
}
//--MARK: RSA
extension SDLContext {
struct RSACipher {
let pubKey: String
let privateKeyDER: Data
init(keySize: Int) throws {
let (privateKey, publicKey) = try Self.loadKeys(keySize: keySize)
let privKeyStr = SwKeyConvert.PrivateKey.derToPKCS1PEM(privateKey)
self.pubKey = SwKeyConvert.PublicKey.derToPKCS8PEM(publicKey)
self.privateKeyDER = try SwKeyConvert.PrivateKey.pemToPKCS1DER(privKeyStr)
}
public func decode(data: Data) throws -> Data {
let tag = Data()
let (decryptedData, _) = try CC.RSA.decrypt(data, derKey: self.privateKeyDER, tag: tag, padding: .pkcs1, digest: .none)
return decryptedData
}
private static func loadKeys(keySize: Int) throws -> (Data, Data) {
if let privateKey = UserDefaults.standard.data(forKey: "privateKey"),
let publicKey = UserDefaults.standard.data(forKey: "publicKey") {
return (privateKey, publicKey)
} else {
let (privateKey, publicKey) = try CC.RSA.generateKeyPair(keySize)
UserDefaults.standard.setValue(privateKey, forKey: "privateKey")
UserDefaults.standard.setValue(publicKey, forKey: "publicKey")
return (privateKey, publicKey)
}
}
}
}
// --MARK: AES, AES256
extension SDLContext {
struct AESCipher {
let aesKey: Data
let ivData: Data
init(aesKey: Data) {
self.aesKey = aesKey
self.ivData = Data(aesKey.prefix(16))
}
func decypt(data: Data) throws -> Data {
return try CC.crypt(.decrypt, blockMode: .cbc, algorithm: .aes, padding: .pkcs7Padding, data: data, key: aesKey, iv: ivData)
}
func encrypt(data: Data) throws -> Data {
return try CC.crypt(.encrypt, blockMode: .cbc, algorithm: .aes, padding: .pkcs7Padding, data: data, key: aesKey, iv: ivData)
}
}
}
// --MARK: session, session10s使使
extension SDLContext {
struct Session {
// ip,
let dstMac: Data
// nat
let natAddress: SocketAddress
// 使
var lastTimestamp: Int32
init(dstMac: Data, natAddress: SocketAddress) {
self.dstMac = dstMac
self.natAddress = natAddress
self.lastTimestamp = Int32(Date().timeIntervalSince1970)
}
mutating func updateLastTimestamp(_ lastTimestamp: Int32) {
self.lastTimestamp = lastTimestamp
}
}
actor SessionManager {
private var sessions: [Data:Session] = [:]
// session
private let ttl: Int32 = 10
func getSession(toAddress: Data) -> Session? {
let timestamp = Int32(Date().timeIntervalSince1970)
if let session = self.sessions[toAddress] {
if session.lastTimestamp >= timestamp + ttl {
self.sessions[toAddress]?.updateLastTimestamp(timestamp)
return session
} else {
self.sessions.removeValue(forKey: toAddress)
}
}
return nil
}
func addSession(session: Session) {
self.sessions[session.dstMac] = session
}
func removeSession(dstMac: Data) {
self.sessions.removeValue(forKey: dstMac)
}
}
}
// --MARK: known_ips
extension SDLContext {
actor ArpServer {
private var known_macs: [UInt32:Data] = [:]
init(known_macs: [UInt32:Data]) {
self.known_macs = known_macs
}
func query(ip: UInt32) -> Data? {
return self.known_macs[ip]
}
func append(ip: UInt32, mac: Data) {
self.known_macs[ip] = mac
}
func remove(ip: UInt32) {
self.known_macs.removeValue(forKey: ip)
}
func clear() {
self.known_macs = [:]
}
}
}
// --MARK:
extension SDLContext {
actor HolerManager {
private var holers: [Data:Task<(), Never>] = [:]
func addHoler(dstMac: Data, creator: @escaping () -> Task<(), Never>) {
if let task = self.holers[dstMac] {
if task.isCancelled {
self.holers[dstMac] = creator()
}
} else {
self.holers[dstMac] = creator()
}
}
func cleanup() {
for holer in holers.values {
holer.cancel()
}
self.holers.removeAll()
}
}
func holerTask(dstMac: Data) -> Task<(), Never> {
return Task {
guard let message = try? await self.superClient?.queryInfo(context: self, dst_mac: dstMac) else {
return
}
switch message.packet {
case .empty:
SDLLogger.log("[SDLContext] hole query_info get empty: \(message)", level: .debug)
case .peerInfo(let peerInfo):
if let remoteAddress = peerInfo.v4Info.socketAddress() {
SDLLogger.log("[SDLContext] hole sock address: \(remoteAddress)", level: .warning)
// register
self.udpHole?.sendRegister(context: self, remoteAddress: remoteAddress, dst_mac: dstMac)
} else {
SDLLogger.log("[SDLContext] hole sock address is invalid: \(peerInfo.v4Info)", level: .warning)
}
default:
SDLLogger.log("[SDLContext] hole query_info is packet: \(message)", level: .warning)
}
}
}
}
//--MARK:
extension SDLContext {
// nat
enum NatType: UInt8, Encodable {
case blocked = 0
case noNat = 1
case fullCone = 2
case portRestricted = 3
case coneRestricted = 4
case symmetric = 5
}
private func getNatAddress(remoteAddress: SocketAddress, attr: SDLProbeAttr) async -> SocketAddress? {
let stunProbeReply = await self.udpHole?.stunProbe(remoteAddress: remoteAddress, attr: attr, timeout: 5)
return stunProbeReply?.socketAddress()
}
// nat
func getNatType() async -> NatType {
let addressArray = config.stunProbeSocketAddressArray
// step1: ip1:port1 <---- ip1:port1
guard let natAddress1 = await getNatAddress(remoteAddress: addressArray[0][0], attr: .none) else {
return .blocked
}
// nat
if natAddress1 == self.udpHole?.localAddress {
return .noNat
}
// step2: ip2:port2 <---- ip2:port2
guard let natAddress2 = await getNatAddress(remoteAddress: addressArray[1][1], attr: .none) else {
return .blocked
}
// natAddress2 IPIPNAT;
// ip{dstIp, dstPort, srcIp, srcPort}, ip
NSLog("nat_address1: \(natAddress1), nat_address2: \(natAddress2)")
if let ipAddress1 = natAddress1.ipAddress, let ipAddress2 = natAddress2.ipAddress, ipAddress1 != ipAddress2 {
return .symmetric
}
// step3: ip1:port1 <---- ip2:port2 (ipport)
// IPNAT
if let natAddress3 = await getNatAddress(remoteAddress: addressArray[0][0], attr: .peer) {
NSLog("nat_address1: \(natAddress1), nat_address2: \(natAddress2), nat_address3: \(natAddress3)")
return .fullCone
}
// step3: ip1:port1 <---- ip1:port2 (port)
// IPNAT
if let natAddress4 = await getNatAddress(remoteAddress: addressArray[0][0], attr: .port) {
NSLog("nat_address1: \(natAddress1), nat_address2: \(natAddress2), nat_address4: \(natAddress4)")
return .coneRestricted
} else {
return .portRestricted
}
}
}
//--MARK: UUID
extension SDLContext {
static func getUUID() -> String {
let userDefaults = UserDefaults.standard
if let uuid = userDefaults.value(forKey: "gClientId") as? String {
return uuid
} else {
let uuid = UUID().uuidString.replacingOccurrences(of: "-", with: "").lowercased()
userDefaults.setValue(uuid, forKey: "gClientId")
return uuid
}
}
// mac
static func getMacAddress() -> Data {
let key = "gMacAddress2"
let userDefaults = UserDefaults.standard
if let mac = userDefaults.value(forKey: key) as? Data {
return mac
}
else {
let mac = generateMacAddress()
userDefaults.setValue(mac, forKey: key)
return mac
}
}
// mac
private static func generateMacAddress() -> Data {
var macAddress = [UInt8](repeating: 0, count: 6)
for i in 0..<6 {
macAddress[i] = UInt8.random(in: 0...255)
}
return Data(macAddress)
}
// mac
private static func formatMacAddress(mac: Data) -> String {
let bytes = [UInt8](mac)
return bytes.map { String(format: "%02X", $0) }.joined(separator: ":").lowercased()
}
}

View File

@ -1,43 +0,0 @@
//
// SDLFlowTracer.swift
// Tun
//
// Created by on 2024/5/27.
//
import Foundation
//
actor SDLFlowTracerActor {
enum FlowType {
case forward
case p2p
case inbound
}
private var forwardFlowBytes: UInt32 = 0
private var p2pFlowBytes: UInt32 = 0
private var inFlowBytes: UInt32 = 0
func inc(num: Int, type: FlowType) {
switch type {
case .inbound:
self.inFlowBytes += UInt32(num)
case .forward:
self.forwardFlowBytes += UInt32(num)
case .p2p:
self.p2pFlowBytes += UInt32(num)
}
}
func reset() -> (UInt32, UInt32, UInt32) {
defer {
self.forwardFlowBytes = 0
self.inFlowBytes = 0
self.p2pFlowBytes = 0
}
return (forwardFlowBytes, p2pFlowBytes, inFlowBytes)
}
}

View File

@ -1,11 +0,0 @@
//
// SDLHoler.swift
// Tun
//
// Created by on 2024/3/12.
//
import Foundation
import Combine

View File

@ -1,39 +0,0 @@
//
// SDLLogger.swift
// Tun
//
// Created by on 2024/3/13.
//
import Foundation
struct SDLLogger {
enum Level {
case debug
case info
case warning
case error
}
static var logLevel: Level = .debug
static func log(_ message: String, level: Level = .debug) {
switch logLevel {
case .debug:
NSLog(message)
case .info:
if level == .info || level == .warning || level == .error {
NSLog(message)
}
case .warning:
if level == .warning || level == .error {
NSLog(message)
}
case .error:
if level == .error {
NSLog(message)
}
}
}
}

File diff suppressed because it is too large Load Diff

View File

@ -1,156 +0,0 @@
//
// SDLPacketType.swift
// Tun
//
// Created by on 2024/4/10.
//
import Foundation
import NIOCore
//
enum SDLPacketType: UInt8 {
case empty = 0x00
case registerSuper = 0x01
case registerSuperAck = 0x02
case registerSuperNak = 0x04
case unregisterSuper = 0x05
case queryInfo = 0x06
case peerInfo = 0x07
case ping = 0x08
case pong = 0x09
//
case event = 0x10
// ,
case command = 0x11
case commandAck = 0x12
//
case flowTracer = 0x15
case register = 0x20
case registerAck = 0x21
case stunRequest = 0x30
case stunReply = 0x31
case stunProbe = 0x32
case stunProbeReply = 0x33
case data = 0xFF
}
//
enum SDLUpgradeType: UInt32 {
case none = 0
case normal = 1
case force = 2
}
// Id
struct SDLIdGenerator {
// id
private var packetId: UInt32
init(seed packetId: UInt32) {
self.packetId = packetId
}
mutating func nextId() -> UInt32 {
let packetId = self.packetId
self.packetId = packetId + 1
return packetId
}
}
//
//
enum SDLEventType: UInt8 {
case natChanged = 0x03
case sendRegister = 0x04
case networkShutdown = 0xFF
}
enum SDLEvent {
case natChanged(SDLNatChangedEvent)
case sendRegister(SDLSendRegisterEvent)
case networkShutdown(SDLNetworkShutdownEvent)
}
// --MARK:
enum SDLCommandType: UInt8 {
case changeNetwork = 0x01
}
enum SDLCommand {
case changeNetwork(SDLChangeNetworkCommand)
}
// --MARK:
// Attr
enum SDLProbeAttr: UInt8 {
case none = 0
case port = 1
case peer = 2
}
// Nak
enum SDLNAKErrorCode: UInt8 {
case invalidToken = 1
case nodeDisabled = 2
case noIpAddress = 3
case networkFault = 4
case internalFault = 5
}
extension SDLV4Info {
func socketAddress() -> SocketAddress? {
let address = "\(v4[0]).\(v4[1]).\(v4[2]).\(v4[3])"
return try? SocketAddress.makeAddressResolvingHost(address, port: Int(port))
}
}
extension SDLStunProbeReply {
func socketAddress() -> SocketAddress? {
let address = SDLUtil.int32ToIp(self.ip)
return try? SocketAddress.makeAddressResolvingHost(address, port: Int(port))
}
}
// --MARK: ,
enum SDLHoleInboundMessage {
case stunReply(SDLStunReply)
case stunProbeReply(SDLStunProbeReply)
case data(SDLData)
case register(SDLRegister)
case registerAck(SDLRegisterAck)
}
// --MARK:
struct SDLSuperInboundMessage {
let msgId: UInt32
let packet: InboundPacket
enum InboundPacket {
case empty
case registerSuperAck(SDLRegisterSuperAck)
case registerSuperNak(SDLRegisterSuperNak)
case peerInfo(SDLPeerInfo)
case pong
case event(SDLEvent)
case command(SDLCommand)
}
}

View File

@ -1,49 +0,0 @@
//
// SDLIPAddress.swift
// Tun
//
// Created by on 2024/3/4.
//
import Foundation
struct SDLNetAddress {
let ip: UInt32
let maskLen: UInt8
// ip
var ipAddress: String {
return intToIpAddress(self.ip)
}
//
var maskAddress: String {
let len0 = 32 - maskLen
let num: UInt32 = (0xFFFFFFFF >> len0) << len0
return intToIpAddress(num)
}
//
var networkAddress: String {
let len0 = 32 - maskLen
let mask: UInt32 = (0xFFFFFFFF >> len0) << len0
return intToIpAddress(self.ip & mask)
}
init(ip: UInt32, maskLen: UInt8) {
self.ip = ip
self.maskLen = maskLen
}
private func intToIpAddress(_ num: UInt32) -> String {
let ip0 = (UInt8) (num >> 24 & 0xFF)
let ip1 = (UInt8) (num >> 16 & 0xFF)
let ip2 = (UInt8) (num >> 8 & 0xFF)
let ip3 = (UInt8) (num & 0xFF)
return "\(ip0).\(ip1).\(ip2).\(ip3)"
}
}

View File

@ -1,62 +0,0 @@
//
// SDLNetworkMonitor.swift
// Tun
//
// Created by on 2024/5/16.
//
import Foundation
import Network
import Combine
//
class SDLNetworkMonitor {
private var monitor: NWPathMonitor
private var interfaceType: NWInterface.InterfaceType?
private let publisher = PassthroughSubject<NWInterface.InterfaceType, Never>()
private var cancel: AnyCancellable?
private let queue = DispatchQueue(label: "networkMonitorQueue")
public let eventFlow = PassthroughSubject<MonitorEvent, Never>()
enum MonitorEvent {
case changed
case unreachable
}
init() {
self.monitor = NWPathMonitor()
}
func start() {
self.monitor.pathUpdateHandler = { path in
if path.status == .satisfied {
if path.usesInterfaceType(.wifi) {
self.publisher.send(.wifi)
} else if path.usesInterfaceType(.cellular) {
self.publisher.send(.cellular)
} else if path.usesInterfaceType(.wiredEthernet) {
self.publisher.send(.wiredEthernet)
}
} else {
self.eventFlow.send(.unreachable)
self.interfaceType = nil
}
}
self.monitor.start(queue: self.queue)
self.cancel = publisher.throttle(for: 5.0, scheduler: self.queue, latest: true)
.sink { type in
if self.interfaceType != nil && self.interfaceType != type {
self.eventFlow.send(.changed)
}
self.interfaceType = type
}
}
deinit {
self.monitor.cancel()
self.cancel?.cancel()
}
}

View File

@ -1,95 +0,0 @@
//
// SDLNoticeClient.swift
// Tun
//
// Created by on 2024/5/20.
//
import Foundation
//
// SDLanServer.swift
// Tun
//
// Created by on 2024/1/31.
//
import Foundation
import NIOCore
import NIOPosix
// sn-server
class SDLNoticeClient: ChannelInboundHandler {
public typealias InboundIn = AddressedEnvelope<ByteBuffer>
public typealias OutboundOut = AddressedEnvelope<ByteBuffer>
private var thread: Thread?
var context: ChannelHandlerContext?
private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
private let remoteAddress: SocketAddress
init() {
self.remoteAddress = try! SocketAddress(ipAddress: "127.0.0.1", port: 50195)
}
//
func start() {
self.thread = Thread {
let bootstrap = DatagramBootstrap(group: self.group)
.channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
.channelInitializer { channel in
//
channel.pipeline.addHandler(self)
}
let channel = try! bootstrap.bind(host: "0.0.0.0", port: 0).wait()
SDLLogger.log("[SDLNoticeClient] started and listening on: \(channel.localAddress!)", level: .debug)
// This will never unblock as we don't close the channel
try! channel.closeFuture.wait()
}
self.thread?.start()
}
// -- MARK: ChannelInboundHandler Methods
public func channelActive(context: ChannelHandlerContext) {
self.context = context
}
// ,
public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
context.fireChannelRead(data)
}
public func errorCaught(context: ChannelHandlerContext, error: Error) {
// As we are not really interested getting notified on success or failure we just pass nil as promise to
// reduce allocations.
context.close(promise: nil)
self.context = nil
}
public func channelInactive(context: ChannelHandlerContext) {
self.context = nil
context.close(promise: nil)
}
//
func send(data: Data) {
guard let context = self.context else {
return
}
context.eventLoop.execute {
let buffer = context.channel.allocator.buffer(bytes: data)
let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: self.remoteAddress, data: buffer)
context.writeAndFlush(self.wrapOutboundOut(envelope), promise: nil)
}
}
deinit {
self.thread?.cancel()
try? self.group.syncShutdownGracefully()
}
}

View File

@ -1,16 +0,0 @@
//
// SDLProtoMessageExtension.swift
// Tun
//
// Created by on 2024/10/24.
//
import Foundation
extension SDLData {
func format() -> String {
return "network_id: \(self.networkID), src_mac: \(LayerPacket.MacAddress.description(data: self.srcMac)), dst_mac: \(LayerPacket.MacAddress.description(data: self.dstMac)), data: \([UInt8](self.data))"
}
}

View File

@ -1,37 +0,0 @@
//
// SDLQPSCounter.swift
// Tun
//
// Created by on 2024/4/16.
//
import Foundation
// qps
class SDLQPSCounter {
private var count = 0
private let timer: DispatchSourceTimer
private let label: String
init(label: String) {
self.label = label
timer = DispatchSource.makeTimerSource(queue: DispatchQueue(label: "com.yourapp.qps"))
timer.schedule(deadline: .now(), repeating: .seconds(1), leeway: .milliseconds(100))
timer.setEventHandler { [weak self] in
guard let self = self else { return }
NSLog("[\(self.label)] QPS: \(self.count)")
self.count = 0
}
timer.resume()
}
func increment(num: Int = 1) {
DispatchQueue(label: "com.yourapp.qps").async {
self.count += num
}
}
deinit {
timer.cancel()
}
}

View File

@ -1,373 +0,0 @@
//
// SDLWebsocketClient.swift
// Tun
//
// Created by on 2024/3/28.
//
import Foundation
import NIOCore
import NIOPosix
import Combine
// --MARK: SuperNode
class SDLSuperClient: ChannelInboundHandler {
public typealias InboundIn = ByteBuffer
public typealias OutboundOut = ByteBuffer
public typealias CallbackFun = (SDLSuperInboundMessage?) -> Void
private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
private var channel: Channel?
// id
var idGenerator = SDLIdGenerator(seed: 1)
private let callbackManager = SuperCallbackManager()
let host: String
let port: Int
private var pingCancel: AnyCancellable?
public var eventFlow = PassthroughSubject<SuperEvent, Never>()
//
enum SuperEvent {
case ready
case closed
case event(SDLEvent)
case command(UInt32, SDLCommand)
}
init(host: String, port: Int) {
self.host = host
self.port = port
}
func start() async throws {
let bootstrap = ClientBootstrap(group: self.group)
.channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
.channelInitializer { channel in
return channel.pipeline.addHandlers([
ByteToMessageHandler(FixedHeaderDelimiterCoder()),
MessageToByteHandler(FixedHeaderDelimiterCoder()),
self
])
}
do {
NSLog("super client connect: \(self.host):\(self.port)")
self.channel = try await bootstrap.connect(host: self.host, port: self.port).get()
} catch let err {
NSLog("super client get error: \(err)")
self.eventFlow.send(.closed)
}
}
// -- MARK: apis
func commandAck(packetId: UInt32, ack: SDLCommandAck) {
guard let data = try? ack.serializedData() else {
return
}
self.send(type: .commandAck, packetId: packetId, data: data)
}
func registerSuper(context ctx: SDLContext) async -> SDLSuperInboundMessage? {
return await withCheckedContinuation { c in
self.registerSuper(context: ctx) { message in
c.resume(returning: message)
}
}
}
func registerSuper(context ctx: SDLContext, callback: @escaping CallbackFun) {
var registerSuper = SDLRegisterSuper()
registerSuper.version = UInt32(ctx.config.version)
registerSuper.clientID = ctx.config.clientId
registerSuper.devAddr = ctx.devAddr
registerSuper.pubKey = ctx.rsaCipher.pubKey
registerSuper.token = ctx.config.token
let data = try! registerSuper.serializedData()
self.write(type: .registerSuper, data: data, callback: callback)
}
func queryInfo(context ctx: SDLContext, dst_mac: Data) async throws -> SDLSuperInboundMessage? {
return await withCheckedContinuation { c in
self.queryInfo(context: ctx, dst_mac: dst_mac) { message in
c.resume(returning: message)
}
}
}
//
func queryInfo(context ctx: SDLContext, dst_mac: Data, callback: @escaping CallbackFun) {
var queryInfo = SDLQueryInfo()
queryInfo.dstMac = dst_mac
self.write(type: .queryInfo, data: try! queryInfo.serializedData(), callback: callback)
}
func unregister(context ctx: SDLContext) throws {
self.send(type: .unregisterSuper, packetId: 0, data: Data())
}
func ping() {
self.send(type: .ping, packetId: 0, data: Data())
}
func flowReport(forwardNum: UInt32, p2pNum: UInt32, inboundNum: UInt32) {
var flow = SDLFlows()
flow.forwardNum = forwardNum
flow.p2PNum = p2pNum
flow.inboundNum = inboundNum
self.send(type: .flowTracer, packetId: 0, data: try! flow.serializedData())
}
// --MARK: ChannelInboundHandler
public func channelActive(context: ChannelHandlerContext) {
self.startPingTicker()
self.eventFlow.send(.ready)
}
public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
var buffer = self.unwrapInboundIn(data)
if let message = decode(buffer: &buffer) {
SDLLogger.log("[SDLSuperTransport] read message: \(message)", level: .warning)
switch message.packet {
case .event(let event):
self.eventFlow.send(.event(event))
case .command(let command):
self.eventFlow.send(.command(message.msgId, command))
default:
self.callbackManager.fireCallback(message: message)
}
}
}
public func errorCaught(context: ChannelHandlerContext, error: Error) {
SDLLogger.log("[SDLSuperTransport] error: \(error)", level: .warning)
self.channel = nil
self.eventFlow.send(.closed)
context.close(promise: nil)
}
public func channelInactive(context: ChannelHandlerContext) {
SDLLogger.log("[SDLSuperTransport] channelInactive", level: .warning)
self.channel = nil
context.close(promise: nil)
}
func write(type: SDLPacketType, data: Data, callback: @escaping CallbackFun) {
guard let channel = self.channel else {
return
}
SDLLogger.log("[SDLSuperTransport] will write data: \(data)", level: .debug)
let packetId = idGenerator.nextId()
self.callbackManager.addCallback(id: packetId, callback: callback)
channel.eventLoop.execute {
var buffer = channel.allocator.buffer(capacity: data.count + 5)
buffer.writeInteger(packetId, as: UInt32.self)
buffer.writeBytes([type.rawValue])
buffer.writeBytes(data)
channel.writeAndFlush(self.wrapOutboundOut(buffer), promise: nil)
}
}
func send(type: SDLPacketType, packetId: UInt32, data: Data) {
guard let channel = self.channel else {
return
}
channel.eventLoop.execute {
var buffer = channel.allocator.buffer(capacity: data.count + 5)
buffer.writeInteger(packetId, as: UInt32.self)
buffer.writeBytes([type.rawValue])
buffer.writeBytes(data)
channel.writeAndFlush(self.wrapOutboundOut(buffer), promise: nil)
}
}
// --MARK:
private func startPingTicker() {
self.pingCancel = Timer.publish(every: 5.0, on: .main, in: .common).autoconnect()
.sink { _ in
// super-node
self.ping()
}
}
deinit {
self.pingCancel?.cancel()
try! group.syncShutdownGracefully()
}
}
/// 2
extension SDLSuperClient {
private final class FixedHeaderDelimiterCoder: ByteToMessageDecoder, MessageToByteEncoder {
typealias InboundIn = ByteBuffer
typealias InboundOut = ByteBuffer
func decode(context: ChannelHandlerContext, buffer: inout ByteBuffer) throws -> DecodingState {
guard let len = buffer.getInteger(at: buffer.readerIndex, endianness: .big, as: UInt16.self) else {
return .needMoreData
}
if buffer.readableBytes >= len + 2 {
buffer.moveReaderIndex(forwardBy: 2)
if let bytes = buffer.readBytes(length: Int(len)) {
context.fireChannelRead(self.wrapInboundOut(ByteBuffer(bytes: bytes)))
}
return .continue
} else {
return .needMoreData
}
}
func encode(data: ByteBuffer, out: inout ByteBuffer) throws {
let len = data.readableBytes
out.writeInteger(UInt16(len))
out.writeBytes(data.readableBytesView)
}
}
}
//
extension SDLSuperClient {
private final class SuperCallbackManager {
//
private var callbacks: [UInt32:CallbackFun] = [:]
private let locker = NSLock()
func addCallback(id: UInt32, callback: @escaping CallbackFun) {
locker.lock()
defer {
locker.unlock()
}
self.callbacks[id] = callback
}
func fireCallback(message: SDLSuperInboundMessage) {
locker.lock()
defer {
locker.unlock()
}
if let callback = self.callbacks[message.msgId] {
callback(message)
self.callbacks.removeValue(forKey: message.msgId)
}
}
func fireAllCallbacks(message: SDLSuperInboundMessage) {
locker.lock()
defer {
locker.unlock()
}
for (_, callback) in self.callbacks {
callback(nil)
}
self.callbacks.removeAll()
}
}
}
// --MARK:
extension SDLSuperClient {
// : <<MsgId:32, Type:8, Body/binary>>
func decode(buffer: inout ByteBuffer) -> SDLSuperInboundMessage? {
guard let msgId = buffer.readInteger(as: UInt32.self),
let type = buffer.readInteger(as: UInt8.self),
let messageType = SDLPacketType(rawValue: type) else {
return nil
}
switch messageType {
case .empty:
return .init(msgId: msgId, packet: .empty)
case .registerSuperAck:
guard let bytes = buffer.readBytes(length: buffer.readableBytes),
let registerSuperAck = try? SDLRegisterSuperAck(serializedData: Data(bytes)) else {
return nil
}
return .init(msgId: msgId, packet: .registerSuperAck(registerSuperAck))
case .registerSuperNak:
guard let bytes = buffer.readBytes(length: buffer.readableBytes),
let registerSuperNak = try? SDLRegisterSuperNak(serializedData: Data(bytes)) else {
return nil
}
return .init(msgId: msgId, packet: .registerSuperNak(registerSuperNak))
case .peerInfo:
guard let bytes = buffer.readBytes(length: buffer.readableBytes),
let peerInfo = try? SDLPeerInfo(serializedData: Data(bytes)) else {
return nil
}
return .init(msgId: msgId, packet: .peerInfo(peerInfo))
case .pong:
return .init(msgId: msgId, packet: .pong)
case .command:
guard let commandVal = buffer.readInteger(as: UInt8.self),
let command = SDLCommandType(rawValue: commandVal),
let bytes = buffer.readBytes(length: buffer.readableBytes) else {
return nil
}
switch command {
case .changeNetwork:
guard let changeNetworkCommand = try? SDLChangeNetworkCommand(serializedData: Data(bytes)) else {
return nil
}
return .init(msgId: msgId, packet: .command(.changeNetwork(changeNetworkCommand)))
}
case .event:
guard let eventVal = buffer.readInteger(as: UInt8.self),
let event = SDLEventType(rawValue: eventVal),
let bytes = buffer.readBytes(length: buffer.readableBytes) else {
return nil
}
switch event {
case .natChanged:
guard let natChangedEvent = try? SDLNatChangedEvent(serializedData: Data(bytes)) else {
return nil
}
return .init(msgId: msgId, packet: .event(.natChanged(natChangedEvent)))
case .sendRegister:
guard let sendRegisterEvent = try? SDLSendRegisterEvent(serializedData: Data(bytes)) else {
return nil
}
return .init(msgId: msgId, packet: .event(.sendRegister(sendRegisterEvent)))
case .networkShutdown:
guard let networkShutdownEvent = try? SDLNetworkShutdownEvent(serializedData: Data(bytes)) else {
return nil
}
return .init(msgId: msgId, packet: .event(.networkShutdown(networkShutdownEvent)))
}
default:
return nil
}
}
}

View File

@ -1,45 +0,0 @@
//
// SDLThrottler.swift
// Tun
//
// Created by on 2024/6/3.
//
import Foundation
import Combine
//
actor SDLThrottler {
private var limit: Int
private var token: Int
private var cancel: AnyCancellable?
init(limit: Int) {
self.limit = limit
self.token = limit
}
func start() {
self.cancel?.cancel()
self.cancel = Timer.publish(every: 1.0, on: .main, in: .common).autoconnect()
.sink { _ in
Task {
self.token = self.limit
}
}
}
func setRateLimit(limit: Int) {
self.limit = limit
}
func getToken(num: Int) -> Bool {
if token > 0 {
self.token = self.token - num
return true
} else {
return false
}
}
}

View File

@ -1,337 +0,0 @@
//
// SDLanServer.swift
// Tun
//
// Created by on 2024/1/31.
//
import Foundation
import NIOCore
import NIOPosix
import Combine
// sn-server
class SDLUDPHole: ChannelInboundHandler {
public typealias InboundIn = AddressedEnvelope<ByteBuffer>
public typealias OutboundOut = AddressedEnvelope<ByteBuffer>
//
public typealias CallbackFun = (SDLStunProbeReply?) -> Void
private let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
private var cookieGenerator = SDLIdGenerator(seed: 1)
private let callbackManager = HoleCallbackManager()
public var localAddress: SocketAddress?
public var channel: Channel?
public var eventFlow = PassthroughSubject<UDPEvent, Never>()
//
enum UDPEvent {
case ready
case closed
case message(SocketAddress, SDLHoleInboundMessage)
case data(SDLData)
}
init() {
}
// MARK: super_node apis
func stunRequest(context ctx: SDLContext) -> UInt32 {
let cookie = self.cookieGenerator.nextId()
let remoteAddress = ctx.config.stunSocketAddress
var stunRequest = SDLStunRequest()
stunRequest.cookie = cookie
stunRequest.clientID = ctx.config.clientId
stunRequest.networkID = ctx.devAddr.networkID
stunRequest.ip = ctx.devAddr.netAddr
stunRequest.mac = ctx.devAddr.mac
stunRequest.natType = UInt32(ctx.natType.rawValue)
SDLLogger.log("[SDLUDPHole] stunRequest: \(remoteAddress), host: \(ctx.config.stunServers[0].host):\(ctx.config.stunServers[0].ports[0])", level: .warning)
self.send(remoteAddress: remoteAddress, type: .stunRequest, data: try! stunRequest.serializedData())
return cookie
}
// tun
func stunProbe(remoteAddress: SocketAddress, attr: SDLProbeAttr = .none, timeout: Int = 5) async -> SDLStunProbeReply? {
return await withCheckedContinuation { continuation in
self.stunProbe(remoteAddress: remoteAddress, attr: attr, timeout: timeout) { probeReply in
continuation.resume(returning: probeReply)
}
}
}
private func stunProbe(remoteAddress: SocketAddress, attr: SDLProbeAttr = .none, timeout: Int, callback: @escaping CallbackFun) {
let cookie = self.cookieGenerator.nextId()
var stunProbe = SDLStunProbe()
stunProbe.cookie = cookie
stunProbe.attr = UInt32(attr.rawValue)
self.send(remoteAddress: remoteAddress, type: .stunProbe, data: try! stunProbe.serializedData())
SDLLogger.log("[SDLUDPHole] stunProbe: \(remoteAddress)", level: .warning)
self.callbackManager.addCallback(id: cookie, timeout: timeout, callback: callback)
}
// MARK: client-client apis
// session
func sendPacket(context ctx: SDLContext, session: SDLContext.Session, data: Data) {
let remoteAddress = session.natAddress
var dataPacket = SDLData()
dataPacket.networkID = ctx.devAddr.networkID
dataPacket.srcMac = ctx.devAddr.mac
dataPacket.dstMac = session.dstMac
dataPacket.ttl = 255
dataPacket.data = data
let packet = try! dataPacket.serializedData()
SDLLogger.log("[SDLUDPHole] sendPacket: \(remoteAddress), count: \(packet.count)", level: .debug)
self.send(remoteAddress: remoteAddress, type: .data, data: packet)
}
// sn, data
func forwardPacket(context ctx: SDLContext, dst_mac: Data, data: Data) {
let remoteAddress = ctx.config.stunSocketAddress
var dataPacket = SDLData()
dataPacket.networkID = ctx.devAddr.networkID
dataPacket.srcMac = ctx.devAddr.mac
dataPacket.dstMac = dst_mac
dataPacket.ttl = 255
dataPacket.data = data
let packet = try! dataPacket.serializedData()
NSLog("[SDLContext] forward packet, remoteAddress: \(remoteAddress), data size: \(packet.count)")
self.send(remoteAddress: remoteAddress, type: .data, data: packet)
}
// register
func sendRegister(context ctx: SDLContext, remoteAddress: SocketAddress, dst_mac: Data) {
var register = SDLRegister()
register.networkID = ctx.devAddr.networkID
register.srcMac = ctx.devAddr.mac
register.dstMac = dst_mac
SDLLogger.log("[SDLUDPHole] SendRegister: \(remoteAddress), src_mac: \(LayerPacket.MacAddress.description(data: ctx.devAddr.mac)), dst_mac: \(LayerPacket.MacAddress.description(data: dst_mac))", level: .debug)
self.send(remoteAddress: remoteAddress, type: .register, data: try! register.serializedData())
}
// registerAck
func sendRegisterAck(context ctx: SDLContext, remoteAddress: SocketAddress, dst_mac: Data) {
var registerAck = SDLRegisterAck()
registerAck.networkID = ctx.devAddr.networkID
registerAck.srcMac = ctx.devAddr.mac
registerAck.dstMac = dst_mac
SDLLogger.log("[SDLUDPHole] SendRegisterAck: \(remoteAddress), \(registerAck)", level: .debug)
self.send(remoteAddress: remoteAddress, type: .registerAck, data: try! registerAck.serializedData())
}
//
func start() async throws {
let bootstrap = DatagramBootstrap(group: self.group)
.channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
.channelInitializer { channel in
//
return channel.setOption(ChannelOptions.socketOption(.so_rcvbuf), value: 5 * 1024 * 1024)
.flatMap {
channel.setOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_SNDBUF), value: 5 * 1024 * 1024)
}.flatMap {
channel.pipeline.addHandler(self)
}
}
let channel = try await bootstrap.bind(host: "0.0.0.0", port: 0).get()
SDLLogger.log("[UDPHole] started and listening on: \(channel.localAddress!)", level: .debug)
self.localAddress = channel.localAddress
self.channel = channel
}
// -- MARK: ChannelInboundHandler Methods
public func channelActive(context: ChannelHandlerContext) {
self.eventFlow.send(.ready)
}
// ,
public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
let envelope = self.unwrapInboundIn(data)
var buffer = envelope.data
let remoteAddress = envelope.remoteAddress
do {
if let message = try decode(buffer: &buffer) {
Task {
switch message {
case .data(let data):
SDLLogger.log("[SDLUDPHole] read data: \(data.format()), from: \(remoteAddress)", level: .debug)
self.eventFlow.send(.data(data))
case .stunProbeReply(let probeReply):
self.callbackManager.fireCallback(message: probeReply)
default:
self.eventFlow.send(.message(remoteAddress, message))
}
}
} else {
SDLLogger.log("[SDLUDPHole] decode message, get null", level: .warning)
}
} catch let err {
SDLLogger.log("[SDLUDPHole] decode message, get error: \(err)", level: .debug)
}
}
public func errorCaught(context: ChannelHandlerContext, error: Error) {
SDLLogger.log("[SDLUDPHole] get error: \(error)", level: .error)
// As we are not really interested getting notified on success or failure we just pass nil as promise to
// reduce allocations.
context.close(promise: nil)
self.channel = nil
self.eventFlow.send(.closed)
}
public func channelInactive(context: ChannelHandlerContext) {
self.channel = nil
context.close(promise: nil)
}
//
func send(remoteAddress: SocketAddress, type: SDLPacketType, data: Data) {
guard let channel = self.channel else {
return
}
// Eventloop线
if channel.eventLoop.inEventLoop {
var buffer = channel.allocator.buffer(capacity: data.count + 1)
buffer.writeBytes([type.rawValue])
buffer.writeBytes(data)
let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: remoteAddress, data: buffer)
channel.writeAndFlush(self.wrapOutboundOut(envelope), promise: nil)
} else {
channel.eventLoop.execute {
var buffer = channel.allocator.buffer(capacity: data.count + 1)
buffer.writeBytes([type.rawValue])
buffer.writeBytes(data)
let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: remoteAddress, data: buffer)
channel.writeAndFlush(self.wrapOutboundOut(envelope), promise: nil)
}
}
}
deinit {
try? self.group.syncShutdownGracefully()
}
}
//--MARK:
extension SDLUDPHole {
func decode(buffer: inout ByteBuffer) throws -> SDLHoleInboundMessage? {
guard let type = buffer.readInteger(as: UInt8.self),
let packetType = SDLPacketType(rawValue: type),
let bytes = buffer.readBytes(length: buffer.readableBytes) else {
SDLLogger.log("[SDLUDPHole] decode error", level: .error)
return nil
}
switch packetType {
case .data:
let dataPacket = try SDLData(serializedData: Data(bytes))
return .data(dataPacket)
case .register:
let registerPacket = try SDLRegister(serializedData: Data(bytes))
return .register(registerPacket)
case .registerAck:
let registerAck = try SDLRegisterAck(serializedData: Data(bytes))
return .registerAck(registerAck)
case .stunReply:
let stunReply = try SDLStunReply(serializedData: Data(bytes))
return .stunReply(stunReply)
case .stunProbeReply:
let stunProbeReply = try SDLStunProbeReply(serializedData: Data(bytes))
return .stunProbeReply(stunProbeReply)
default:
return nil
}
}
}
// --MARK:
extension SDLUDPHole {
private final class HoleCallbackManager {
//
private var callbacks: [UInt32:CallbackFun] = [:]
private let locker = NSLock()
func addCallback(id: UInt32, timeout: Int, callback: @escaping CallbackFun) {
locker.lock()
defer {
locker.unlock()
}
DispatchQueue.global().asyncAfter(deadline: .now() + Double(timeout)) {
self.fireCallback(cookie: id)
}
self.callbacks[id] = callback
}
func fireCallback(message: SDLStunProbeReply) {
locker.lock()
defer {
locker.unlock()
}
if let callback = self.callbacks[message.cookie] {
callback(message)
self.callbacks.removeValue(forKey: message.cookie)
}
}
func fireAllCallbacks(message: SDLSuperInboundMessage) {
locker.lock()
defer {
locker.unlock()
}
for (_, callback) in self.callbacks {
callback(nil)
}
self.callbacks.removeAll()
}
private func fireCallback(cookie: UInt32) {
locker.lock()
defer {
locker.unlock()
}
if let callback = self.callbacks[cookie] {
callback(nil)
self.callbacks.removeValue(forKey: cookie)
}
}
}
}

View File

@ -1,46 +0,0 @@
//
// Util.swift
// Tun
//
// Created by on 2024/1/19.
//
import Foundation
struct SDLUtil {
public static func int32ToIp(_ num: UInt32) -> String {
let ip0 = (UInt8) (num >> 24 & 0xFF)
let ip1 = (UInt8) (num >> 16 & 0xFF)
let ip2 = (UInt8) (num >> 8 & 0xFF)
let ip3 = (UInt8) (num & 0xFF)
return "\(ip0).\(ip1).\(ip2).\(ip3)"
}
public static func netMaskIp(maskLen: UInt8) -> String {
let len0 = 32 - maskLen
let num: UInt32 = (0xFFFFFFFF >> len0) << len0
let ip0 = (UInt8) (num >> 24 & 0xFF)
let ip1 = (UInt8) (num >> 16 & 0xFF)
let ip2 = (UInt8) (num >> 8 & 0xFF)
let ip3 = (UInt8) (num & 0xFF)
return "\(ip0).\(ip1).\(ip2).\(ip3)"
}
// ip
public static func inSameNetwork(ip: UInt32, compareIp: UInt32, maskLen: UInt8) -> Bool {
if ip == compareIp {
return true
}
let len0 = 32 - maskLen
//
let mask: UInt32 = (0xFFFFFFFF >> len0) << len0
return ip & mask == compareIp & mask
}
}

View File

@ -1,37 +0,0 @@
//
// UIntExtension.swift
// Tun
//
// Created by on 2024/5/30.
//
import Foundation
extension UInt16 {
init(bytes: (UInt8, UInt8)) {
self = UInt16(bytes.0) << 8 + UInt16(bytes.1)
}
init(data: Data) {
self = UInt16(data[0]) << 8 + UInt16(data[1])
}
func data() -> Data {
var data = Data()
data.append(contentsOf: [UInt8(self >> 8), UInt8(self & 0x00FF)])
return data
}
}
extension UInt32 {
init(bytes: (UInt8, UInt8, UInt8, UInt8)) {
self = UInt32(bytes.0) << 24 + UInt32(bytes.1) << 16 + UInt32(bytes.2) << 8 + UInt32(bytes.3)
}
init(data: Data) {
self = UInt32(data[0]) << 24 | UInt32(data[1]) << 16 | UInt32(data[2]) << 8 | UInt32(data[3])
}
}

View File

@ -7,6 +7,7 @@
objects = { objects = {
/* Begin PBXBuildFile section */ /* Begin PBXBuildFile section */
C82EA7472E3FAA5A00DA5B3C /* Punchnet in Frameworks */ = {isa = PBXBuildFile; productRef = C82EA7462E3FAA5A00DA5B3C /* Punchnet */; };
C8A77F2A2DD1E77B00195617 /* NetworkExtension.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = C8A77F292DD1E77B00195617 /* NetworkExtension.framework */; }; C8A77F2A2DD1E77B00195617 /* NetworkExtension.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = C8A77F292DD1E77B00195617 /* NetworkExtension.framework */; };
C8A77F322DD1E77B00195617 /* Tun.appex in Embed Foundation Extensions */ = {isa = PBXBuildFile; fileRef = C8A77F272DD1E77B00195617 /* Tun.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; }; C8A77F322DD1E77B00195617 /* Tun.appex in Embed Foundation Extensions */ = {isa = PBXBuildFile; fileRef = C8A77F272DD1E77B00195617 /* Tun.appex */; settings = {ATTRIBUTES = (RemoveHeadersOnCopy, ); }; };
C8A77F792DD1E93900195617 /* NIO in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F782DD1E93900195617 /* NIO */; }; C8A77F792DD1E93900195617 /* NIO in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F782DD1E93900195617 /* NIO */; };
@ -14,8 +15,6 @@
C8A77F7D2DD1E93900195617 /* NIOCore in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F7C2DD1E93900195617 /* NIOCore */; }; C8A77F7D2DD1E93900195617 /* NIOCore in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F7C2DD1E93900195617 /* NIOCore */; };
C8A77F7F2DD1E93900195617 /* NIOEmbedded in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F7E2DD1E93900195617 /* NIOEmbedded */; }; C8A77F7F2DD1E93900195617 /* NIOEmbedded in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F7E2DD1E93900195617 /* NIOEmbedded */; };
C8A77F812DD1E93900195617 /* NIOFoundationCompat in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F802DD1E93900195617 /* NIOFoundationCompat */; }; C8A77F812DD1E93900195617 /* NIOFoundationCompat in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F802DD1E93900195617 /* NIOFoundationCompat */; };
C8A77F832DD1E98B00195617 /* NIO in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F822DD1E98B00195617 /* NIO */; };
C8A77F852DD1E99300195617 /* NIOCore in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F842DD1E99300195617 /* NIOCore */; };
C8A77F882DD1EA0200195617 /* SwiftProtobuf in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F872DD1EA0200195617 /* SwiftProtobuf */; }; C8A77F882DD1EA0200195617 /* SwiftProtobuf in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F872DD1EA0200195617 /* SwiftProtobuf */; };
C8A77F8A2DD1EA0200195617 /* SwiftProtobufPluginLibrary in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F892DD1EA0200195617 /* SwiftProtobufPluginLibrary */; }; C8A77F8A2DD1EA0200195617 /* SwiftProtobufPluginLibrary in Frameworks */ = {isa = PBXBuildFile; productRef = C8A77F892DD1EA0200195617 /* SwiftProtobufPluginLibrary */; };
/* End PBXBuildFile section */ /* End PBXBuildFile section */
@ -143,10 +142,9 @@
isa = PBXFrameworksBuildPhase; isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647; buildActionMask = 2147483647;
files = ( files = (
C8A77F852DD1E99300195617 /* NIOCore in Frameworks */,
C8A77F2A2DD1E77B00195617 /* NetworkExtension.framework in Frameworks */, C8A77F2A2DD1E77B00195617 /* NetworkExtension.framework in Frameworks */,
C8A77F8A2DD1EA0200195617 /* SwiftProtobufPluginLibrary in Frameworks */, C8A77F8A2DD1EA0200195617 /* SwiftProtobufPluginLibrary in Frameworks */,
C8A77F832DD1E98B00195617 /* NIO in Frameworks */, C82EA7472E3FAA5A00DA5B3C /* Punchnet in Frameworks */,
C8A77F882DD1EA0200195617 /* SwiftProtobuf in Frameworks */, C8A77F882DD1EA0200195617 /* SwiftProtobuf in Frameworks */,
); );
runOnlyForDeploymentPostprocessing = 0; runOnlyForDeploymentPostprocessing = 0;
@ -280,10 +278,9 @@
); );
name = Tun; name = Tun;
packageProductDependencies = ( packageProductDependencies = (
C8A77F822DD1E98B00195617 /* NIO */,
C8A77F842DD1E99300195617 /* NIOCore */,
C8A77F872DD1EA0200195617 /* SwiftProtobuf */, C8A77F872DD1EA0200195617 /* SwiftProtobuf */,
C8A77F892DD1EA0200195617 /* SwiftProtobufPluginLibrary */, C8A77F892DD1EA0200195617 /* SwiftProtobufPluginLibrary */,
C82EA7462E3FAA5A00DA5B3C /* Punchnet */,
); );
productName = Tun; productName = Tun;
productReference = C8A77F272DD1E77B00195617 /* Tun.appex */; productReference = C8A77F272DD1E77B00195617 /* Tun.appex */;
@ -325,8 +322,7 @@
mainGroup = C8A77EEA2DD1E6D000195617; mainGroup = C8A77EEA2DD1E6D000195617;
minimizedProjectReferenceProxies = 1; minimizedProjectReferenceProxies = 1;
packageReferences = ( packageReferences = (
C8A77F772DD1E93900195617 /* XCLocalSwiftPackageReference "../../packages/swift-nio" */, C82EA7452E3FAA5A00DA5B3C /* XCRemoteSwiftPackageReference "swiftlib_sdlan" */,
C8A77F862DD1EA0200195617 /* XCLocalSwiftPackageReference "../../packages/swift-protobuf" */,
); );
preferredProjectObjectVersion = 77; preferredProjectObjectVersion = 77;
productRefGroup = C8A77EF42DD1E6D000195617 /* Products */; productRefGroup = C8A77EF42DD1E6D000195617 /* Products */;
@ -475,7 +471,7 @@
GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES; GCC_WARN_UNUSED_VARIABLE = YES;
LOCALIZATION_PREFERS_STRING_CATALOGS = YES; LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
MACOSX_DEPLOYMENT_TARGET = 15.2; MACOSX_DEPLOYMENT_TARGET = 14.6;
MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
ONLY_ACTIVE_ARCH = YES; ONLY_ACTIVE_ARCH = YES;
@ -532,7 +528,7 @@
GCC_WARN_UNUSED_FUNCTION = YES; GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES; GCC_WARN_UNUSED_VARIABLE = YES;
LOCALIZATION_PREFERS_STRING_CATALOGS = YES; LOCALIZATION_PREFERS_STRING_CATALOGS = YES;
MACOSX_DEPLOYMENT_TARGET = 15.2; MACOSX_DEPLOYMENT_TARGET = 14.6;
MTL_ENABLE_DEBUG_INFO = NO; MTL_ENABLE_DEBUG_INFO = NO;
MTL_FAST_MATH = YES; MTL_FAST_MATH = YES;
SDKROOT = macosx; SDKROOT = macosx;
@ -561,7 +557,7 @@
"$(inherited)", "$(inherited)",
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
); );
MACOSX_DEPLOYMENT_TARGET = 14.0; MACOSX_DEPLOYMENT_TARGET = 14.6;
MARKETING_VERSION = 1.0; MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnet; PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnet;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -593,7 +589,7 @@
"$(inherited)", "$(inherited)",
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
); );
MACOSX_DEPLOYMENT_TARGET = 14.0; MACOSX_DEPLOYMENT_TARGET = 14.6;
MARKETING_VERSION = 1.0; MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnet; PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnet;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -612,7 +608,7 @@
CURRENT_PROJECT_VERSION = 1; CURRENT_PROJECT_VERSION = 1;
DEVELOPMENT_TEAM = PF3QG837XS; DEVELOPMENT_TEAM = PF3QG837XS;
GENERATE_INFOPLIST_FILE = YES; GENERATE_INFOPLIST_FILE = YES;
MACOSX_DEPLOYMENT_TARGET = 14.0; MACOSX_DEPLOYMENT_TARGET = 14.6;
MARKETING_VERSION = 1.0; MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnetTests; PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnetTests;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -630,7 +626,7 @@
CURRENT_PROJECT_VERSION = 1; CURRENT_PROJECT_VERSION = 1;
DEVELOPMENT_TEAM = PF3QG837XS; DEVELOPMENT_TEAM = PF3QG837XS;
GENERATE_INFOPLIST_FILE = YES; GENERATE_INFOPLIST_FILE = YES;
MACOSX_DEPLOYMENT_TARGET = 14.0; MACOSX_DEPLOYMENT_TARGET = 14.6;
MARKETING_VERSION = 1.0; MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnetTests; PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnetTests;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -647,6 +643,7 @@
CURRENT_PROJECT_VERSION = 1; CURRENT_PROJECT_VERSION = 1;
DEVELOPMENT_TEAM = PF3QG837XS; DEVELOPMENT_TEAM = PF3QG837XS;
GENERATE_INFOPLIST_FILE = YES; GENERATE_INFOPLIST_FILE = YES;
MACOSX_DEPLOYMENT_TARGET = 14.6;
MARKETING_VERSION = 1.0; MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnetUITests; PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnetUITests;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -663,6 +660,7 @@
CURRENT_PROJECT_VERSION = 1; CURRENT_PROJECT_VERSION = 1;
DEVELOPMENT_TEAM = PF3QG837XS; DEVELOPMENT_TEAM = PF3QG837XS;
GENERATE_INFOPLIST_FILE = YES; GENERATE_INFOPLIST_FILE = YES;
MACOSX_DEPLOYMENT_TARGET = 14.6;
MARKETING_VERSION = 1.0; MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnetUITests; PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnetUITests;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -691,6 +689,7 @@
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
"@executable_path/../../../../Frameworks", "@executable_path/../../../../Frameworks",
); );
MACOSX_DEPLOYMENT_TARGET = 14.6;
MARKETING_VERSION = 1.0; MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnet.tun; PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnet.tun;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -721,6 +720,7 @@
"@executable_path/../Frameworks", "@executable_path/../Frameworks",
"@executable_path/../../../../Frameworks", "@executable_path/../../../../Frameworks",
); );
MACOSX_DEPLOYMENT_TARGET = 14.6;
MARKETING_VERSION = 1.0; MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnet.tun; PRODUCT_BUNDLE_IDENTIFIER = com.jihe.punchnet.tun;
PRODUCT_NAME = "$(TARGET_NAME)"; PRODUCT_NAME = "$(TARGET_NAME)";
@ -782,18 +782,23 @@
}; };
/* End XCConfigurationList section */ /* End XCConfigurationList section */
/* Begin XCLocalSwiftPackageReference section */ /* Begin XCRemoteSwiftPackageReference section */
C8A77F772DD1E93900195617 /* XCLocalSwiftPackageReference "../../packages/swift-nio" */ = { C82EA7452E3FAA5A00DA5B3C /* XCRemoteSwiftPackageReference "swiftlib_sdlan" */ = {
isa = XCLocalSwiftPackageReference; isa = XCRemoteSwiftPackageReference;
relativePath = "../../packages/swift-nio"; repositoryURL = "https://gitea.s5s8.com/anlicheng/swiftlib_sdlan.git";
requirement = {
kind = exactVersion;
version = 2.2.0;
};
}; };
C8A77F862DD1EA0200195617 /* XCLocalSwiftPackageReference "../../packages/swift-protobuf" */ = { /* End XCRemoteSwiftPackageReference section */
isa = XCLocalSwiftPackageReference;
relativePath = "../../packages/swift-protobuf";
};
/* End XCLocalSwiftPackageReference section */
/* Begin XCSwiftPackageProductDependency section */ /* Begin XCSwiftPackageProductDependency section */
C82EA7462E3FAA5A00DA5B3C /* Punchnet */ = {
isa = XCSwiftPackageProductDependency;
package = C82EA7452E3FAA5A00DA5B3C /* XCRemoteSwiftPackageReference "swiftlib_sdlan" */;
productName = Punchnet;
};
C8A77F782DD1E93900195617 /* NIO */ = { C8A77F782DD1E93900195617 /* NIO */ = {
isa = XCSwiftPackageProductDependency; isa = XCSwiftPackageProductDependency;
productName = NIO; productName = NIO;
@ -814,16 +819,6 @@
isa = XCSwiftPackageProductDependency; isa = XCSwiftPackageProductDependency;
productName = NIOFoundationCompat; productName = NIOFoundationCompat;
}; };
C8A77F822DD1E98B00195617 /* NIO */ = {
isa = XCSwiftPackageProductDependency;
package = C8A77F772DD1E93900195617 /* XCLocalSwiftPackageReference "../../packages/swift-nio" */;
productName = NIO;
};
C8A77F842DD1E99300195617 /* NIOCore */ = {
isa = XCSwiftPackageProductDependency;
package = C8A77F772DD1E93900195617 /* XCLocalSwiftPackageReference "../../packages/swift-nio" */;
productName = NIOCore;
};
C8A77F872DD1EA0200195617 /* SwiftProtobuf */ = { C8A77F872DD1EA0200195617 /* SwiftProtobuf */ = {
isa = XCSwiftPackageProductDependency; isa = XCSwiftPackageProductDependency;
productName = SwiftProtobuf; productName = SwiftProtobuf;

View File

@ -1,13 +1,13 @@
{ {
"originHash" : "fc5ff56467a09054cad310ea04e2207caefea4e4c42012fbd995ed64d089417b", "originHash" : "2c771b2bd4bccdc5777d69cc734485452a1e854c0123ba591d596b3f580f4cb8",
"pins" : [ "pins" : [
{ {
"identity" : "swift-atomics", "identity" : "swift-atomics",
"kind" : "remoteSourceControl", "kind" : "remoteSourceControl",
"location" : "https://github.com/apple/swift-atomics.git", "location" : "https://github.com/apple/swift-atomics.git",
"state" : { "state" : {
"revision" : "cd142fd2f64be2100422d658e7411e39489da985", "revision" : "b601256eab081c0f92f059e12818ac1d4f178ff7",
"version" : "1.2.0" "version" : "1.3.0"
} }
}, },
{ {
@ -15,8 +15,26 @@
"kind" : "remoteSourceControl", "kind" : "remoteSourceControl",
"location" : "https://github.com/apple/swift-collections.git", "location" : "https://github.com/apple/swift-collections.git",
"state" : { "state" : {
"revision" : "671108c96644956dddcd89dd59c203dcdb36cec7", "revision" : "8c0c0a8b49e080e54e5e328cc552821ff07cd341",
"version" : "1.1.4" "version" : "1.2.1"
}
},
{
"identity" : "swift-nio",
"kind" : "remoteSourceControl",
"location" : "https://github.com/apple/swift-nio.git",
"state" : {
"revision" : "a5fea865badcb1c993c85b0f0e8d05a4bd2270fb",
"version" : "2.85.0"
}
},
{
"identity" : "swift-protobuf",
"kind" : "remoteSourceControl",
"location" : "https://github.com/apple/swift-protobuf.git",
"state" : {
"revision" : "102a647b573f60f73afdce5613a51d71349fe507",
"version" : "1.30.0"
} }
}, },
{ {
@ -24,8 +42,17 @@
"kind" : "remoteSourceControl", "kind" : "remoteSourceControl",
"location" : "https://github.com/apple/swift-system.git", "location" : "https://github.com/apple/swift-system.git",
"state" : { "state" : {
"revision" : "a34201439c74b53f0fd71ef11741af7e7caf01e1", "revision" : "b63d24d465e237966c3f59f47dcac6c70fb0bca3",
"version" : "1.4.2" "version" : "1.6.1"
}
},
{
"identity" : "swiftlib_sdlan",
"kind" : "remoteSourceControl",
"location" : "https://gitea.s5s8.com/anlicheng/swiftlib_sdlan.git",
"state" : {
"revision" : "2c05d71dbe3684e51e9de55910619156ebe360c6",
"version" : "2.2.0"
} }
} }
], ],

View File

@ -1,30 +0,0 @@
//
// Config.swift
// punchnet
//
// Created by on 2025/5/14.
//
import Foundation
enum PunchnetError: Error {
case dnsUnreachable
}
struct PunchnetConfig {
static let server = "punchnet.aioe.tech"
static let port = 18083
static func getOptions() throws -> [String:NSObject] {
var options: [String: NSObject] = [:]
if let ip = DNSResolver.resolveAddrInfos(PunchnetConfig.server).first {
options["super_ip"] = ip as NSObject
} else {
throw PunchnetError.dnsUnreachable
}
return options
}
}

View File

@ -15,4 +15,29 @@ struct SystemConfig {
// //
static let installedChannel = "MacAppStore" static let installedChannel = "MacAppStore"
// super
//static let superHost = "118.178.229.213"
static let superHost = "punchnet.aioe.tech"
static let superPort = 18083
// stun
static let stunServers = "118.178.229.213:1265,1266;118.178.229.213:1265,1266"
static func getOptions(token: String) -> [String:NSObject]? {
guard let superIp = DNSResolver.resolveAddrInfos(superHost).first else {
return nil
}
return [
"version:": version as NSObject,
"installed_channel": installedChannel as NSObject,
"token": token as NSObject,
"super_ip": superIp as NSObject,
"super_port": superPort as NSObject,
"stun_servers": stunServers as NSObject
]
}
} }

View File

@ -32,10 +32,7 @@ class VPNManager: ObservableObject {
try await manager.loadFromPreferences() try await manager.loadFromPreferences()
self.addVPNStatusObserver(manager) self.addVPNStatusObserver(manager)
var configOptions = try PunchnetConfig.getOptions() try manager.connection.startVPNTunnel(options: options)
configOptions.merge(options, uniquingKeysWith: {$1})
try manager.connection.startVPNTunnel(options: configOptions)
} }
// vpn // vpn

View File

@ -9,7 +9,6 @@ import Foundation
import SwiftUI import SwiftUI
struct AbortView: View { struct AbortView: View {
struct AlertShow: Identifiable { struct AlertShow: Identifiable {
enum ShowContent { enum ShowContent {
case error(String) case error(String)

View File

@ -9,8 +9,7 @@ import SwiftUI
import SwiftData import SwiftData
import Combine import Combine
struct ContentView: View { struct IndexView: View {
@AppStorage("token") private var token: String = "" @AppStorage("token") private var token: String = ""
@State private var showToken: Bool = false @State private var showToken: Bool = false
@ -191,24 +190,13 @@ struct ContentView: View {
case .connected: case .connected:
try await vpnManager.disableVpn() try await vpnManager.disableVpn()
case .disconnected: case .disconnected:
/* try await vpnManager.enableVpn(options: SystemConfig.getOptions(token: self.token)!)
if self.token.isEmpty {
self.showAlert = true
return
}
*/
//print("use port: \(vpnManager.noticePort as NSObject)")
try await vpnManager.enableVpn(options: [
"version:": SystemConfig.version as NSObject,
"installed_channel": SystemConfig.installedChannel as NSObject,
"token": self.token as NSObject
])
} }
} }
} }
#Preview { #Preview {
ContentView() IndexView()
//.modelContainer(for: Item.self, inMemory: true) //.modelContainer(for: Item.self, inMemory: true)
} }

View File

@ -35,7 +35,7 @@ struct punchnetApp: App {
var body: some Scene { var body: some Scene {
WindowGroup(id: "mainWindow") { WindowGroup(id: "mainWindow") {
ContentView() IndexView()
.frame(minWidth: 300, maxWidth: 300, minHeight: 500, maxHeight: 500) .frame(minWidth: 300, maxWidth: 300, minHeight: 500, maxHeight: 500)
.onAppear { .onAppear {
// //
@ -94,11 +94,7 @@ struct punchnetApp: App {
switch self.vpnManager.vpnStatus { switch self.vpnManager.vpnStatus {
case .disconnected: case .disconnected:
Task { Task {
try await vpnManager.enableVpn(options: [ try await vpnManager.enableVpn(options: SystemConfig.getOptions(token: self.token)!)
"version:": SystemConfig.version as NSObject,
"installed_channel": SystemConfig.installedChannel as NSObject,
"token": token as NSObject
])
} }
case .connected: case .connected:
Task { Task {