flamenet-messenger-ios/Sources/E2E/AnonymousRelayClient.swift

import CryptoKit
import Foundation

/// Section 8.13, stage D2: reads about OTHER people that name nobody.
///
/// Every read here is a POST with its target in the body, never in the URL,
/// so the target is in no proxy's access log; and it goes out on its own
/// HTTP client: no `Authorization` header, no cookies, no cache, its own
/// connection pool, a generic User-Agent. A connection that carried an
/// authenticated request never carries one of these.
///
/// What the relay still sees, and the app says so where it matters: the IP
/// address, which is usually the one this device polls from seconds apart.
/// What changes is what is stored.
final class AnonymousRelayClient {

    private let base: URL
    /// Follows the bridge setting (`BridgedSession`).
    private let sessions: BridgedSession
    var session: URLSession { sessions.session }

    /// - Parameter base: the relay's `…/flamenet/v1` root.
    init(base: URL, protocolClasses: [AnyClass]? = nil) {
        self.base = base
        let cfg = URLSessionConfiguration.ephemeral
        cfg.httpCookieStorage = nil
        cfg.httpShouldSetCookies = false
        cfg.httpCookieAcceptPolicy = .never
        cfg.urlCache = nil
        cfg.urlCredentialStorage = nil
        cfg.requestCachePolicy = .reloadIgnoringLocalCacheData
        cfg.timeoutIntervalForRequest = 25
        cfg.timeoutIntervalForResource = 120
        cfg.httpAdditionalHeaders = ["User-Agent": "FlameNet"]
        if let protocolClasses { cfg.protocolClasses = protocolClasses }
        self.sessions = BridgedSession { cfg.copy() as! URLSessionConfiguration }
    }

    /// The most tokens one presence request may carry (decision DD3).
    static let presenceBatch = 8

    /// Presence for up to eight tokens, keyed by token.
    func presence(tokens: [String]) async throws -> [String: String] {
        precondition(tokens.count <= Self.presenceBatch)
        struct Row: Decodable {
            let token: String
            let presence: String
        }
        struct Answer: Decodable { let presence: [Row] }
        let answer: Answer = try await post("/e2e/anon/presence", ["tokens": tokens])
        return Dictionary(
            answer.presence.map { ($0.token, $0.presence) }, uniquingKeysWith: { a, _ in a })
    }

    /// Identity keys for an account, no times. `cap` is a presence token the
    /// account issued this one, which the relay meters by instead of the IP.
    func devices(of userID: Int, cap: String?) async throws -> E2EDevicesResponse {
        var body: [String: Any] = ["user_id": userID]
        if let cap { body["cap"] = cap }
        return try await post("/e2e/anon/devices", body)
    }

    /// Prekey bundles for an account, popping one prekey per device.
    func bundles(of userID: Int, cap: String?) async throws -> E2EKeysResponse {
        var body: [String: Any] = ["user_id": userID]
        if let cap { body["cap"] = cap }
        return try await post("/e2e/anon/bundles", body)
    }

    func introChallenge() async throws -> E2EIntroChallenge {
        var req = URLRequest(url: base.appendingPathComponent("/e2e/intro/challenge"))
        req.httpMethod = "GET"
        req.setValue("application/json", forHTTPHeaderField: "Accept")
        return try await perform(req)
    }

    /// An introduction by handle (after the proof of work) or by a reusable
    /// link (section 14.5). Nil when the relay answers "no such account",
    /// which is also its answer for an unlisted handle and a revoked link.
    func intro(handle: String, challenge: String, nonce: String) async throws -> E2EIntroAnswer? {
        try await intro(["handle": handle, "challenge": challenge, "nonce": nonce])
    }

    func intro(link: Data) async throws -> E2EIntroAnswer? {
        try await intro(["link": Base64URL.encode(link)])
    }

    private func intro(_ body: [String: Any]) async throws -> E2EIntroAnswer? {
        var req = URLRequest(url: base.appendingPathComponent("/e2e/intro"))
        req.httpMethod = "POST"
        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
        req.httpBody = try JSONSerialization.data(withJSONObject: body)
        let (data, response) = try await session.data(for: req)
        guard let http = response as? HTTPURLResponse else {
            throw MessengerError.transport("Non-HTTP response")
        }
        if http.statusCode == 404 { return nil }
        if http.statusCode == 429 {
            throw MessengerError.rateLimited(
                retryAfterSeconds: http.value(forHTTPHeaderField: "Retry-After").flatMap(Int.init))
        }
        guard (200..<300).contains(http.statusCode),
            let o = try JSONSerialization.jsonObject(with: data) as? [String: Any],
            let uid = JSONValue(any: o["user_id"])?.intValue,
            let introB64 = o["intro"] as? String, let intro = Data(base64Encoded: introB64),
            intro.count == 32,
            let exp = JSONValue(any: o["exp"])?.intValue,
            let rawDevices = o["devices"]
        else { throw MessengerError.httpStatus(http.statusCode) }
        let devices = try JSONDecoder().decode(
            [E2EKeysResponse.Bundle].self,
            from: JSONSerialization.data(withJSONObject: rawDevices))
        return E2EIntroAnswer(
            userID: Int(uid), fnid: o["fnid"] as? String, intro: intro, exp: Int(exp),
            handleCert: (o["handle_cert"] as? [String: Any]).flatMap(HandleCertificate.init(json:)),
            devices: devices)
    }

    private func post<T: Decodable>(_ path: String, _ body: [String: Any]) async throws -> T {
        var req = URLRequest(url: base.appendingPathComponent(path))
        req.httpMethod = "POST"
        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
        req.setValue("application/json", forHTTPHeaderField: "Accept")
        req.httpBody = try JSONSerialization.data(withJSONObject: body)
        return try await perform(req)
    }

    private func perform<T: Decodable>(_ req: URLRequest) async throws -> T {
        let (data, response) = try await session.data(for: req)
        guard let http = response as? HTTPURLResponse else {
            throw MessengerError.transport("Non-HTTP response")
        }
        if http.statusCode == 429 {
            throw MessengerError.rateLimited(
                retryAfterSeconds: http.value(forHTTPHeaderField: "Retry-After").flatMap(Int.init))
        }
        guard (200..<300).contains(http.statusCode) else {
            throw MessengerError.httpStatus(http.statusCode)
        }
        do {
            return try JSONDecoder().decode(T.self, from: data)
        } catch {
            throw MessengerError.decoding(error.localizedDescription)
        }
    }
}