Crossmate/Services/PushClient.swift (30229B)
1import CryptoKit
2import Foundation
3
4
5
6
7
8
9@MainActor
10final class PushClient {
11 enum Environment: String {
12 case sandbox
13 case production
14 }
15
16 private let baseURL: URL
17 private let deviceID: String
18 private let environment: Environment
19 private let session: URLSession
20 private let log: (String) -> Void
21 private let authenticator: PushRequestAuthenticator
22 private let authorizationHeaders: (String, String, Data) async throws -> [String: String]
23
24 private var apnsToken: String?
25 private var authorID: String?
26
27
28
29
30 private var bindings: Set<PushAddressBinding> = []
31
32
33 private var mutedKinds: Set<String> = []
34 private var lastRegistered: Registration?
35
36
37
38
39 var gameCredentialResolver: (@MainActor (UUID) -> GamePushCredentials?)?
40
41
42
43
44
45 var contentKeyResolver: (@MainActor (UUID) -> SymmetricKey?)?
46
47
48
49
50
51 static let genericAlertBody = "New activity in one of your puzzles"
52
53
54
55
56 private var registeredGameCredentials: [UUID: String] = [:]
57
58
59
60
61
62
63 private struct Registration: Equatable {
64 let token: String
65 let bindings: Set<PushAddressBinding>
66 let mutedKinds: Set<String>
67 }
68
69
70
71
72
73
74
75
76
77
78
79
80
81 static func makeWorkerSession() -> URLSession {
82 let config = URLSessionConfiguration.default
83 config.waitsForConnectivity = true
84 config.timeoutIntervalForRequest = 30
85 config.timeoutIntervalForResource = 60
86 return URLSession(configuration: config)
87 }
88
89 init?(
90 deviceID: String = RecordSerializer.localDeviceID,
91 session: URLSession = PushClient.makeWorkerSession(),
92 log: @escaping (String) -> Void = { _ in }
93 ) {
94 guard let rawBase = Bundle.main.object(forInfoDictionaryKey: "CrossmatePushBaseURL") as? String else {
95 log("Push disabled: missing CrossmatePushBaseURL")
96 return nil
97 }
98 let trimmedBase = rawBase.trimmingCharacters(in: .whitespacesAndNewlines)
99 guard !trimmedBase.isEmpty, !trimmedBase.hasPrefix("$(") else {
100 log("Push disabled: empty CrossmatePushBaseURL")
101 return nil
102 }
103 guard let base = URL(string: trimmedBase),
104 let scheme = base.scheme,
105 scheme == "https",
106 base.host?.isEmpty == false
107 else {
108 log("Push disabled: invalid CrossmatePushBaseURL")
109 return nil
110 }
111 self.baseURL = base
112 self.deviceID = deviceID
113 self.session = session
114 self.log = log
115 let authenticator = PushRequestAuthenticator(
116 baseURL: base,
117 deviceID: deviceID,
118 session: session
119 )
120 self.authenticator = authenticator
121 self.authorizationHeaders = { method, path, body in
122 try await authenticator.signedHeaders(method: method, path: path, body: body)
123 }
124
125
126
127
128 switch Bundle.main.object(forInfoDictionaryKey: "CrossmateAPSEnvironment") as? String {
129 case "development":
130 self.environment = .sandbox
131 case "production":
132 self.environment = .production
133 case let other:
134 log("Push disabled: unrecognised APNs environment \(other ?? "<missing>")")
135 return nil
136 }
137 }
138
139 init(
140 baseURL: URL,
141 environment: Environment,
142 deviceID: String = RecordSerializer.localDeviceID,
143 session: URLSession,
144 log: @escaping (String) -> Void = { _ in },
145 authorizationHeaders: @escaping (String, String, Data) async throws -> [String: String]
146 ) {
147 self.baseURL = baseURL
148 self.deviceID = deviceID
149 self.environment = environment
150 self.session = session
151 self.log = log
152 let authenticator = PushRequestAuthenticator(
153 baseURL: baseURL,
154 deviceID: deviceID,
155 session: session
156 )
157 self.authenticator = authenticator
158 self.authorizationHeaders = authorizationHeaders
159 }
160
161 func updateAPNsToken(_ data: Data) {
162 let hex = data.map { String(format: "%02x", $0) }.joined()
163 if hex == apnsToken { return }
164 apnsToken = hex
165 Task { await reconcile() }
166 }
167
168 func testingSetAPNsToken(_ data: Data) {
169 apnsToken = data.map { String(format: "%02x", $0) }.joined()
170 }
171
172 func testingReconcile() async {
173 await reconcile()
174 }
175
176
177
178
179
180 func updateAuthorID(_ newAuthorID: String?) {
181 let normalized = newAuthorID?.trimmingCharacters(in: .whitespaces)
182 authorID = (normalized?.isEmpty == false) ? normalized : nil
183 }
184
185
186
187
188
189
190 func setAddresses(_ next: Set<PushAddressBinding>) {
191 if next == bindings { return }
192 bindings = next
193 Task { await reconcile() }
194 }
195
196 func testingSetAddresses(_ next: Set<PushAddressBinding>) {
197 bindings = next
198 }
199
200
201
202
203 func setMutedKinds(_ next: Set<String>) {
204 if next == mutedKinds { return }
205 mutedKinds = next
206 Task { await reconcile() }
207 }
208
209 private func reconcile() async {
210 guard let apnsToken else { return }
211 let desired = bindings
212 let signature = Registration(
213 token: apnsToken,
214 bindings: desired,
215 mutedKinds: mutedKinds
216 )
217 if lastRegistered == signature { return }
218 let toRemove = (lastRegistered?.bindings ?? []).subtracting(desired)
219 do {
220
221
222 for creds in Set(desired.compactMap(\.credentials)) {
223 await registerGameCredential(creds)
224 }
225
226
227
228
229
230 let sortedMuted = signature.mutedKinds.sorted()
231 let accountBindings = desired.filter { $0.credentials == nil }
232 if !accountBindings.isEmpty {
233 try await register(
234 token: apnsToken,
235 bindings: Array(accountBindings),
236 mutedKinds: sortedMuted
237 )
238 }
239 let gameGroups = Dictionary(
240 grouping: desired.filter { $0.credentials != nil }
241 ) { $0.credentials! }
242 for (creds, group) in gameGroups {
243 try await register(
244 token: apnsToken,
245 bindings: group,
246 mutedKinds: sortedMuted,
247 gameCredential: creds
248 )
249 }
250 if !toRemove.isEmpty {
251 try await unregister(bindings: Array(toRemove))
252 }
253 lastRegistered = signature
254 } catch {
255
256
257
258 log("Push register failed: \(error.localizedDescription)")
259 }
260 }
261
262
263
264
265
266
267
268 struct Addressee: Sendable, Equatable {
269 let address: String
270 let body: String?
271
272
273
274 let payload: PushPayload?
275
276 init(address: String, body: String? = nil, payload: PushPayload? = nil) {
277 self.address = address
278 self.body = body
279 self.payload = payload
280 }
281 }
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299 static func gameCollapseID(_ gameID: UUID) -> String {
300 "game-\(gameID.uuidString)"
301 }
302
303 @discardableResult
304 func publish(
305 kind: String,
306 gameID: UUID,
307 addressees: [Addressee],
308 title: String,
309 puzzleTitle: String? = nil,
310 background: Bool = false,
311 gameCredentialed: Bool = true,
312 broadcast: Bool = false,
313 excludeAddress: String? = nil,
314 broadcastPayload: PushPayload? = nil,
315 payloadKey: SymmetricKey? = nil,
316 collapseID: String? = nil,
317 extra: [String: Any] = [:],
318 body: String
319 ) async -> Bool {
320 guard broadcast || !addressees.isEmpty else { return true }
321
322
323
324
325 var credential: GamePushCredentials?
326 if gameCredentialed {
327 guard let creds = gameCredentialResolver?(gameID) else {
328 log("push(\(kind)): skipped (no game credential)")
329 return false
330 }
331 await registerGameCredential(creds)
332 credential = creds
333 }
334 log(broadcast
335 ? "push(\(kind)): broadcasting to room"
336 : "push(\(kind)): publishing to \(addressees.count) addressee(s)")
337
338
339
340
341
342
343 let needsContentKey = broadcastPayload != nil || addressees.contains { $0.payload != nil }
344 let contentKey = needsContentKey ? (payloadKey ?? contentKeyResolver?(gameID)) : nil
345
346
347
348
349
350
351 let addresseePayloads: [[String: Any]] = addressees.map { addressee in
352 var entry: [String: Any] = ["address": addressee.address]
353 if var payload = addressee.payload {
354 if let puzzleTitle { payload.puzzleTitle = puzzleTitle }
355 if let contentKey, let sealed = PushPayloadCipher.seal(payload, key: contentKey) {
356 entry["enc"] = sealed
357 }
358 }
359 return entry
360 }
361 var payload: [String: Any] = [
362 "kind": kind,
363 "gameID": gameID.uuidString,
364 "fromAuthorID": authorID ?? "",
365 "senderDeviceID": deviceID,
366 "title": title,
367
368
369 "alertBody": body.isEmpty ? "" : Self.genericAlertBody,
370 "addressees": addresseePayloads,
371 "background": background
372 ]
373
374
375
376 if let credential {
377 payload["credID"] = credential.credID.uuidString
378 }
379
380
381
382 if let collapseID {
383 payload["collapseID"] = collapseID
384 }
385
386
387
388
389 if broadcast {
390 payload["broadcast"] = true
391 if let excludeAddress { payload["excludeAddress"] = excludeAddress }
392 if var broadcastPayload {
393 if let puzzleTitle { broadcastPayload.puzzleTitle = puzzleTitle }
394 if let contentKey, let sealed = PushPayloadCipher.seal(broadcastPayload, key: contentKey) {
395 payload["enc"] = sealed
396 }
397 }
398 }
399 for (key, value) in extra {
400 payload[key] = value
401 }
402 var request = URLRequest(url: baseURL.appendingPathComponent("publish"))
403 request.httpMethod = "POST"
404 do {
405 let body = try JSONSerialization.data(withJSONObject: payload)
406 request.httpBody = body
407 let (data, response) = try await sendAuthorized(
408 request,
409 method: "POST",
410 path: "/publish",
411 body: body,
412 gameCredential: credential
413 )
414 guard response.statusCode == 200 else {
415 throw URLError(.badServerResponse)
416 }
417 log("push(\(kind)): worker accepted\(Self.deliverySummary(from: data))")
418 return true
419 } catch {
420 log("push(\(kind)) failed: \(error.localizedDescription)")
421 return false
422 }
423 }
424
425 func publishAccountEvent(
426 kind: String,
427 gameID: UUID,
428 address: String,
429 presenceUntil: Date? = nil
430 ) async {
431 var extra: [String: Any] = [:]
432 if let presenceUntil {
433 extra["presenceUntil"] = Self.iso8601.string(from: presenceUntil)
434 }
435 await publish(
436 kind: kind,
437 gameID: gameID,
438 addressees: [Addressee(address: address)],
439 title: "",
440 background: true,
441 gameCredentialed: false,
442 extra: extra,
443 body: ""
444 )
445 }
446
447
448
449
450
451
452
453 nonisolated static func deliverySummary(from data: Data) -> String {
454 guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
455 return ""
456 }
457 let counts = ["delivered", "muted", "removed", "failed"].compactMap { key in
458 (json[key] as? Int).map { "\(key)=\($0)" }
459 }
460 return counts.isEmpty ? "" : " (\(counts.joined(separator: " ")))"
461 }
462
463 private static let iso8601: ISO8601DateFormatter = {
464 let formatter = ISO8601DateFormatter()
465 formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
466 formatter.timeZone = TimeZone(secondsFromGMT: 0)
467 return formatter
468 }()
469
470
471
472
473 private func addressPayload(for bindings: [PushAddressBinding]) -> [[String: Any]] {
474 bindings.map { binding in
475 var entry: [String: Any] = ["address": binding.address]
476 if let credID = binding.credentials?.credID {
477 entry["credID"] = credID.uuidString
478 }
479 return entry
480 }
481 }
482
483 private func register(
484 token: String,
485 bindings: [PushAddressBinding],
486 mutedKinds: [String],
487 gameCredential: GamePushCredentials? = nil
488 ) async throws {
489 var request = URLRequest(url: baseURL.appendingPathComponent("register"))
490 request.httpMethod = "POST"
491 let body: [String: Any] = [
492 "deviceID": deviceID,
493 "token": token,
494 "environment": environment.rawValue,
495 "addresses": addressPayload(for: bindings),
496 "mutedKinds": mutedKinds
497 ]
498 let data = try JSONSerialization.data(withJSONObject: body)
499 request.httpBody = data
500 let (_, response) = try await sendAuthorized(
501 request,
502 method: "POST",
503 path: "/register",
504 body: data,
505 gameCredential: gameCredential
506 )
507 try assert204(response)
508 }
509
510 private func unregister(bindings: [PushAddressBinding]) async throws {
511 var request = URLRequest(url: baseURL.appendingPathComponent("register"))
512 request.httpMethod = "DELETE"
513 let data = (try? JSONSerialization.data(withJSONObject: [
514 "deviceID": deviceID,
515 "addresses": addressPayload(for: bindings)
516 ])) ?? Data()
517 request.httpBody = data
518 let (_, response) = try await sendAuthorized(
519 request,
520 method: "DELETE",
521 path: "/register",
522 body: data
523 )
524 do {
525 try assert204(response)
526 } catch {
527 log("Push unregister failed: HTTP \(response.statusCode)")
528 throw error
529 }
530 }
531
532
533
534
535
536
537
538 private func registerGameCredential(_ credentials: GamePushCredentials) async {
539 if registeredGameCredentials[credentials.credID] == credentials.secret { return }
540 let path = "/games/\(credentials.credID.uuidString)/register"
541 var request = URLRequest(
542 url: baseURL
543 .appendingPathComponent("games")
544 .appendingPathComponent(credentials.credID.uuidString)
545 .appendingPathComponent("register")
546 )
547 request.httpMethod = "POST"
548 let data = (try? JSONSerialization.data(withJSONObject: ["secret": credentials.secret])) ?? Data()
549 request.httpBody = data
550 do {
551 let (_, response) = try await sendAuthorized(
552 request,
553 method: "POST",
554 path: path,
555 body: data
556 )
557 switch response.statusCode {
558 case 200..<300:
559 registeredGameCredentials[credentials.credID] = credentials.secret
560 case 409:
561 log("Push game-credential rejected (secret mismatch) for \(credentials.credID)")
562 default:
563 log("Push game-credential register failed: HTTP \(response.statusCode)")
564 }
565 } catch {
566 log("Push game-credential register failed: \(error.localizedDescription)")
567 }
568 }
569
570 private func sendAuthorized(
571 _ request: URLRequest,
572 method: String,
573 path: String,
574 body: Data,
575 gameCredential: GamePushCredentials? = nil
576 ) async throws -> (Data, HTTPURLResponse) {
577
578
579
580
581
582
583
584
585
586
587
588 let maxAttempts = 3
589 var attempt = 0
590 while true {
591 do {
592 return try await sendAuthorized(
593 request,
594 method: method,
595 path: path,
596 body: body,
597 gameCredential: gameCredential,
598 retryAfterRegistrationReset: true
599 )
600 } catch let error as URLError
601 where Self.isRetryableTransport(error.code) && attempt + 1 < maxAttempts {
602 attempt += 1
603
604
605 try? await Task.sleep(for: .milliseconds(200 * attempt))
606 }
607 }
608 }
609
610
611
612
613
614 private static func isRetryableTransport(_ code: URLError.Code) -> Bool {
615 switch code {
616 case .networkConnectionLost, .timedOut, .cannotConnectToHost,
617 .cannotFindHost, .dnsLookupFailed, .secureConnectionFailed:
618 return true
619 default:
620 return false
621 }
622 }
623
624 private func sendAuthorized(
625 _ request: URLRequest,
626 method: String,
627 path: String,
628 body: Data,
629 gameCredential: GamePushCredentials?,
630 retryAfterRegistrationReset: Bool
631 ) async throws -> (Data, HTTPURLResponse) {
632 var request = request
633 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
634 let headers = try await authorizationHeaders(method, path, body)
635 for (key, value) in headers {
636 request.setValue(value, forHTTPHeaderField: key)
637 }
638
639
640
641 if let gameCredential,
642 let bodyHash = headers["X-Crossmate-Body-SHA256"],
643 let timestamp = headers["X-Crossmate-Timestamp"],
644 let nonce = headers["X-Crossmate-Nonce"] {
645 let payload = GamePushSigner.signaturePayload(
646 credID: gameCredential.credID,
647 bodyHash: bodyHash,
648 timestamp: timestamp,
649 nonce: nonce
650 )
651 if let signature = try? GamePushSigner.signature(
652 payload: payload,
653 secret: gameCredential.secret
654 ) {
655 request.setValue(signature, forHTTPHeaderField: "X-Crossmate-Game-Signature")
656 }
657 }
658 let (data, response) = try await session.data(for: request)
659 guard let http = response as? HTTPURLResponse else {
660 throw URLError(.badServerResponse)
661 }
662 if http.statusCode == 401, retryAfterRegistrationReset {
663 await authenticator.resetRegistration()
664 return try await sendAuthorized(
665 request,
666 method: method,
667 path: path,
668 body: body,
669 gameCredential: gameCredential,
670 retryAfterRegistrationReset: false
671 )
672 }
673 return (data, http)
674 }
675
676 private func assert204(_ response: HTTPURLResponse) throws {
677 guard response.statusCode == 204 else {
678 throw URLError(.badServerResponse)
679 }
680 }
681}