├── README.md
├── .gitignore
├── Sources
    ├── Dribble
    │   ├── Errors.swift
    │   ├── TurnChannels.swift
    │   ├── Heplers.swift
    │   ├── TurnClient.swift
    │   ├── StunClient.swift
    │   ├── StunInboundHandler.swift
    │   ├── TurnAllocation.swift
    │   └── STUN.swift
    └── CLIExample
    │   └── CLI.swift
├── Coturn
    └── docker-compose.yml
├── Package.resolved
├── Package.swift
├── .swiftpm
    └── xcode
    │   └── xcshareddata
    │       └── xcschemes
    │           ├── Dribble.xcscheme
    │           ├── CLIExample.xcscheme
    │           └── Dribble-Package.xcscheme
└── Tests
    └── DribbleTests
        └── DribbleTests.swift


/README.md:
--------------------------------------------------------------------------------
1 | # Dribble
2 | 
3 | A description of this package.
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .DS_Store
2 | /.build
3 | /Packages
4 | /*.xcodeproj
5 | xcuserdata/
6 | DerivedData/
7 | .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
8 | .vscode/
9 | 


--------------------------------------------------------------------------------
/Sources/Dribble/Errors.swift:
--------------------------------------------------------------------------------
 1 | enum StunClientError: Error {
 2 |     case queryFailed
 3 | }
 4 | 
 5 | enum TurnClientError: Error {
 6 |     case createPermissionFailure
 7 | }
 8 | 
 9 | enum TurnChannelError: Error {
10 |     case operationUnsupported
11 | }
12 | 


--------------------------------------------------------------------------------
/Coturn/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: '2.4'
 2 | 
 3 | services:
 4 |   coturn:
 5 |     image: bloodhunterd/coturn
 6 |     environment:
 7 |       REALM: example.com
 8 |       SECRET: password
 9 |     hostname: coturn
10 |     ports:
11 |       - '3478:3478'
12 |       - '5349:5349'
13 |     volumes:
14 |       - ./cert.pem:/etc/ssl/private/cert.pem:ro
15 |       - ./key.pem:/etc/ssl/private/key.pem:ro
16 |       - ./dhparams.pem:/etc/ssl/private/dhparams.pem:ro
17 |       - ./turndb:/var/lib/turn/turndb
18 | 


--------------------------------------------------------------------------------
/Sources/Dribble/TurnChannels.swift:
--------------------------------------------------------------------------------
 1 | import NIO
 2 | 
 3 | struct TurnChannelData {
 4 |     // 0x4000 through 0x4FFF
 5 |     let channelNumber: ChannelNumber
 6 |     var length: UInt16 {
 7 |         UInt16(applicationData.readableBytes)
 8 |     }
 9 |     var applicationData: ByteBuffer
10 | }
11 | 
12 | public struct ChannelNumber: RawRepresentable {
13 |     public let rawValue: UInt16
14 |     
15 |     public init(rawValue: UInt16) {
16 |         self.rawValue = rawValue
17 |     }
18 |     
19 |     public init() {
20 |         self.rawValue = .random(in: 0x4000 ... 0x4FFF)
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/Sources/Dribble/Heplers.swift:
--------------------------------------------------------------------------------
 1 | import NIO
 2 | 
 3 | final class EnvelopToByteBufferConverter: ChannelInboundHandler {
 4 |     public typealias InboundIn = AddressedEnvelope<ByteBuffer>
 5 |     public typealias InboundOut = ByteBuffer
 6 |     public typealias ErrorHandler = ((Error) -> ())?
 7 |     
 8 |     private let errorHandler: ErrorHandler
 9 |     
10 |     init(errorHandler: ErrorHandler) {
11 |         self.errorHandler = errorHandler
12 |     }
13 |     
14 |     public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
15 |         let envelope = self.unwrapInboundIn(data)
16 |         let byteBuffer = envelope.data
17 |         context.fireChannelRead(self.wrapInboundOut(byteBuffer))
18 |     }
19 |     
20 |     public func errorCaught(context: ChannelHandlerContext, error: Error) {
21 |         errorHandler?(error)
22 |         context.close(promise: nil)
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/Sources/Dribble/TurnClient.swift:
--------------------------------------------------------------------------------
 1 | import NIOConcurrencyHelpers
 2 | import _NIOConcurrency
 3 | import NIO
 4 | 
 5 | public final class TurnClient: StunClient {
 6 |     public func requestAllocation() async throws -> TurnAllocation {
 7 |         let message = try await sendMessage(.allocationRequest())
 8 |         
 9 |         guard let relayedAddressAttribute = message.attributes.first(where: { attribute in
10 |             return attribute.type == StunAttributeType.xorRelayedAddress.rawValue
11 |         }) else {
12 |             throw StunClientError.queryFailed
13 |         }
14 |         
15 |         switch try relayedAddressAttribute.resolve(forTransaction: message.header.transactionId) {
16 |         case .xorRelayedAddress(let address):
17 |             return TurnAllocation(
18 |                 ourAddress: address,
19 |                 client: self
20 |             )
21 |         default:
22 |             throw StunClientError.queryFailed
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Package.resolved:
--------------------------------------------------------------------------------
 1 | {
 2 |   "object": {
 3 |     "pins": [
 4 |       {
 5 |         "package": "swift-atomics",
 6 |         "repositoryURL": "https://github.com/apple/swift-atomics.git",
 7 |         "state": {
 8 |           "branch": null,
 9 |           "revision": "cd142fd2f64be2100422d658e7411e39489da985",
10 |           "version": "1.2.0"
11 |         }
12 |       },
13 |       {
14 |         "package": "swift-collections",
15 |         "repositoryURL": "https://github.com/apple/swift-collections.git",
16 |         "state": {
17 |           "branch": null,
18 |           "revision": "a902f1823a7ff3c9ab2fba0f992396b948eda307",
19 |           "version": "1.0.5"
20 |         }
21 |       },
22 |       {
23 |         "package": "swift-crypto",
24 |         "repositoryURL": "https://github.com/apple/swift-crypto.git",
25 |         "state": {
26 |           "branch": null,
27 |           "revision": "d9825fa541df64b1a7b182178d61b9a82730d01f",
28 |           "version": "2.1.0"
29 |         }
30 |       },
31 |       {
32 |         "package": "swift-nio",
33 |         "repositoryURL": "https://github.com/apple/swift-nio.git",
34 |         "state": {
35 |           "branch": null,
36 |           "revision": "54c85cb26308b89846d4671f23954dce088da2b0",
37 |           "version": "2.60.0"
38 |         }
39 |       }
40 |     ]
41 |   },
42 |   "version": 1
43 | }
44 | 


--------------------------------------------------------------------------------
/Package.swift:
--------------------------------------------------------------------------------
 1 | // swift-tools-version:5.5
 2 | // The swift-tools-version declares the minimum version of Swift required to build this package.
 3 | 
 4 | import PackageDescription
 5 | 
 6 | let package = Package(
 7 |     name: "Dribble",
 8 |     platforms: [
 9 |         .macOS(.v12),
10 |         .iOS(.v15),
11 |     ],
12 |     products: [
13 |         // Products define the executables and libraries a package produces, and make them visible to other packages.
14 |         .library(
15 |             name: "Dribble",
16 |             targets: ["Dribble"]),
17 |     ],
18 |     dependencies: [
19 |         .package(url: "https://github.com/apple/swift-nio.git", from: "2.60.0"),
20 |         .package(url: "https://github.com/apple/swift-crypto.git", "1.0.0"..<"3.0.0"),
21 |     ],
22 |     targets: [
23 |         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
24 |         // Targets can depend on other targets in this package, and on products in packages this package depends on.
25 |         .target(
26 |             name: "Dribble",
27 |             dependencies: [
28 |                 .product(name: "NIO", package: "swift-nio"),
29 |                 .product(name: "_NIOConcurrency", package: "swift-nio"),
30 |                 .product(name: "NIOFoundationCompat", package: "swift-nio"),
31 |                 .product(name: "Crypto", package: "swift-crypto"),
32 |             ]),
33 |         .executableTarget(name: "CLIExample", dependencies: [
34 |             "Dribble"
35 |         ]),
36 |         .testTarget(
37 |             name: "DribbleTests",
38 |             dependencies: ["Dribble"]),
39 |     ]
40 | )
41 | 


--------------------------------------------------------------------------------
/Sources/Dribble/StunClient.swift:
--------------------------------------------------------------------------------
 1 | import NIOConcurrencyHelpers
 2 | import _NIOConcurrency
 3 | import NIO
 4 | 
 5 | public class StunClient {
 6 |     let channel: Channel
 7 |     let sender: StunMessageSender
 8 |     
 9 |     internal required init(channel: Channel, sender: StunMessageSender) {
10 |         self.channel = channel
11 |         self.sender = sender
12 |     }
13 |     
14 |     public static func connect(to address: SocketAddress) async throws -> Self {
15 |         let sender = StunInboundHandler(remoteAddress: address)
16 |         let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
17 |         let channel = try await DatagramBootstrap(group: elg)
18 |             .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
19 |             .channelInitializer { channel in
20 |                 channel.pipeline.addHandlers(
21 |                     EnvelopToByteBufferConverter { _ in
22 |                         _ = channel.close()
23 |                     },
24 |                     ByteToMessageHandler(StunParser()),
25 |                     sender
26 |                 )
27 |             }.bind(
28 |                 host: address.protocol == .inet ? "0.0.0.0" : "::",
29 |                 port: 0
30 |             ).get()
31 |         
32 |         return Self.init(channel: channel, sender: sender)
33 |     }
34 |     
35 |     internal func sendMessage(_ message: StunMessage) async throws -> StunMessage {
36 |         try await sender.sendMessage(message, on: channel)
37 |     }
38 |     
39 |     public func requestBinding(addressFamily: AddressFamily) async throws -> SocketAddress {
40 |         let message = try await sendMessage(.bindingRequest(with: addressFamily))
41 |         
42 |         guard let addressAttribute = message.attributes.first(where: { attribute in
43 |             switch attribute.type {
44 |             case StunAttributeType.mappedAddress.rawValue:
45 |                 return true
46 |             case StunAttributeType.xorMappedAddress.rawValue:
47 |                 return true
48 |             default:
49 |                 return false
50 |             }
51 |         }) else {
52 |             throw StunClientError.queryFailed
53 |         }
54 |         
55 |         switch try addressAttribute.resolve(forTransaction: message.header.transactionId) {
56 |         case .mappedAddress(let address), .xorMappedAddress(let address):
57 |             return address
58 |         default:
59 |             throw StunClientError.queryFailed
60 |         }
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/Sources/CLIExample/CLI.swift:
--------------------------------------------------------------------------------
 1 | import Dribble
 2 | import NIO
 3 | 
 4 | final class EnvelopToByteBufferConverter: ChannelInboundHandler {
 5 |     public typealias InboundIn = AddressedEnvelope<ByteBuffer>
 6 |     public typealias InboundOut = ByteBuffer
 7 |     public typealias ErrorHandler = ((Error) -> ())?
 8 |     
 9 |     private let errorHandler: ErrorHandler
10 |     
11 |     init(errorHandler: ErrorHandler) {
12 |         self.errorHandler = errorHandler
13 |     }
14 |     
15 |     public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
16 |         let envelope = self.unwrapInboundIn(data)
17 |         let byteBuffer = envelope.data
18 |         context.fireChannelRead(self.wrapInboundOut(byteBuffer))
19 |     }
20 |     
21 |     public func errorCaught(context: ChannelHandlerContext, error: Error) {
22 |         errorHandler?(error)
23 |         context.close(promise: nil)
24 |     }
25 | }
26 | 
27 | struct PrintHandler: ByteToMessageDecoder {
28 |     typealias InboundOut = Never
29 |     
30 |     func decode(context: ChannelHandlerContext, buffer: inout ByteBuffer) throws -> DecodingState {
31 |         let string = buffer.readString(length: buffer.readableBytes) ?? "error"
32 |         print(string)
33 |         
34 |         return .continue
35 |     }
36 |     
37 |     func decodeLast(context: ChannelHandlerContext, buffer: inout ByteBuffer, seenEOF: Bool) throws -> DecodingState {
38 |         try decode(context: context, buffer: &buffer)
39 |     }
40 | }
41 | 
42 | @main
43 | struct CLI {
44 |     static func main() async throws {
45 |         let client = try await TurnClient.connect(
46 |             to: SocketAddress.makeAddressResolvingHost("10.211.55.4", port: 3478)
47 |         )
48 |         
49 |         let myAddress = try await client.requestBinding(addressFamily: .ipv4)
50 |         let allocation = try await client.requestAllocation()
51 |         
52 |         // Normally the other client should also find their address
53 |         // We can skip that here, because it's the same address
54 |         
55 |         let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
56 |         let proxyTargettedChannel = try await DatagramBootstrap(group: elg)
57 |             .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
58 |             .channelInitializer { channel in
59 |                 channel.eventLoop.makeSucceededVoidFuture()
60 |             }.bind(
61 |                 host: myAddress.protocol == .inet ? "0.0.0.0" : "::",
62 |                 port: 0
63 |             ).get()
64 |         
65 |         var theirAddress = myAddress
66 |         theirAddress.port = proxyTargettedChannel.localAddress?.port
67 |         let allocationChannel = try await allocation.createChannel(for: theirAddress)
68 |         try await allocationChannel.pipeline.addHandler(ByteToMessageHandler(PrintHandler()))
69 |         try await proxyTargettedChannel.pipeline.addHandlers(
70 |             EnvelopToByteBufferConverter { _ in },
71 |             ByteToMessageHandler(PrintHandler())
72 |         )
73 |         
74 |         try await proxyTargettedChannel.writeAndFlush(
75 |             AddressedEnvelope(
76 |                 remoteAddress: allocation.ourAddress,
77 |                 data: ByteBuffer(string: "Hello")
78 |             )
79 |         )
80 |         
81 |         try await allocationChannel.writeAndFlush(ByteBuffer(string: "Test"))
82 |         
83 |         sleep(5)
84 |         try await proxyTargettedChannel.close()
85 |         try await allocationChannel.close()
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/.swiftpm/xcode/xcshareddata/xcschemes/Dribble.xcscheme:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <Scheme
 3 |    LastUpgradeVersion = "1300"
 4 |    version = "1.3">
 5 |    <BuildAction
 6 |       parallelizeBuildables = "YES"
 7 |       buildImplicitDependencies = "YES">
 8 |       <BuildActionEntries>
 9 |          <BuildActionEntry
10 |             buildForTesting = "YES"
11 |             buildForRunning = "YES"
12 |             buildForProfiling = "YES"
13 |             buildForArchiving = "YES"
14 |             buildForAnalyzing = "YES">
15 |             <BuildableReference
16 |                BuildableIdentifier = "primary"
17 |                BlueprintIdentifier = "Dribble"
18 |                BuildableName = "Dribble"
19 |                BlueprintName = "Dribble"
20 |                ReferencedContainer = "container:">
21 |             </BuildableReference>
22 |          </BuildActionEntry>
23 |          <BuildActionEntry
24 |             buildForTesting = "YES"
25 |             buildForRunning = "YES"
26 |             buildForProfiling = "YES"
27 |             buildForArchiving = "YES"
28 |             buildForAnalyzing = "YES">
29 |             <BuildableReference
30 |                BuildableIdentifier = "primary"
31 |                BlueprintIdentifier = "CLIExample"
32 |                BuildableName = "CLIExample"
33 |                BlueprintName = "CLIExample"
34 |                ReferencedContainer = "container:">
35 |             </BuildableReference>
36 |          </BuildActionEntry>
37 |       </BuildActionEntries>
38 |    </BuildAction>
39 |    <TestAction
40 |       buildConfiguration = "Debug"
41 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
42 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
43 |       shouldUseLaunchSchemeArgsEnv = "YES">
44 |       <Testables>
45 |          <TestableReference
46 |             skipped = "NO">
47 |             <BuildableReference
48 |                BuildableIdentifier = "primary"
49 |                BlueprintIdentifier = "DribbleTests"
50 |                BuildableName = "DribbleTests"
51 |                BlueprintName = "DribbleTests"
52 |                ReferencedContainer = "container:">
53 |             </BuildableReference>
54 |          </TestableReference>
55 |       </Testables>
56 |    </TestAction>
57 |    <LaunchAction
58 |       buildConfiguration = "Debug"
59 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
60 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
61 |       launchStyle = "0"
62 |       useCustomWorkingDirectory = "NO"
63 |       ignoresPersistentStateOnLaunch = "NO"
64 |       debugDocumentVersioning = "YES"
65 |       debugServiceExtension = "internal"
66 |       allowLocationSimulation = "YES">
67 |    </LaunchAction>
68 |    <ProfileAction
69 |       buildConfiguration = "Release"
70 |       shouldUseLaunchSchemeArgsEnv = "YES"
71 |       savedToolIdentifier = ""
72 |       useCustomWorkingDirectory = "NO"
73 |       debugDocumentVersioning = "YES">
74 |       <MacroExpansion>
75 |          <BuildableReference
76 |             BuildableIdentifier = "primary"
77 |             BlueprintIdentifier = "Dribble"
78 |             BuildableName = "Dribble"
79 |             BlueprintName = "Dribble"
80 |             ReferencedContainer = "container:">
81 |          </BuildableReference>
82 |       </MacroExpansion>
83 |    </ProfileAction>
84 |    <AnalyzeAction
85 |       buildConfiguration = "Debug">
86 |    </AnalyzeAction>
87 |    <ArchiveAction
88 |       buildConfiguration = "Release"
89 |       revealArchiveInOrganizer = "YES">
90 |    </ArchiveAction>
91 | </Scheme>
92 | 


--------------------------------------------------------------------------------
/Sources/Dribble/StunInboundHandler.swift:
--------------------------------------------------------------------------------
 1 | import NIO
 2 | import _NIOConcurrency
 3 | 
 4 | protocol StunMessageSender {
 5 |     func sendMessage(_ message: StunMessage, on channel: Channel) async throws -> StunMessage
 6 |     func registerTurnAllocationChannel(_ channel: TurnAllocationChannel, theirAddress: SocketAddress) async throws
 7 | }
 8 | 
 9 | final class StunInboundHandler: ChannelInboundHandler, StunMessageSender {
10 |     public typealias InboundIn = StunMessage
11 |     public typealias OutboundOut = AddressedEnvelope<ByteBuffer>
12 |     
13 |     let remoteAddress: SocketAddress
14 |     var queries = [StunTransactionId: EventLoopPromise<StunMessage>]()
15 |     var allocations = [(SocketAddress, Channel)]()
16 |     
17 |     init(remoteAddress: SocketAddress) {
18 |         self.remoteAddress = remoteAddress
19 |     }
20 |     
21 |     public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
22 |         let message = self.unwrapInboundIn(data)
23 |         
24 |         if message.header.type == .dataIndication {
25 |             do {
26 |                 if
27 |                     let data = message.attributes.first(where: { $0.stunType == .data }),
28 |                     let origin = message.attributes.first(where: { $0.stunType == .xorPeerAddress }),
29 |                     case .data(let buffer) = try data.resolve(forTransaction: message.header.transactionId),
30 |                     case .xorPeerAddress(let address) = try origin.resolve(forTransaction: message.header.transactionId)
31 |                 {
32 |                     let allocation = allocations.first(where: { allocation in
33 |                         switch (allocation.0, address) {
34 |                         case (.v4(let lhs), .v4(let rhs)):
35 |                             return lhs.address.sin_addr.s_addr == rhs.address.sin_addr.s_addr
36 |                         case (.v6(let lhs), .v6(let rhs)):
37 |                         #if swift(>=5.5) && os(Linux)
38 |                             return lhs.address.sin6_addr.__in6_u.__u6_addr32 == rhs.address.sin6_addr.__in6_u.__u6_addr32
39 |                         #else
40 |                              return lhs.address.sin6_addr.__u6_addr.__u6_addr32 == rhs.address.sin6_addr.__u6_addr.__u6_addr32
41 |                         #endif
42 |                         case (.v4, _), (.v6, _), (.unixDomainSocket, _),
43 |                             (_, .v4), (_, .v6), (_, .unixDomainSocket):
44 |                             return false
45 |                         }
46 |                     })
47 |                     allocation?.1.pipeline.fireChannelRead(NIOAny(buffer))
48 |                 }
49 |             } catch {
50 |                 print(error)
51 |             }
52 |         } else if let query = queries.removeValue(forKey: message.header.transactionId) {
53 |             query.succeed(message)
54 |         }
55 |     }
56 |     
57 |     public func errorCaught(context: ChannelHandlerContext, error: Error) {
58 |         for query in queries.values {
59 |             query.fail(error)
60 |         }
61 |         
62 |         queries.removeAll()
63 |         allocations.removeAll()
64 |         context.close(promise: nil)
65 |     }
66 | 
67 |     func registerTurnAllocationChannel(_ channel: TurnAllocationChannel, theirAddress: SocketAddress) async throws {
68 |         allocations.append((theirAddress, channel))
69 |     }
70 |     
71 |     func sendMessage(_ message: StunMessage, on channel: Channel) async throws -> StunMessage {
72 |         var data = ByteBuffer()
73 |         data.writeStunMessage(message)
74 |         let promise = channel.eventLoop.makePromise(of: StunMessage.self)
75 |         self.queries[message.header.transactionId] = promise
76 |         return try await channel.writeAndFlush(
77 |             AddressedEnvelope(
78 |                 remoteAddress: remoteAddress,
79 |                 data: data
80 |             )
81 |         ).flatMap {
82 |             promise.futureResult
83 |         }.get()
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/.swiftpm/xcode/xcshareddata/xcschemes/CLIExample.xcscheme:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <Scheme
  3 |    LastUpgradeVersion = "1300"
  4 |    version = "1.3">
  5 |    <BuildAction
  6 |       parallelizeBuildables = "YES"
  7 |       buildImplicitDependencies = "YES">
  8 |       <BuildActionEntries>
  9 |          <BuildActionEntry
 10 |             buildForTesting = "YES"
 11 |             buildForRunning = "YES"
 12 |             buildForProfiling = "YES"
 13 |             buildForArchiving = "YES"
 14 |             buildForAnalyzing = "YES">
 15 |             <BuildableReference
 16 |                BuildableIdentifier = "primary"
 17 |                BlueprintIdentifier = "CLIExample"
 18 |                BuildableName = "CLIExample"
 19 |                BlueprintName = "CLIExample"
 20 |                ReferencedContainer = "container:">
 21 |             </BuildableReference>
 22 |          </BuildActionEntry>
 23 |          <BuildActionEntry
 24 |             buildForTesting = "YES"
 25 |             buildForRunning = "YES"
 26 |             buildForProfiling = "NO"
 27 |             buildForArchiving = "NO"
 28 |             buildForAnalyzing = "YES">
 29 |             <BuildableReference
 30 |                BuildableIdentifier = "primary"
 31 |                BlueprintIdentifier = "DribbleTests"
 32 |                BuildableName = "DribbleTests"
 33 |                BlueprintName = "DribbleTests"
 34 |                ReferencedContainer = "container:">
 35 |             </BuildableReference>
 36 |          </BuildActionEntry>
 37 |       </BuildActionEntries>
 38 |    </BuildAction>
 39 |    <TestAction
 40 |       buildConfiguration = "Debug"
 41 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
 42 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
 43 |       shouldUseLaunchSchemeArgsEnv = "YES">
 44 |       <Testables>
 45 |          <TestableReference
 46 |             skipped = "NO">
 47 |             <BuildableReference
 48 |                BuildableIdentifier = "primary"
 49 |                BlueprintIdentifier = "DribbleTests"
 50 |                BuildableName = "DribbleTests"
 51 |                BlueprintName = "DribbleTests"
 52 |                ReferencedContainer = "container:">
 53 |             </BuildableReference>
 54 |          </TestableReference>
 55 |       </Testables>
 56 |    </TestAction>
 57 |    <LaunchAction
 58 |       buildConfiguration = "Debug"
 59 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
 60 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
 61 |       launchStyle = "0"
 62 |       useCustomWorkingDirectory = "NO"
 63 |       ignoresPersistentStateOnLaunch = "NO"
 64 |       debugDocumentVersioning = "YES"
 65 |       debugServiceExtension = "internal"
 66 |       allowLocationSimulation = "YES">
 67 |       <BuildableProductRunnable
 68 |          runnableDebuggingMode = "0">
 69 |          <BuildableReference
 70 |             BuildableIdentifier = "primary"
 71 |             BlueprintIdentifier = "CLIExample"
 72 |             BuildableName = "CLIExample"
 73 |             BlueprintName = "CLIExample"
 74 |             ReferencedContainer = "container:">
 75 |          </BuildableReference>
 76 |       </BuildableProductRunnable>
 77 |    </LaunchAction>
 78 |    <ProfileAction
 79 |       buildConfiguration = "Release"
 80 |       shouldUseLaunchSchemeArgsEnv = "YES"
 81 |       savedToolIdentifier = ""
 82 |       useCustomWorkingDirectory = "NO"
 83 |       debugDocumentVersioning = "YES">
 84 |       <BuildableProductRunnable
 85 |          runnableDebuggingMode = "0">
 86 |          <BuildableReference
 87 |             BuildableIdentifier = "primary"
 88 |             BlueprintIdentifier = "CLIExample"
 89 |             BuildableName = "CLIExample"
 90 |             BlueprintName = "CLIExample"
 91 |             ReferencedContainer = "container:">
 92 |          </BuildableReference>
 93 |       </BuildableProductRunnable>
 94 |    </ProfileAction>
 95 |    <AnalyzeAction
 96 |       buildConfiguration = "Debug">
 97 |    </AnalyzeAction>
 98 |    <ArchiveAction
 99 |       buildConfiguration = "Release"
100 |       revealArchiveInOrganizer = "YES">
101 |    </ArchiveAction>
102 | </Scheme>
103 | 


--------------------------------------------------------------------------------
/Tests/DribbleTests/DribbleTests.swift:
--------------------------------------------------------------------------------
  1 | import NIO
  2 | import XCTest
  3 | @testable import Dribble
  4 | import NIOPosix
  5 | 
  6 | final class DribbleTests: XCTestCase {
  7 |     func testExample() throws {
  8 |         let remoteAddress = try SocketAddress.makeAddressResolvingHost("stun.l.google.com", port: 19302)
  9 |         let elg = MultiThreadedEventLoopGroup(numberOfThreads: 1)
 10 |         let server = try DatagramBootstrap(group: elg)
 11 |             .channelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
 12 |             .channelInitializer { channel in
 13 |                 channel.pipeline.addHandlers([
 14 |                     EnvelopToByteBufferConverter { _ in
 15 |                         _ = channel.close()
 16 |                     },
 17 |                     ByteToMessageHandler(StunParser()),
 18 |                     
 19 |                     StunInboundHandler(errorHandler: { error in
 20 |                         XCTFail()
 21 |                     }, attributesHandler: { message in
 22 |                         for attribute in message.attributes {
 23 |                             var value = attribute.value
 24 |                             guard let type = StunAttributeType(rawValue: attribute.type) else {
 25 |                                 continue
 26 |                             }
 27 |                             let attribute = try! ResolvedStunAttribute(
 28 |                                 type: type,
 29 |                                 transactionId: message.header.transactionId,
 30 |                                 buffer: &value
 31 |                             )
 32 |                             print(attribute)
 33 |                         }
 34 |                         print(message)
 35 |                     })
 36 |                 ])
 37 |             }.bind(host: remoteAddress.protocol == .inet ? "0.0.0.0" : "::", port: 14135).wait()
 38 |         
 39 |         do {
 40 |             let message = StunMessage.bindingRequest(with: .ipv6)
 41 |             var buffer = ByteBuffer()
 42 |             buffer.writeStunMessage(message)
 43 |             let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: remoteAddress, data: buffer)
 44 |             try server.writeAndFlush(envelope).wait()
 45 |         }
 46 |         
 47 |         sleep(3)
 48 |         
 49 |         do {
 50 |             let message = StunMessage.allocationRequest()
 51 |             var buffer = ByteBuffer()
 52 |             buffer.writeStunMessage(message)
 53 |             let envelope = AddressedEnvelope<ByteBuffer>(remoteAddress: remoteAddress, data: buffer)
 54 |             try server.writeAndFlush(envelope).wait()
 55 |         }
 56 |         
 57 |         try server.close().wait()
 58 |         try elg.syncShutdownGracefully()
 59 |     }
 60 | }
 61 | 
 62 | final class EnvelopToByteBufferConverter: ChannelInboundHandler {
 63 |     public typealias InboundIn = AddressedEnvelope<ByteBuffer>
 64 |     public typealias InboundOut = ByteBuffer
 65 |     public typealias ErrorHandler = ((Error) -> ())?
 66 |     
 67 |     private let errorHandler: ErrorHandler
 68 |     
 69 |     init(errorHandler: ErrorHandler) {
 70 |         self.errorHandler = errorHandler
 71 |     }
 72 |     
 73 |     public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
 74 |         let envelope = self.unwrapInboundIn(data)
 75 |         let byteBuffer = envelope.data
 76 |         context.fireChannelRead(self.wrapInboundOut(byteBuffer))
 77 |     }
 78 |     
 79 |     public func errorCaught(context: ChannelHandlerContext, error: Error) {
 80 |         errorHandler?(error)
 81 |         context.close(promise: nil)
 82 |     }
 83 | }
 84 | 
 85 | final class StunInboundHandler: ChannelInboundHandler {
 86 |     public typealias InboundIn = StunMessage
 87 |     public typealias OutboundOut = AddressedEnvelope<ByteBuffer>
 88 |     public typealias ErrorHandler = ((Error) -> ())?
 89 |     
 90 |     private let errorHandler: ErrorHandler
 91 |     private let attributesHandler:  (StunMessage) -> ()
 92 |     
 93 |     init(errorHandler: ErrorHandler, attributesHandler: @escaping (StunMessage) -> ()) {
 94 |         self.errorHandler = errorHandler
 95 |         self.attributesHandler = attributesHandler
 96 |     }
 97 |     
 98 |     public func channelRead(context: ChannelHandlerContext, data: NIOAny) {
 99 |         attributesHandler(self.unwrapInboundIn(data))
100 |     }
101 |     
102 |     public func errorCaught(context: ChannelHandlerContext, error: Error) {
103 |         errorHandler?(error)
104 |         context.close(promise: nil)
105 |     }
106 | }
107 | 


--------------------------------------------------------------------------------
/.swiftpm/xcode/xcshareddata/xcschemes/Dribble-Package.xcscheme:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <Scheme
  3 |    LastUpgradeVersion = "1300"
  4 |    version = "1.3">
  5 |    <BuildAction
  6 |       parallelizeBuildables = "YES"
  7 |       buildImplicitDependencies = "YES">
  8 |       <BuildActionEntries>
  9 |          <BuildActionEntry
 10 |             buildForTesting = "YES"
 11 |             buildForRunning = "YES"
 12 |             buildForProfiling = "YES"
 13 |             buildForArchiving = "YES"
 14 |             buildForAnalyzing = "YES">
 15 |             <BuildableReference
 16 |                BuildableIdentifier = "primary"
 17 |                BlueprintIdentifier = "Dribble"
 18 |                BuildableName = "Dribble"
 19 |                BlueprintName = "Dribble"
 20 |                ReferencedContainer = "container:">
 21 |             </BuildableReference>
 22 |          </BuildActionEntry>
 23 |          <BuildActionEntry
 24 |             buildForTesting = "YES"
 25 |             buildForRunning = "YES"
 26 |             buildForProfiling = "YES"
 27 |             buildForArchiving = "YES"
 28 |             buildForAnalyzing = "YES">
 29 |             <BuildableReference
 30 |                BuildableIdentifier = "primary"
 31 |                BlueprintIdentifier = "CLIExample"
 32 |                BuildableName = "CLIExample"
 33 |                BlueprintName = "CLIExample"
 34 |                ReferencedContainer = "container:">
 35 |             </BuildableReference>
 36 |          </BuildActionEntry>
 37 |          <BuildActionEntry
 38 |             buildForTesting = "YES"
 39 |             buildForRunning = "YES"
 40 |             buildForProfiling = "NO"
 41 |             buildForArchiving = "NO"
 42 |             buildForAnalyzing = "YES">
 43 |             <BuildableReference
 44 |                BuildableIdentifier = "primary"
 45 |                BlueprintIdentifier = "DribbleTests"
 46 |                BuildableName = "DribbleTests"
 47 |                BlueprintName = "DribbleTests"
 48 |                ReferencedContainer = "container:">
 49 |             </BuildableReference>
 50 |          </BuildActionEntry>
 51 |       </BuildActionEntries>
 52 |    </BuildAction>
 53 |    <TestAction
 54 |       buildConfiguration = "Debug"
 55 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
 56 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
 57 |       shouldUseLaunchSchemeArgsEnv = "YES">
 58 |       <Testables>
 59 |          <TestableReference
 60 |             skipped = "NO">
 61 |             <BuildableReference
 62 |                BuildableIdentifier = "primary"
 63 |                BlueprintIdentifier = "DribbleTests"
 64 |                BuildableName = "DribbleTests"
 65 |                BlueprintName = "DribbleTests"
 66 |                ReferencedContainer = "container:">
 67 |             </BuildableReference>
 68 |          </TestableReference>
 69 |       </Testables>
 70 |    </TestAction>
 71 |    <LaunchAction
 72 |       buildConfiguration = "Debug"
 73 |       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
 74 |       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
 75 |       launchStyle = "0"
 76 |       useCustomWorkingDirectory = "NO"
 77 |       ignoresPersistentStateOnLaunch = "NO"
 78 |       debugDocumentVersioning = "YES"
 79 |       debugServiceExtension = "internal"
 80 |       allowLocationSimulation = "YES">
 81 |       <MacroExpansion>
 82 |          <BuildableReference
 83 |             BuildableIdentifier = "primary"
 84 |             BlueprintIdentifier = "CLIExample"
 85 |             BuildableName = "CLIExample"
 86 |             BlueprintName = "CLIExample"
 87 |             ReferencedContainer = "container:">
 88 |          </BuildableReference>
 89 |       </MacroExpansion>
 90 |    </LaunchAction>
 91 |    <ProfileAction
 92 |       buildConfiguration = "Release"
 93 |       shouldUseLaunchSchemeArgsEnv = "YES"
 94 |       savedToolIdentifier = ""
 95 |       useCustomWorkingDirectory = "NO"
 96 |       debugDocumentVersioning = "YES">
 97 |       <MacroExpansion>
 98 |          <BuildableReference
 99 |             BuildableIdentifier = "primary"
100 |             BlueprintIdentifier = "CLIExample"
101 |             BuildableName = "CLIExample"
102 |             BlueprintName = "CLIExample"
103 |             ReferencedContainer = "container:">
104 |          </BuildableReference>
105 |       </MacroExpansion>
106 |    </ProfileAction>
107 |    <AnalyzeAction
108 |       buildConfiguration = "Debug">
109 |    </AnalyzeAction>
110 |    <ArchiveAction
111 |       buildConfiguration = "Release"
112 |       revealArchiveInOrganizer = "YES">
113 |    </ArchiveAction>
114 | </Scheme>
115 | 


--------------------------------------------------------------------------------
/Sources/Dribble/TurnAllocation.swift:
--------------------------------------------------------------------------------
  1 | import NIO
  2 | 
  3 | public struct TurnAllocation {
  4 |     public let ourAddress: SocketAddress
  5 |     internal let client: TurnClient
  6 |     
  7 |     public func createChannel(for theirAddress: SocketAddress) async throws -> Channel {
  8 |         let transactionId = StunTransactionId()
  9 |         var xorPeerAddress = ByteBuffer()
 10 |         xorPeerAddress.writeSocketAddress(theirAddress, xor: true)
 11 |         let response = try await client.sendMessage(
 12 |             StunMessage(
 13 |                 type: .createPermission,
 14 |                 transactionId: transactionId,
 15 |                 attributes: [
 16 |                     .init(
 17 |                         type: .xorPeerAddress,
 18 |                         value: xorPeerAddress
 19 |                     )
 20 |                 ]
 21 |             )
 22 |         )
 23 |         
 24 |         guard response.header.type == .createPermissionSuccess else {
 25 |             throw TurnClientError.createPermissionFailure
 26 |         }
 27 |         
 28 |         let channel = TurnAllocationChannel(
 29 |             client: client,
 30 |             allocationAddress: theirAddress
 31 |         )
 32 |         
 33 |         try await client.sender.registerTurnAllocationChannel(channel, theirAddress: theirAddress)
 34 |         
 35 |         return channel
 36 |     }
 37 | }
 38 | 
 39 | final class TurnAllocationChannel: Channel, ChannelCore {
 40 |     internal let client: TurnClient
 41 |     internal let allocationAddress: SocketAddress
 42 |     public let allocator: ByteBufferAllocator
 43 |     private var _pipeline: ChannelPipeline!
 44 |     
 45 |     init(client: TurnClient, allocationAddress: SocketAddress) {
 46 |         self.client = client
 47 |         self.allocationAddress = allocationAddress
 48 |         self.allocator = client.channel.allocator
 49 |         self._pipeline = ChannelPipeline(channel: self)
 50 |     }
 51 |     
 52 |     public var closeFuture: EventLoopFuture<Void> {
 53 |         client.channel.closeFuture
 54 |     }
 55 |     
 56 |     public var pipeline: ChannelPipeline {
 57 |         _pipeline
 58 |     }
 59 |     
 60 |     public var localAddress: SocketAddress? { parent?.localAddress }
 61 |     public var remoteAddress: SocketAddress? { parent?.remoteAddress }
 62 |     
 63 |     public var parent: Channel? {
 64 |         client.channel
 65 |     }
 66 |     
 67 |     public let isWritable = true
 68 |     public let isActive = true
 69 |     
 70 |     public var _channelCore: ChannelCore { self }
 71 |     
 72 |     public func localAddress0() throws -> SocketAddress {
 73 |         try client.channel._channelCore.localAddress0()
 74 |     }
 75 |     
 76 |     public func remoteAddress0() throws -> SocketAddress {
 77 |         try client.channel._channelCore.remoteAddress0()
 78 |     }
 79 |     
 80 |     public func setOption<Option>(_ option: Option, value: Option.Value) -> EventLoopFuture<Void> where Option : ChannelOption {
 81 |         fatalError("Setting option \(option) on TurnAllocationChannel is not supported")
 82 |     }
 83 |     
 84 |     func getOption<Option>(_ option: Option) -> EventLoopFuture<Option.Value> where Option : ChannelOption {
 85 |         fatalError("Getting option \(option) on TurnAllocationChannel is not supported")
 86 |     }
 87 |     
 88 |     public func register0(promise: EventLoopPromise<Void>?) {
 89 |         fatalError("not implemented \(#function)")
 90 |     }
 91 |     
 92 |     public func bind0(to: SocketAddress, promise: EventLoopPromise<Void>?) {
 93 |         fatalError("not implemented \(#function)")
 94 |     }
 95 |     
 96 |     public func connect0(to: SocketAddress, promise: EventLoopPromise<Void>?) {
 97 |         fatalError("not implemented \(#function)")
 98 |     }
 99 |     
100 |     public func write0(_ data: NIOAny, promise: EventLoopPromise<Void>?) {
101 |         @Sendable func run() async throws {
102 |             var peerAddress = ByteBuffer()
103 |             peerAddress.writeSocketAddress(self.allocationAddress, xor: true)
104 |             
105 |             _ = try await client.sendMessage(
106 |                 StunMessage(
107 |                     type: .sendIndication,
108 |                     attributes: [
109 |                         StunAttribute(
110 |                             type: .xorPeerAddress,
111 |                             value: peerAddress
112 |                         ),
113 |                         StunAttribute(
114 |                             type: .data,
115 |                             value: unwrapData(data)
116 |                         )
117 |                     ]
118 |                 )
119 |             )
120 |         }
121 |         
122 |         if let promise = promise {
123 |             promise.completeWithTask {
124 |                 try await run()
125 |             }
126 |         } else {
127 |             Task.detached {
128 |                 try await run()
129 |             }
130 |         }
131 |     }
132 |     
133 |     public func flush0() {
134 |         // TODO: Packets are always flushed
135 |     }
136 |     
137 |     public func read0() {
138 |         client.channel.read()
139 |     }
140 |     
141 |     public func close0(error: Error, mode: CloseMode, promise: EventLoopPromise<Void>?) {
142 |         fatalError()
143 |     }
144 |     
145 |     public func triggerUserOutboundEvent0(_ event: Any, promise: EventLoopPromise<Void>?) {
146 |         promise?.fail(TurnChannelError.operationUnsupported)
147 |     }
148 |     
149 |     public func channelRead0(_ data: NIOAny) {
150 |         // Do nothing
151 |     }
152 |     
153 |     public func errorCaught0(error: Error) {
154 |         // No handling needed
155 |     }
156 |     
157 |     public var eventLoop: EventLoop { client.channel.eventLoop }
158 | }
159 | 


--------------------------------------------------------------------------------
/Sources/Dribble/STUN.swift:
--------------------------------------------------------------------------------
  1 | import Crypto
  2 | import NIO
  3 | import NIOFoundationCompat
  4 | 
  5 | enum StunError: Error {
  6 |     case invalidAttributeFormat, invalidPacket, unsupported, invalidResponse, unknownAttribute
  7 | }
  8 | 
  9 | public enum StunMessageType: UInt16 {
 10 |     // STUN Spec
 11 |     case bindingRequest = 0x0001
 12 |     case bindingResponse = 0x0101
 13 |     case bindingErrorResponse = 0x0111
 14 |     case sharedSecretRequest = 0x0002
 15 |     case sharedSecretResponse = 0x0102
 16 |     case sharedSecretErrorResponse = 0x0112
 17 |     
 18 |     // TURN Spec
 19 |     case allocateRequest = 0x003
 20 |     case allocateResponse = 0x103
 21 |     case send = 0x006
 22 |     case sendIndication = 0x016
 23 |     case dataRequest = 0x007
 24 |     case dataIndication = 0x017
 25 |     
 26 |     case createPermission = 0x008
 27 |     case createPermissionSuccess = 0x108
 28 |     
 29 |     case channelBind = 0x009
 30 |     case channelBindSuccess = 0x109
 31 | }
 32 | 
 33 | public struct StunParser: ByteToMessageDecoder {
 34 |     public typealias InboundOut = StunMessage
 35 |     
 36 |     public init() {}
 37 |     
 38 |     public func decode(context: ChannelHandlerContext, buffer: inout ByteBuffer) throws -> DecodingState {
 39 |         guard
 40 |             buffer.readableBytes >= 20,
 41 |             let length: UInt16 = buffer.getInteger(at: 2),
 42 |             buffer.readableBytes >= 20 + Int(length)
 43 |         else {
 44 |             return .needMoreData
 45 |         }
 46 |         
 47 |         let endIndex = buffer.readerIndex + 20 + Int(length)
 48 |         
 49 |         guard
 50 |             let _type: UInt16 = buffer.readInteger(),
 51 |             let type = StunMessageType(rawValue: _type)
 52 |         else {
 53 |             throw StunError.invalidPacket
 54 |         }
 55 |         
 56 |         buffer.moveReaderIndex(forwardBy: 2)
 57 |         
 58 |         guard
 59 |             buffer.readInteger() == StunMessageHeader.cookie,
 60 |             let transactionId = buffer.readBytes(length: 12)
 61 |         else {
 62 |             throw StunError.invalidPacket
 63 |         }
 64 |         
 65 |         var attributes = [StunAttribute]()
 66 |         while buffer.readableBytes > 0 && buffer.readerIndex <= endIndex {
 67 |             guard
 68 |                 let type: UInt16 = buffer.readInteger(),
 69 |                 let bodyLength: UInt16 = buffer.readInteger(),
 70 |                 let body = buffer.readSlice(length: Int(bodyLength))
 71 |             else {
 72 |                 throw StunError.invalidPacket
 73 |             }
 74 |             
 75 |             let paddingLength = (4 - (Int(bodyLength) % 4)) % 4
 76 |             
 77 |             if buffer.readableBytes < paddingLength {
 78 |                 throw StunError.invalidPacket
 79 |             }
 80 |             
 81 |             buffer.moveReaderIndex(forwardBy: paddingLength)
 82 |             
 83 |             attributes.append(StunAttribute(type: type, value: body))
 84 |         }
 85 |         
 86 |         guard buffer.readerIndex == endIndex else {
 87 |             throw StunError.invalidPacket
 88 |         }
 89 |         
 90 |         let packet = StunMessage(
 91 |             type: type,
 92 |             transactionId: StunTransactionId(bytes: transactionId),
 93 |             attributes: attributes
 94 |         )
 95 |         
 96 |         context.fireChannelRead(wrapInboundOut(packet))
 97 |         return .continue
 98 |     }
 99 |     
100 |     public func decodeLast(context: ChannelHandlerContext, buffer: inout ByteBuffer, seenEOF: Bool) throws -> DecodingState {
101 |         return try decode(context: context, buffer: &buffer)
102 |     }
103 | }
104 | 
105 | public struct StunTransactionId: Hashable {
106 |     internal var bytes: [UInt8]
107 |     
108 |     init(bytes: [UInt8]) {
109 |         assert(bytes.count == 12)
110 |         self.bytes = bytes
111 |     }
112 |     
113 |     public init() {
114 |         self.bytes = .init(unsafeUninitializedCapacity: 12, initializingWith: { buffer, initializedCount in
115 |             for i in 0..<12 {
116 |                 buffer[i] = .random(in: .min ..< .max)
117 |             }
118 |             
119 |             initializedCount = 12
120 |         })
121 |     }
122 | }
123 | 
124 | public struct StunMessageHeader {
125 |     static let cookieArray: [UInt8] = [0x21, 0x12, 0xA4, 0x42]
126 |     static let cookieHighBits: UInt16 = 0x2112
127 |     static let cookie: UInt32 = 0x2112A442
128 |     
129 |     public let type: StunMessageType
130 |     
131 |     /// Length of the body, not including this 20 byte header
132 |     var length: UInt16
133 |     
134 |     var cookie: UInt32 { Self.cookie }
135 |     public let transactionId: StunTransactionId
136 | }
137 | 
138 | public enum StunAttributeType: UInt16 {
139 |     // STUN spec
140 |     case mappedAddress = 0x0001
141 |     case username = 0x0006
142 |     case messageIntegrity = 0x0008
143 |     case errorCode = 0x0009
144 |     case unknown = 0x000a
145 |     case realm = 0x0014
146 |     case nonce = 0x0015
147 |     case xorMappedAddress = 0x0020
148 |     case software = 0x8022
149 |     case alternateServer = 0x8023
150 |     case fingerprint = 0x8028
151 |     
152 |     // TURN spec
153 |     case channelNumber = 0x000C
154 |     case lifetime = 0x000D
155 |     case xorPeerAddress = 0x0012
156 |     case data = 0x0013
157 |     case xorRelayedAddress = 0x0016
158 |     case requestedAddressFamily = 0x0017
159 |     case evenPort = 0x0018
160 |     case requestedTransport = 0x0019
161 |     case dontFragment = 0x001A
162 |     case reservationToken = 0x0022
163 |     case additionalAddressFamily = 0x8000
164 |     case addressErrorCode = 0x8001
165 |     case icmp = 0x8004
166 | }
167 | 
168 | public enum AddressFamily: UInt8 {
169 |     case ipv4 = 0x01
170 |     case ipv6 = 0x02
171 | }
172 | 
173 | public enum ResolvedStunAttribute {
174 |     // 0                   1                   2                   3
175 |     // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
176 |     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
177 |     // |0 0 0 0 0 0 0 0|    Family     |           Port                |
178 |     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
179 |     // |                                                               |
180 |     // |                 Address (32 bits or 128 bits)                 |
181 |     // |                                                               |
182 |     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
183 |     
184 |     /// The above graph applies here
185 |     case mappedAddress(SocketAddress)
186 |     
187 |     // MUST be the same IP address family I.E. ipv4/ipv6
188 |     case alternateServer(SocketAddress)
189 |     
190 |     /// The same graph, but now we XOR it with the magic cookie
191 |     /// Port is XOR-ed with the two highest bits of the magic cookie
192 |     /// IPv4 is xor-ed byte-for-byte from front to back
193 |     /// IPv6 is xor-ed with the concatenation of the cookie + transaction ID in network byte order
194 |     case xorMappedAddress(SocketAddress)
195 |     case xorPeerAddress(SocketAddress)
196 |     case xorRelayedAddress(SocketAddress)
197 |     
198 |     /// UTF-8 encoded string less than 513 bytes & SASLprepped
199 |     /// https://datatracker.ietf.org/doc/html/rfc4013
200 |     case username(String)
201 |     
202 |     /// Max 128 characters, 763 bytes
203 |     case realm(String)
204 |     
205 |     /// Max 128 characters, 763 bytes
206 |     case nonce(String)
207 |     
208 |     /// Max 128 characters, 763 bytes
209 |     case software(String)
210 |     
211 |     case messageIntegrity([UInt8])
212 |     
213 |     // - MARK: TURN
214 |     
215 |     case channelNumber(ChannelNumber)
216 |     
217 |     /// Allocation lifetime if not refreshed, in seconds
218 |     case lifetime(UInt32)
219 |     
220 |     case icmp
221 |     case data(ByteBuffer)
222 |     case requestedAddressFamily(AddressFamily)
223 |     case evenPort(Bool)
224 |     case dontFragment
225 |     
226 |     public init(
227 |         type: StunAttributeType,
228 |         transactionId: StunTransactionId,
229 |         buffer: inout ByteBuffer
230 |     ) throws {
231 |         func parseXorAddress() throws -> SocketAddress {
232 |             guard
233 |                 buffer.readInteger(as: UInt8.self) == 0,
234 |                 let familyType: UInt8 = buffer.readInteger(),
235 |                 let family = AddressFamily(rawValue: familyType),
236 |                 var port: UInt16 = buffer.readInteger(),
237 |                 buffer.readableBytes == (family == .ipv4 ? 4 : 16)
238 |             else {
239 |                 throw StunError.invalidAttributeFormat
240 |             }
241 |             
242 |             port ^= StunMessageHeader.cookieHighBits
243 |             let addressBuffer: ByteBuffer
244 |             
245 |             switch family {
246 |             case .ipv4:
247 |                 guard var address: UInt32 = buffer.readInteger() else {
248 |                     throw StunError.invalidAttributeFormat
249 |                 }
250 |                 
251 |                 address ^= StunMessageHeader.cookie
252 |                 addressBuffer = ByteBuffer(integer: address)
253 |             case .ipv6:
254 |                 guard var address = buffer.readBytes(length: 16) else {
255 |                     throw StunError.invalidAttributeFormat
256 |                 }
257 |                 
258 |                 for i in 0..<4 {
259 |                     address[i] ^= StunMessageHeader.cookieArray[i]
260 |                 }
261 |                 
262 |                 for i in 4..<16 {
263 |                     address[i] ^= transactionId.bytes[i - 4]
264 |                 }
265 |                 
266 |                 addressBuffer = ByteBuffer(bytes: address)
267 |             }
268 |             
269 |             return try SocketAddress(
270 |                 packedIPAddress: addressBuffer,
271 |                 port: Int(port)
272 |             )
273 |         }
274 |         
275 |         func parseAddress() throws -> SocketAddress {
276 |             guard
277 |                 buffer.readInteger(as: UInt8.self) == 0,
278 |                 let familyType: UInt8 = buffer.readInteger(),
279 |                 let family = AddressFamily(rawValue: familyType),
280 |                 let port: UInt16 = buffer.readInteger(),
281 |                 buffer.readableBytes == (family == .ipv4 ? 4 : 16)
282 |             else {
283 |                 throw StunError.invalidAttributeFormat
284 |             }
285 |             
286 |             return try SocketAddress(
287 |                 packedIPAddress: buffer,
288 |                 port: Int(port)
289 |             )
290 |         }
291 |         
292 |         switch type {
293 |         case .mappedAddress:
294 |             self = try .mappedAddress(parseAddress())
295 |         case .xorMappedAddress:
296 |             self = try .mappedAddress(parseXorAddress())
297 |         case .username:
298 |             throw StunError.unsupported
299 |         case .messageIntegrity:
300 |             guard let sha1Hash = buffer.readBytes(length: 20) else {
301 |                 throw StunError.invalidAttributeFormat
302 |             }
303 |             
304 |             self = .messageIntegrity(sha1Hash)
305 |         case .errorCode:
306 |             throw StunError.unsupported
307 |         case .unknown:
308 |             // Only present in errors with code 420
309 |             throw StunError.unsupported
310 |         case .realm:
311 |             guard
312 |                 buffer.readableBytes <= 763,
313 |                 let realm = buffer.readString(length: buffer.readableBytes),
314 |                 realm.count <= 128
315 |             else {
316 |                 throw StunError.invalidAttributeFormat
317 |             }
318 |             
319 |             self = .realm(realm)
320 |         case .nonce:
321 |             guard
322 |                 buffer.readableBytes <= 763,
323 |                 let nonce = buffer.readString(length: buffer.readableBytes),
324 |                 nonce.count <= 128
325 |             else {
326 |                 throw StunError.invalidAttributeFormat
327 |             }
328 |             
329 |             self = .nonce(nonce)
330 |         case .software:
331 |             guard
332 |                 buffer.readableBytes <= 763,
333 |                 let software = buffer.readString(length: buffer.readableBytes),
334 |                 software.count <= 128
335 |             else {
336 |                 throw StunError.invalidAttributeFormat
337 |             }
338 |             
339 |             self = .software(software)
340 |         case .alternateServer:
341 |             // MUST be the same IP address family I.E. ipv4/ipv6
342 |             self = try .alternateServer(parseAddress())
343 |         case .fingerprint:
344 |             throw StunError.unsupported
345 |         case .channelNumber:
346 |             guard
347 |                 let channelNumber: UInt16 = buffer.readInteger(),
348 |                 buffer.readInteger(as: UInt16.self) == 0
349 |             else {
350 |                 throw StunError.invalidAttributeFormat
351 |             }
352 |             
353 |             self = .channelNumber(ChannelNumber(rawValue: channelNumber))
354 |         case .lifetime:
355 |             guard let lifetime: UInt32 = buffer.readInteger() else {
356 |                 throw StunError.invalidAttributeFormat
357 |             }
358 |             
359 |             self = .lifetime(lifetime)
360 |         case .xorPeerAddress:
361 |             self = try .xorPeerAddress(parseXorAddress())
362 |         case .data:
363 |             self = .data(buffer.readSlice(length: buffer.readableBytes)!)
364 |         case .xorRelayedAddress:
365 |             self = try .xorRelayedAddress(parseXorAddress())
366 |         case .requestedAddressFamily:
367 |             guard
368 |                 let _family: UInt8 = buffer.readInteger(),
369 |                 let family = AddressFamily(rawValue: _family),
370 |                 buffer.readInteger(as: UInt8.self) == 0,
371 |                 buffer.readInteger(as: UInt8.self) == 0,
372 |                 buffer.readInteger(as: UInt8.self) == 0
373 |             else {
374 |                 throw StunError.invalidAttributeFormat
375 |             }
376 |             
377 |             self = .requestedAddressFamily(family)
378 |         case .evenPort:
379 |             guard let _evenPort: UInt8 = buffer.readInteger() else {
380 |                 throw StunError.invalidAttributeFormat
381 |             }
382 |             
383 |             self = .evenPort(_evenPort & 0b1 == 0b1)
384 |         case .requestedTransport:
385 |             throw StunError.unsupported
386 |         case .dontFragment:
387 |             self = .dontFragment
388 |         case .reservationToken:
389 |             throw StunError.unsupported
390 |         case .additionalAddressFamily:
391 |             throw StunError.unsupported
392 |         case .addressErrorCode:
393 |             throw StunError.unsupported
394 |         case .icmp:
395 |             throw StunError.unsupported
396 |         }
397 |     }
398 | }
399 | 
400 | public struct StunAttribute {
401 |     public let type: UInt16
402 |     var stunType: StunAttributeType? {
403 |         StunAttributeType(rawValue: type)
404 |     }
405 |     var length: UInt16 {
406 |         UInt16(value.readableBytes)
407 |     }
408 |     public internal(set) var value: ByteBuffer
409 |     
410 |     init(
411 |         type: UInt16,
412 |         value: ByteBuffer
413 |     ) {
414 |         self.type = type
415 |         self.value = value
416 |     }
417 |     
418 |     init(
419 |         type: StunAttributeType,
420 |         value: ByteBuffer
421 |     ) {
422 |         self.type = type.rawValue
423 |         self.value = value
424 |     }
425 |     
426 |     func resolve(forTransaction transactionId: StunTransactionId) throws -> ResolvedStunAttribute {
427 |         guard let type = StunAttributeType(rawValue: type) else {
428 |             // Unknown type
429 |             throw StunError.unknownAttribute
430 |         }
431 |         
432 |         var value = value
433 |         
434 |         return try ResolvedStunAttribute(
435 |             type: type,
436 |             transactionId: transactionId,
437 |             buffer: &value
438 |         )
439 |     }
440 | }
441 | 
442 | public struct StunMessage {
443 |     public internal(set) var header: StunMessageHeader
444 |     public internal(set) var attributes: [StunAttribute]
445 |     var body: ByteBuffer
446 |     private var providesIntegrity = false
447 |     
448 |     // TODO: Fingerprint?
449 |     private mutating func provideSHA1Integrity(with hmac: inout HMAC<Insecure.SHA1>) {
450 |         assert(!providesIntegrity)
451 |         providesIntegrity = true
452 |         
453 |         // Update the header length, that's needed for the integrity hashing
454 |         // 4 byte attribute header, 20 byte hash length
455 |         self.header.length += 24
456 |         
457 |         // Write the body except the new attribute
458 |         // This needs to be hashed
459 |         // That includes the length of the integrity attribute
460 |         var newBody = ByteBuffer()
461 |         newBody.writeStunMessage(self)
462 |         
463 |         // Create the hash
464 |         hmac.update(data: newBody.readableBytesView)
465 |         let hash = hmac.finalize()
466 |         
467 |         // The attribute to be added
468 |         let attribute = StunAttribute(
469 |             type: .messageIntegrity,
470 |             value: ByteBuffer(bytes: hash)
471 |         )
472 |         
473 |         // Add the attribute to the body & attributes list
474 |         attributes.append(attribute)
475 |         newBody.writeAttribute(attribute)
476 |         
477 |         // Set the new body, header was already updated
478 |         self.body = newBody
479 |     }
480 |     
481 |     public mutating func provideSHA1Integrity(
482 |         username: String,
483 |         realm: String,
484 |         password: String
485 |     ) {
486 |         let credentials = Insecure.MD5.hash(
487 |             data: "\(username):\(realm):\(password)".data(using: .utf8)!
488 |         )
489 |         
490 |         var hmac = HMAC<Insecure.SHA1>(
491 |             key: SymmetricKey(data: credentials)
492 |         )
493 |         
494 |         provideSHA1Integrity(with: &hmac)
495 |     }
496 |     
497 |     public mutating func provideSHA1Integrity(
498 |         username: String,
499 |         password: String
500 |     ) {
501 |         var hmac = HMAC<Insecure.SHA1>(
502 |             key: SymmetricKey(data: password.data(using: .utf8)!)
503 |         )
504 |         
505 |         provideSHA1Integrity(with: &hmac)
506 |     }
507 | 
508 |     init(
509 |         type: StunMessageType,
510 |         transactionId: StunTransactionId = .init(),
511 |         attributes: [StunAttribute]
512 |     ) {
513 |         self.attributes = attributes
514 |         
515 |         var buffer = ByteBuffer()
516 |         
517 |         for attribute in attributes {
518 |             buffer.writeAttribute(attribute)
519 |         }
520 |         
521 |         self.body = buffer
522 |         self.header = StunMessageHeader(
523 |             type: type,
524 |             length: UInt16(buffer.readableBytes),
525 |             transactionId: transactionId
526 |         )
527 |     }
528 |     
529 |     public static func bindingRequest(with family: AddressFamily) -> StunMessage {
530 |         return StunMessage(
531 |             type: .bindingRequest,
532 |             attributes: []
533 |         )
534 |     }
535 |     
536 |     public static func allocationRequest() -> StunMessage {
537 |         return StunMessage(
538 |             type: .allocateRequest,
539 |             attributes: [
540 |                 // 17 is UDP
541 |                 .init(type: .requestedTransport, value: ByteBuffer(bytes: [17, 0, 0, 0]))
542 |             ]
543 |         )
544 |     }
545 | }
546 | 
547 | // TODO: Retransmit over UDP
548 | 
549 | extension ByteBuffer {
550 |     mutating func writeAttribute(_ attribute: StunAttribute) {
551 |         writeInteger(attribute.type)
552 |         writeInteger(attribute.length)
553 |         writeImmutableBuffer(attribute.value)
554 |     }
555 |     
556 |     mutating func writeSocketAddress(_ address: SocketAddress, xor: Bool) {
557 |         writeInteger(0x00 as UInt8)
558 |         
559 |         switch address {
560 |         case .v4(let iPv4Address):
561 |             writeInteger(AddressFamily.ipv4.rawValue)
562 |             var xorPort = iPv4Address.address.sin_port.bigEndian
563 |             xorPort ^= StunMessageHeader.cookieHighBits
564 |             writeInteger(xorPort)
565 |             
566 |             var address = iPv4Address.address.sin_addr.s_addr.bigEndian
567 |             address ^= StunMessageHeader.cookie
568 |             writeInteger(address)
569 |         case .v6(let iPv6Address):
570 |             writeInteger(AddressFamily.ipv6.rawValue)
571 |             let port = iPv6Address.address.sin6_port ^ StunMessageHeader.cookieHighBits
572 |             writeInteger(port)
573 |             
574 |             withUnsafeBytes(of: iPv6Address.address.sin6_addr) { buffer in
575 |                 let buffer = buffer.bindMemory(to: UInt32.self)
576 |                 assert(buffer.count == 4)
577 |                 
578 |                 for i in 0..<4 {
579 |                     self.writeInteger(buffer[i], endianness: .little)
580 |                 }
581 |             }
582 |         case .unixDomainSocket:
583 |             fatalError("Unsupported SocketAddress")
584 |         }
585 |     }
586 |     
587 |     mutating func writeStunMessage(_ message: StunMessage) {
588 |         reserveCapacity(writerIndex + 20 + message.body.readableBytes)
589 |         writeInteger(message.header.type.rawValue)
590 |         writeInteger(message.header.length)
591 |         writeInteger(message.header.cookie)
592 |         writeBytes(message.header.transactionId.bytes)
593 |         writeImmutableBuffer(message.body)
594 |         
595 |         let padding = (4 - (message.body.readableBytes % 4)) % 4
596 |         writeBytes([UInt8](repeating: 0x00, count: padding))
597 |     }
598 | }
599 | 


--------------------------------------------------------------------------------