Implement prototype onion request API

SignalServiceKit/src/Loki/API/LokiAPI+SwarmAPI.swift

@@ -24,7 +24,7 @@ public extension LokiAPI {
     
     // MARK: Clearnet Setup
     fileprivate static let seedNodePool: Set<String> = [ "http://storage.seed1.loki.network:22023", "http://storage.seed2.loki.network:38157", "http://149.56.148.124:38157" ]
-    fileprivate static var randomSnodePool: Set<LokiAPITarget> = []
+    internal static var randomSnodePool: Set<LokiAPITarget> = []
 
     @objc public static func clearRandomSnodePool() {
         randomSnodePool.removeAll()

SignalServiceKit/src/Loki/API/OnionRequestAPI.swift

@@ -0,0 +1,109 @@
+import PromiseKit
+
+// TODO: Threading
+
+internal enum OnionRequestAPI {
+    internal static var guardSnodes: Set<LokiAPITarget> = []
+    internal static var paths: Set<Path> = []
+
+    private static let pathCount: UInt = 3
+    /// The number of snodes (including the guard snode) in a path.
+    private static let pathSize: UInt = 3
+    private static let guardSnodeCount: UInt = 3
+
+    internal enum Error : LocalizedError {
+        case insufficientSnodes
+
+        var errorDescription: String? {
+            switch self {
+            case .insufficientSnodes: return "Couldn't find enough snodes to build a path."
+            }
+        }
+    }
+
+    internal typealias Path = OnionRequestPath
+
+    // MARK: Private API
+    /// Tests the given guard snode candidate. The returned promise errors out if the snode is faulty; the promise is fulfilled otherwise.
+    private static func testGuardSnodeCandidate(_ candidate: LokiAPITarget) -> Promise<Void> {
+        print("[Loki] Testing candidate guard snode: \(candidate).")
+        let hexEncodedPublicKey = getUserHexEncodedPublicKey()
+        let parameters: JSON = [ "pubKey" : hexEncodedPublicKey ]
+        let timeout: TimeInterval = 10 // Use a shorter timeout for testing
+        return LokiAPI.invoke(.getSwarm, on: candidate, associatedWith: hexEncodedPublicKey, parameters: parameters, timeout: timeout).map { _ in }
+    }
+
+    /// Finds `guardSnodeCount` reliable guard snodes to use for path building. The returned promise may error out with `Error.insufficientSnodes`
+    /// if not enough (reliable) snodes are available.
+    private static func getGuardSnodes() -> Promise<Set<LokiAPITarget>> {
+        if !guardSnodes.isEmpty {
+            return Promise<Set<LokiAPITarget>> { $0.fulfill(guardSnodes) }
+        } else {
+            print("[Loki] Populating guard snode cache.")
+            return LokiAPI.getRandomSnode().then { _ -> Promise<Set<LokiAPITarget>> in // Just used to populate the snode pool
+                let snodePool = LokiAPI.randomSnodePool
+                guard !snodePool.isEmpty else { throw Error.insufficientSnodes }
+                var result: Set<LokiAPITarget> = [] // TODO: Sync on DispatchQueue.global()
+                // Loops until a valid guard snode is found
+                func getGuardSnode() -> Promise<LokiAPITarget> {
+                    // randomElement() uses the system's default random generator, which is cryptographically secure
+                    guard let candidate = snodePool.randomElement() else { return Promise<LokiAPITarget> { $0.reject(Error.insufficientSnodes) } }
+                    return testGuardSnodeCandidate(candidate).map { candidate }.recover { _ in getGuardSnode() }
+                }
+                func getAndStoreGuardSnode() -> Promise<LokiAPITarget> {
+                    return getGuardSnode().then { guardSnode -> Promise<LokiAPITarget> in
+                        if !result.contains(guardSnode) {
+                            result.insert(guardSnode)
+                            return Promise { $0.fulfill(guardSnode) }
+                        } else {
+                            return getAndStoreGuardSnode()
+                        }
+                    }
+                }
+                let promises = (0..<guardSnodeCount).map { _ in getAndStoreGuardSnode() }
+                return when(fulfilled: promises).map { guardSnodes in
+                    let guardSnodesAsSet = Set(guardSnodes)
+                    OnionRequestAPI.guardSnodes = guardSnodesAsSet
+                    return guardSnodesAsSet
+                }
+            }
+        }
+    }
+
+    /// Builds and returns `pathCount` paths. The returned promise may error out with `Error.insufficientSnodes`
+    /// if not enough (reliable) snodes are available.
+    private static func buildPaths() -> Promise<Set<Path>> {
+        print("[Loki] Building onion request paths.")
+        return LokiAPI.getRandomSnode().then { _ -> Promise<Set<Path>> in // Just used to populate the snode pool
+            let snodePool = LokiAPI.randomSnodePool
+            return getGuardSnodes().map { guardSnodes in
+                var unusedSnodes = snodePool.subtracting(guardSnodes)
+                let minSnodeCount = guardSnodeCount * pathSize - guardSnodeCount
+                guard unusedSnodes.count >= minSnodeCount else { throw Error.insufficientSnodes }
+                let result = Set(guardSnodes.map { guardSnode -> Path in
+                    // The force unwraps are safe because of the minSnodeCount check above
+                    let snode1 = unusedSnodes.randomElement()!
+                    let snode2 = unusedSnodes.randomElement()!
+                    return Path(guardSnode: guardSnode, snode1: snode1, snode2: snode2)
+                })
+                print("[Loki] Built new onion request paths: \(result.map { "\($0.description)" }.joined(separator: ", "))")
+                return result
+            }
+        }
+    }
+
+    // MARK: Internal API
+    /// Returns an `OnionRequestPath` to be used for onion requests. Builds new paths if needed.
+    internal static func getPath() -> Promise<Path> {
+        // randomElement() uses the system's default random generator, which is cryptographically secure
+        if paths.count >= pathCount {
+            return Promise<Path> { $0.fulfill(paths.randomElement()!) }
+        } else {
+            return buildPaths().map { paths in
+                let path = paths.randomElement()!
+                OnionRequestAPI.paths = paths
+                return path
+            }
+        }
+    }
+}

SignalServiceKit/src/Loki/API/OnionRequestPath.swift

@@ -0,0 +1,12 @@
+
+/// A path used for making onion requests. See the "Onion Requests" section of
+/// [The Session Whitepaper](https://arxiv.org/pdf/2002.04609.pdf) for more information.
+struct OnionRequestPath : Hashable, CustomStringConvertible {
+    let guardSnode: LokiAPITarget
+    let snode1: LokiAPITarget
+    let snode2: LokiAPITarget
+
+    var description: String {
+        return "\(guardSnode)-\(snode1)-\(snode2)"
+    }
+}