Tests/Unit/PushRequestAuthenticatorTests.swift (10507B)
1import Foundation
2import Testing
3
4@testable import Crossmate
5
6@Suite("Push request authentication", .serialized)
7struct PushRequestAuthenticatorTests {
8 @Test("App Attest key IDs canonicalize standard and URL-safe Base64")
9 func keyIDCanonicalization() throws {
10 let bytes = Data([0xfb, 0xff] + Array(0..<30))
11 let standard = bytes.base64EncodedString()
12 let urlSafe = bytes.base64URLEncodedString()
13
14 #expect(standard.contains("+"))
15 #expect(standard.contains("/"))
16 #expect(standard.hasSuffix("="))
17 #expect(try PushRequestAuthenticator.canonicalKeyID(standard) == urlSafe)
18 #expect(try PushRequestAuthenticator.canonicalKeyID(urlSafe) == urlSafe)
19 }
20
21 @Test("App Attest key IDs reject malformed and storage-smuggling values")
22 func keyIDRejection() {
23 for keyID in ["", "A", "AA=A", "+_8=", "not:base64", String(repeating: "A", count: 257)] {
24 #expect(throws: PushRequestAuthError.self) {
25 try PushRequestAuthenticator.canonicalKeyID(keyID)
26 }
27 }
28 }
29
30 @Test("challenge failures retain privacy-safe status and retry information")
31 func challengeDiagnostics() throws {
32 let url = try #require(URL(string: "https://push.test/attest/challenge"))
33 let badRequest = try #require(HTTPURLResponse(
34 url: url,
35 statusCode: 400,
36 httpVersion: nil,
37 headerFields: nil
38 ))
39 let badRequestError = PushRequestAuthenticator.challengeError(
40 response: badRequest,
41 data: Data("Malformed deviceID or keyID".utf8),
42 now: Date(timeIntervalSince1970: 0)
43 )
44 #expect(badRequestError.localizedDescription.contains("HTTP 400"))
45 #expect(badRequestError.localizedDescription.contains("Malformed deviceID or keyID"))
46
47 let secretEcho = PushRequestAuthenticator.challengeError(
48 response: badRequest,
49 data: Data("keyID abcdef0123456789".utf8),
50 now: Date(timeIntervalSince1970: 0)
51 )
52 #expect(secretEcho.localizedDescription.contains("unrecognized response"))
53 #expect(!secretEcho.localizedDescription.contains("abcdef0123456789"))
54
55 let limited = try #require(HTTPURLResponse(
56 url: url,
57 statusCode: 429,
58 httpVersion: nil,
59 headerFields: ["Retry-After": "90"]
60 ))
61 let limitedError = PushRequestAuthenticator.challengeError(
62 response: limited,
63 data: Data("Rate limit exceeded".utf8),
64 now: Date(timeIntervalSince1970: 0)
65 )
66 #expect(limitedError.localizedDescription.contains("HTTP 429"))
67 #expect(limitedError.localizedDescription.contains("90 seconds"))
68 }
69
70 @Test("failed challenge reuses the persisted key after backoff")
71 func failedChallengeReusesKey() async throws {
72 AuthURLProtocol.reset()
73 defer { AuthURLProtocol.reset() }
74
75 let bytes = Data([0xfb, 0xff] + Array(0..<30))
76 let originalKeyID = bytes.base64EncodedString()
77 let canonicalKeyID = bytes.base64URLEncodedString()
78 let service = FakeAppAttestService(keyID: originalKeyID)
79 let storage = MemoryPushAuthKeyStore()
80 let sleeps = SleepRecorder()
81 AuthURLProtocol.setHandler { request, challengeAttempt in
82 switch request.url?.path {
83 case "/attest/challenge" where challengeAttempt == 1:
84 return (500, [:], Data("internal details".utf8))
85 case "/attest/challenge":
86 return (200, [:], Data(#"{"challenge":"challenge-1"}"#.utf8))
87 case "/attest/register":
88 return (204, [:], Data())
89 default:
90 return (404, [:], Data("Not found".utf8))
91 }
92 }
93
94 let configuration = URLSessionConfiguration.ephemeral
95 configuration.protocolClasses = [AuthURLProtocol.self]
96 let authenticator = PushRequestAuthenticator(
97 baseURL: URL(string: "https://push.test")!,
98 deviceID: "device-1",
99 session: URLSession(configuration: configuration),
100 service: service,
101 keyStore: storage.store,
102 now: { Date(timeIntervalSince1970: 1_000) },
103 sleep: { await sleeps.record($0) },
104 jitter: { 1 }
105 )
106
107 await #expect(throws: PushRequestAuthError.self) {
108 try await authenticator.signedHeaders(method: "POST", path: "/register", body: Data())
109 }
110 let headers = try await authenticator.signedHeaders(
111 method: "POST",
112 path: "/register",
113 body: Data()
114 )
115
116 #expect(headers["X-Crossmate-Key-ID"] == canonicalKeyID)
117 #expect(service.generateKeyCount == 1)
118 #expect(service.attestKeyIDs == [originalKeyID])
119 #expect(await sleeps.values == [2])
120 }
121
122 @Test("lost registration response resends the persisted attestation")
123 func lostRegistrationResponseReusesAttestation() async throws {
124 AuthURLProtocol.reset()
125 defer { AuthURLProtocol.reset() }
126
127 let bytes = Data([0xfb, 0xff] + Array(0..<30))
128 let originalKeyID = bytes.base64EncodedString()
129 let service = FakeAppAttestService(keyID: originalKeyID)
130 let storage = MemoryPushAuthKeyStore()
131 let sleeps = SleepRecorder()
132 let registerAttempts = LockedCounter()
133 AuthURLProtocol.setHandler { request, _ in
134 switch request.url?.path {
135 case "/attest/challenge":
136 return (200, [:], Data(#"{"challenge":"challenge-1"}"#.utf8))
137 case "/attest/register":
138 let attempt = registerAttempts.increment()
139 return attempt == 1 ? (500, [:], Data()) : (204, [:], Data())
140 default:
141 return (404, [:], Data("Not found".utf8))
142 }
143 }
144
145 let configuration = URLSessionConfiguration.ephemeral
146 configuration.protocolClasses = [AuthURLProtocol.self]
147 let authenticator = PushRequestAuthenticator(
148 baseURL: URL(string: "https://push.test")!,
149 deviceID: "device-1",
150 session: URLSession(configuration: configuration),
151 service: service,
152 keyStore: storage.store,
153 now: { Date(timeIntervalSince1970: 1_000) },
154 sleep: { await sleeps.record($0) },
155 jitter: { 1 }
156 )
157
158 await #expect(throws: PushRequestAuthError.self) {
159 try await authenticator.signedHeaders(method: "POST", path: "/register", body: Data())
160 }
161 _ = try await authenticator.signedHeaders(method: "POST", path: "/register", body: Data())
162
163 #expect(service.generateKeyCount == 1)
164 #expect(service.attestKeyIDs == [originalKeyID])
165 #expect(registerAttempts.value == 2)
166 #expect(await sleeps.values == [2])
167 }
168}
169
170private final class FakeAppAttestService: AppAttestServicing, @unchecked Sendable {
171 private let lock = NSLock()
172 private let keyID: String
173 private var generated = 0
174 private var attested: [String] = []
175
176 init(keyID: String) {
177 self.keyID = keyID
178 }
179
180 var isSupported: Bool { true }
181
182 var generateKeyCount: Int {
183 lock.withLock { generated }
184 }
185
186 var attestKeyIDs: [String] {
187 lock.withLock { attested }
188 }
189
190 func generateKey() async throws -> String {
191 lock.withLock { generated += 1 }
192 return keyID
193 }
194
195 func attestKey(_ keyID: String, clientDataHash: Data) async throws -> Data {
196 lock.withLock { attested.append(keyID) }
197 return Data([1, 2, 3])
198 }
199
200 func generateAssertion(_ keyID: String, clientDataHash: Data) async throws -> Data {
201 Data([4, 5, 6])
202 }
203}
204
205private final class MemoryPushAuthKeyStore: @unchecked Sendable {
206 private let lock = NSLock()
207 private var values: [String: Data] = [:]
208
209 var store: PushAuthKeyStore {
210 PushAuthKeyStore(
211 load: { [self] key in lock.withLock { values[key] } },
212 save: { [self] key, data in lock.withLock { values[key] = data } },
213 delete: { [self] key in lock.withLock { _ = values.removeValue(forKey: key) } }
214 )
215 }
216}
217
218private actor SleepRecorder {
219 private(set) var values: [TimeInterval] = []
220
221 func record(_ value: TimeInterval) {
222 values.append(value)
223 }
224}
225
226private final class LockedCounter: @unchecked Sendable {
227 private let lock = NSLock()
228 private var count = 0
229
230 var value: Int { lock.withLock { count } }
231
232 func increment() -> Int {
233 lock.withLock {
234 count += 1
235 return count
236 }
237 }
238}
239
240private final class AuthURLProtocol: URLProtocol {
241 typealias Result = (status: Int, headers: [String: String], data: Data)
242 private static let state = AuthURLProtocolState()
243
244 static func reset() { state.reset() }
245 static func setHandler(_ handler: @escaping @Sendable (URLRequest, Int) -> Result) {
246 state.setHandler(handler)
247 }
248
249 override class func canInit(with request: URLRequest) -> Bool { true }
250 override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
251
252 override func startLoading() {
253 let result = Self.state.result(for: request)
254 let response = HTTPURLResponse(
255 url: request.url!,
256 statusCode: result.status,
257 httpVersion: nil,
258 headerFields: result.headers
259 )!
260 client?.urlProtocol(self, didReceive: response, cacheStoragePolicy: .notAllowed)
261 client?.urlProtocol(self, didLoad: result.data)
262 client?.urlProtocolDidFinishLoading(self)
263 }
264
265 override func stopLoading() {}
266}
267
268private final class AuthURLProtocolState: @unchecked Sendable {
269 private let lock = NSLock()
270 private var challengeAttempts = 0
271 private var handler: (@Sendable (URLRequest, Int) -> AuthURLProtocol.Result)?
272
273 func reset() {
274 lock.withLock {
275 challengeAttempts = 0
276 handler = nil
277 }
278 }
279
280 func setHandler(_ next: @escaping @Sendable (URLRequest, Int) -> AuthURLProtocol.Result) {
281 lock.withLock { handler = next }
282 }
283
284 func result(for request: URLRequest) -> AuthURLProtocol.Result {
285 lock.withLock {
286 if request.url?.path == "/attest/challenge" { challengeAttempts += 1 }
287 return handler?(request, challengeAttempts) ?? (500, [:], Data())
288 }
289 }
290}