crossmate

PushRequestAuthenticator.swift (7751B)

---

 import CryptoKit
 import DeviceCheck
 import Foundation
 
 enum PushRequestAuthError: LocalizedError {
     case appAttestUnsupported
     case missingChallenge
     case attestationRejected
     case invalidResponse
 
     var errorDescription: String? {
         switch self {
         case .appAttestUnsupported:
             "App Attest is not available on this device."
         case .missingChallenge:
             "The push worker did not return an App Attest challenge."
         case .attestationRejected:
             "The push worker rejected this app installation's attestation."
         case .invalidResponse:
             "The push worker returned an invalid authentication response."
         }
     }
 }
 
 /// Enrolls this app installation with the push worker using App Attest, then
 /// signs each worker request with the attested key. The worker stores only the
 /// public key and a monotonically increasing assertion counter; Crossmate still
 /// has no server-side user accounts.
 actor PushRequestAuthenticator {
     private static let keyIDKey = "push.appAttest.keyID.v1"
 
     private let baseURL: URL
     private let deviceID: String
     private let session: URLSession
     private let service = DCAppAttestService.shared
 
     private var cachedKeyID: String?
     private var registeringTask: Task<String, Error>?
 
     init(
         baseURL: URL,
         deviceID: String,
         session: URLSession
     ) {
         self.baseURL = baseURL
         self.deviceID = deviceID
         self.session = session
     }
 
     func signedHeaders(
         method: String,
         path: String,
         body: Data
     ) async throws -> [String: String] {
         let keyID = try await registeredKeyID()
         return try await assertionHeaders(
             keyID: keyID,
             method: method,
             path: path,
             body: body
         )
     }
 
     func resetRegistration() {
         cachedKeyID = nil
         registeringTask?.cancel()
         registeringTask = nil
         KeychainHelper.delete(key: Self.keyIDKey)
     }
 
     private func registeredKeyID() async throws -> String {
         if let cachedKeyID { return cachedKeyID }
         if let data = KeychainHelper.load(key: Self.keyIDKey),
            let keyID = String(data: data, encoding: .utf8),
            !keyID.isEmpty {
             cachedKeyID = keyID
             return keyID
         }
         if let registeringTask {
             return try await registeringTask.value
         }
         let task = Task { try await registerFreshKey() }
         registeringTask = task
         do {
             let keyID = try await task.value
             registeringTask = nil
             cachedKeyID = keyID
             return keyID
         } catch {
             registeringTask = nil
             throw error
         }
     }
 
     private func registerFreshKey() async throws -> String {
         guard service.isSupported else {
             throw PushRequestAuthError.appAttestUnsupported
         }
         let keyID = try await service.generateKey()
         let challenge = try await fetchChallenge(for: keyID)
         let clientDataHash = Self.clientDataHashForAttestation(
             challenge: challenge,
             deviceID: deviceID,
             keyID: keyID
         )
         let attestation = try await service.attestKey(keyID, clientDataHash: clientDataHash)
         try await submitAttestation(
             keyID: keyID,
             challenge: challenge,
             attestation: attestation
         )
         try KeychainHelper.save(key: Self.keyIDKey, data: Data(keyID.utf8))
         return keyID
     }
 
     private func fetchChallenge(for keyID: String) async throws -> String {
         var request = URLRequest(
             url: baseURL.appendingPathComponent("attest").appendingPathComponent("challenge")
         )
         request.httpMethod = "POST"
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
         request.httpBody = try JSONEncoder().encode(
             ChallengeRequest(deviceID: deviceID, keyID: keyID)
         )
         let (data, response) = try await session.data(for: request)
         guard let http = response as? HTTPURLResponse, http.statusCode == 200 else {
             throw PushRequestAuthError.missingChallenge
         }
         let decoded = try JSONDecoder().decode(ChallengeResponse.self, from: data)
         guard !decoded.challenge.isEmpty else {
             throw PushRequestAuthError.missingChallenge
         }
         return decoded.challenge
     }
 
     private func submitAttestation(
         keyID: String,
         challenge: String,
         attestation: Data
     ) async throws {
         var request = URLRequest(
             url: baseURL.appendingPathComponent("attest").appendingPathComponent("register")
         )
         request.httpMethod = "POST"
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
         let body = AttestationRequest(
             deviceID: deviceID,
             keyID: keyID,
             challenge: challenge,
             attestationObject: attestation.base64URLEncodedString()
         )
         request.httpBody = try JSONEncoder().encode(body)
         let (_, response) = try await session.data(for: request)
         guard let http = response as? HTTPURLResponse, http.statusCode == 204 else {
             throw PushRequestAuthError.attestationRejected
         }
     }
 
     private func assertionHeaders(
         keyID: String,
         method: String,
         path: String,
         body: Data
     ) async throws -> [String: String] {
         let timestamp = String(Int(Date().timeIntervalSince1970))
         let nonce = UUID().uuidString
         let bodyHash = Data(SHA256.hash(data: body)).base64URLEncodedString()
         let canonical = Self.canonicalRequest(
             method: method,
             path: path,
             bodyHash: bodyHash,
             timestamp: timestamp,
             nonce: nonce,
             deviceID: deviceID,
             keyID: keyID
         )
         let clientDataHash = Data(SHA256.hash(data: Data(canonical.utf8)))
         let assertion = try await service.generateAssertion(keyID, clientDataHash: clientDataHash)
         return [
             "X-Crossmate-Auth-Version": "appattest-v1",
             "X-Crossmate-Device-ID": deviceID,
             "X-Crossmate-Key-ID": keyID,
             "X-Crossmate-Timestamp": timestamp,
             "X-Crossmate-Nonce": nonce,
             "X-Crossmate-Body-SHA256": bodyHash,
             "X-Crossmate-Assertion": assertion.base64URLEncodedString()
         ]
     }
 
     private static func clientDataHashForAttestation(
         challenge: String,
         deviceID: String,
         keyID: String
     ) -> Data {
         let canonical = [
             "crossmate-appattest-v1",
             challenge,
             deviceID,
             keyID
         ].joined(separator: "\n")
         return Data(SHA256.hash(data: Data(canonical.utf8)))
     }
 
     static func canonicalRequest(
         method: String,
         path: String,
         bodyHash: String,
         timestamp: String,
         nonce: String,
         deviceID: String,
         keyID: String
     ) -> String {
         [
             "crossmate-push-request-v1",
             method.uppercased(),
             path,
             bodyHash,
             timestamp,
             nonce,
             deviceID,
             keyID
         ].joined(separator: "\n")
     }
 
     private struct ChallengeRequest: Encodable {
         var deviceID: String
         var keyID: String
     }
 
     private struct ChallengeResponse: Decodable {
         var challenge: String
     }
 
     private struct AttestationRequest: Encodable {
         var deviceID: String
         var keyID: String
         var challenge: String
         var attestationObject: String
     }
 }