Repository Public
1// Native specifics of the Swift engine: SQLite persistence, Secure Enclave device keys, device-key step-up,2// expired bearer sessions, the read-only AutoFill reader, Connect, audit chain.3import CryptoKit4import Foundation5import LocalAuthentication6import XCTest7@testable import SharedVaultKit89final class NativeTests: ServerTestCase {10 private func tempDir() throws -> URL {11 let dir = FileManager.default.temporaryDirectory.appendingPathComponent("svk-\(UUID().uuidString)")12 try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)13 addTeardownBlock { try? FileManager.default.removeItem(at: dir) }14 return dir15 }1617 private func passkeyItem(rpId: String, user: String) throws -> Item {18 PasskeyCrypto.makeItem(try PasskeyCrypto.createCredential(rpId: rpId, userName: user, userHandle: Data("uh-\(user)".utf8), clientDataHash: SPV1.sha256(Data("x".utf8))))19 }2021 func testSQLiteStorePersistsOnlyCiphertextAndSurvivesRestartOfflineWithReader() async throws {22 let dir = try tempDir()23 let path = dir.appendingPathComponent("group/vault.sqlite").path24 let store = try SQLiteStore(path: path)25 let keyStore = InMemoryKeyStore()26 let (a, recoveryKey) = try await newAccount("sqlite1", store: store, keyStore: keyStore)27 let v = try await personal(a)28 let id = try await a.engine.saveItem(vaultId: v, item: login())29 let pk = try await a.engine.saveItem(vaultId: v, item: try passkeyItem(rpId: "passkeys.example", user: "zoe"))30 var trashed = login("In the trash")31 trashed.trashedAt = "2026-01-01T00:00:00.000Z"32 try await a.engine.saveItem(vaultId: v, item: trashed)33 a.api.offline = true34 let offlineId = try await a.engine.saveItem(vaultId: v, item: login("Queued offline ZQ9"))35 let digest = await a.engine.stateDigest()3637 // nothing decrypted touches the disk38 var disk = Data()39 for f in try FileManager.default.contentsOfDirectory(atPath: dir.appendingPathComponent("group").path) {40 disk.append(try Data(contentsOf: dir.appendingPathComponent("group").appendingPathComponent(f)))41 }42 XCTAssertGreaterThan(disk.count, 4096)43 let text = String(decoding: disk, as: UTF8.self)44 XCTAssertTrue(text.contains(v), "sanity: the files are the database (vault ids are stored in clear)")45 for needle in [SECRET_TITLE, SECRET_PW, SECRET_USER, "zanzibar", "note-ZQ9", "tag-zq9", "JBSWY3DPEHPK3PXP", "Personal", "Queued offline", "passkeys.example", recoveryKey, try XCTUnwrap(try keyStore.loadSessionToken())] {46 XCTAssertNil(disk.range(of: Data(needle.utf8)), "plaintext on disk: \(needle.prefix(12))")47 }48 XCTAssertEqual(try FileManager.default.attributesOfItem(atPath: path)[.posixPermissions] as? Int, 0o600)4950 // a second process (the AutoFill extension) opens the same file read-only while the app keeps it open51 let readerStore = try SQLiteStore(path: path, readOnly: true)52 XCTAssertThrowsError(try readerStore.apply(StoreDelta()))53 let reader = VaultReader(store: readerStore, keyStore: keyStore)54 XCTAssertTrue(reader.isAvailable())55 let session = try reader.unlock(context: nil)56 XCTAssertEqual(session.vaults.map(\.meta.name), ["Personal"])57 XCTAssertEqual(Set(session.logins().map(\.item.title)), [SECRET_TITLE, "Queued offline ZQ9"], "pending edits are visible, trashed items are not")58 XCTAssertEqual(session.item(recordIdentifier: "\(v)/\(id)")?.item.fields["password"], SECRET_PW)59 XCTAssertEqual(session.item(recordIdentifier: "\(v)/\(offlineId)")?.pending, true)60 XCTAssertNil(session.item(recordIdentifier: "\(v)/\(SPV1.uuid())"))61 XCTAssertEqual(session.logins(matching: "https://www.zanzibar-7731.test/").count, 2)62 XCTAssertEqual(session.logins(matching: "https://zanzibar-7731.test.evil.example/").count, 0)63 XCTAssertEqual(session.logins(matching: "http://bank.zanzibar-7731.test/login").count, 0, "saved https is never filled on http")64 let ids = session.credentialIdentities()65 XCTAssertEqual(Set(ids.passwords), [66 PasswordCredentialIdentity(recordIdentifier: "\(v)/\(id)", serviceIdentifier: "bank.zanzibar-7731.test", user: SECRET_USER),67 PasswordCredentialIdentity(recordIdentifier: "\(v)/\(offlineId)", serviceIdentifier: "bank.zanzibar-7731.test", user: SECRET_USER),68 ])69 XCTAssertEqual(ids.passkeys.count, 1)70 XCTAssertEqual(ids.passkeys.first?.recordIdentifier, "\(v)/\(pk)")71 XCTAssertEqual(ids.passkeys.first?.relyingPartyIdentifier, "passkeys.example")72 XCTAssertEqual(ids.passkeys.first?.userName, "zoe")73 XCTAssertEqual(ids.passkeys.first?.userHandle, Data("uh-zoe".utf8))74 let stored = try XCTUnwrap(session.passkeys(relyingParty: "passkeys.example", allowedCredentialIDs: [try XCTUnwrap(ids.passkeys.first).credentialID]).first)75 XCTAssertTrue(session.passkeys(relyingParty: "other.example").isEmpty)76 let assertion = try PasskeyCrypto.assert(fields: stored.item.fields, clientDataHash: SPV1.sha256(Data("cd".utf8)))77 XCTAssertEqual(assertion.credentialID, ids.passkeys.first?.credentialID)7879 // "restart": a new engine over a new connection to the same file, with the network down80 let store2 = try SQLiteStore(path: path)81 let api2 = TestTransport()82 api2.offline = true83 let engine2 = VaultEngine(transport: api2, store: store2, keyStore: keyStore, passkeys: a.auth, platformLabel: "Test device")84 let loaded = try await engine2.load()85 XCTAssertEqual(loaded, .locked)86 let lockedCount = await engine2.list().count87 XCTAssertEqual(lockedCount, 0)88 try await engine2.unlock(context: nil, backgroundSync: false)89 let titles = await engine2.list().map(\.item.title)90 XCTAssertEqual(Set(titles), [SECRET_TITLE, "passkeys.example", "In the trash", "Queued offline ZQ9"])91 let digest2 = await engine2.stateDigest()92 XCTAssertEqual(digest2, digest)93 let health = await engine2.syncHealth()94 XCTAssertEqual(health.pending, 1)95 // back online: the queued write goes out with the persisted bearer session, no passkey involved96 let assertionsBefore = a.auth.getCount97 api2.offline = false98 try await engine2.sync()99 let health2 = await engine2.syncHealth()100 XCTAssertEqual(health2.pending, 0)101 XCTAssertTrue(health2.online)102 XCTAssertNotNil(health2.lastSyncAt)103 XCTAssertEqual(a.auth.getCount, assertionsBefore)104 XCTAssertEqual(try psql("select count(*) from records where id = '\(offlineId)'"), "1")105 // the reader sees the committed state of the writer106 XCTAssertEqual(try reader.unlock(context: nil).item(recordIdentifier: "\(v)/\(offlineId)")?.pending, false)107108 // forgetting the account empties the database109 try await engine2.forget()110 XCTAssertEqual(try store2.load(), PersistedState())111 XCTAssertFalse(reader.isAvailable())112 XCTAssertThrowsError(try reader.unlock(context: nil))113 store.close(); store2.close(); readerStore.close()114 }115116 func testReaderOnDatabaseThatWasNeverInitialisedAndWrongKeys() async throws {117 let dir = try tempDir()118 let path = dir.appendingPathComponent("empty.sqlite").path119 sqlite3Touch(path)120 let empty = try SQLiteStore(path: path, readOnly: true)121 XCTAssertEqual(try empty.load(), PersistedState())122 // another device's keys cannot open this device's state123 let store = MemoryStore(), keyStore = InMemoryKeyStore()124 let (a, _) = try await newAccount("reader1", store: store, keyStore: keyStore)125 _ = a126 let other = InMemoryKeyStore()127 try other.save(identity: try XCTUnwrap(try keyStore.loadIdentity()), keys: try other.generateDeviceKeys())128 XCTAssertThrowsError(try VaultReader(store: store, keyStore: other).unlock(context: nil)) { XCTAssertEqual($0 as? VaultError, .authenticationFailed) }129 XCTAssertEqual(try VaultReader(store: store, keyStore: keyStore).unlock(context: nil).vaults.count, 1)130 }131132 func testSecureEnclaveKeyStoreEndToEnd() async throws {133 guard SecureEnclaveSupport.isAvailable else { throw XCTSkip("Secure Enclave not available on this machine") }134 // keys WITHOUT user presence so that no prompt appears; the legacy file Keychain because the test runner is unsigned135 let keyStore = SecureEnclaveKeyStore(service: "ai.spboucher.vault.test.\(UUID().uuidString)", policy: .none, useDataProtectionKeychain: false)136 addTeardownBlock { try? keyStore.clear() }137 do {138 let probe = try keyStore.generateDeviceKeys()139 try keyStore.save(identity: DeviceIdentity(accountId: "probe", handle: "probe", deviceId: "probe", createdAt: "x", arkEnvelope: nil), keys: probe)140 try keyStore.clear()141 } catch { throw XCTSkip("Secure Enclave keys or the Keychain are not usable in this process: \(error)") }142 XCTAssertTrue(keyStore.hardwareBacked)143 let store = MemoryStore()144 let (a, _) = try await newAccount("enclave1", store: store, keyStore: keyStore, platform: "Mac Studio")145 let v = try await personal(a)146 let id = try await a.engine.saveItem(vaultId: v, item: login("Hardware"))147 let devs = try await a.engine.devices()148 XCTAssertEqual(devs.count, 1)149 XCTAssertTrue(devs[0].hardware, "the server is told the keys are hardware-bound")150 XCTAssertTrue(devs[0].verified)151 XCTAssertEqual(try psql("select hardware from devices where id = '\(devs[0].deviceId)'"), "t")152 // the Keychain holds opaque Secure Enclave blobs, not private keys153 let keys = try XCTUnwrap(try keyStore.loadKeys(context: nil))154 XCTAssertTrue(keys.isHardwareBound)155 XCTAssertEqual(keys.encPub, try psql("select enc_pub from devices where id = '\(devs[0].deviceId)'"))156157 // restart + offline unlock with the enclave key; one LAContext covers both keys158 let api2 = TestTransport()159 api2.offline = true160 let engine2 = VaultEngine(transport: api2, store: store, keyStore: keyStore, passkeys: a.auth, platformLabel: "Mac Studio")161 let state = try await engine2.load()162 XCTAssertEqual(state, .locked)163 let context = LAContext()164 context.touchIDAuthenticationAllowableReuseDuration = 10165 try await engine2.unlock(context: context, backgroundSync: false)166 let got = await engine2.get(vaultId: v, id: id)167 XCTAssertEqual(got?.item.title, "Hardware")168 // step-up with the enclave signing key (no passkey), then a strong operation169 api2.offline = false170 try psql("update sessions set strong_at = now() - interval '1 hour'")171 let before = a.auth.getCount172 let rk2 = try await engine2.rotateRecoveryKey()173 XCTAssertEqual(a.auth.getCount, before, "native step-up does not use the passkey")174 XCTAssertTrue(rk2.hasPrefix("SPV1-"))175 // passkey sign-in with the enclave device proof176 await engine2.lock()177 let s = try await engine2.signIn()178 XCTAssertEqual(s, .unlocked)179 // a second device paired from a software-key device: the enclave device certifies it180 let b = try await pair(Dev(engine: engine2, api: api2, store: store, keyStore: keyStore, auth: a.auth))181 let bGot = await b.engine.get(vaultId: v, id: id)182 XCTAssertEqual(bGot?.item.title, "Hardware")183 // the reader (AutoFill) works with the same Keychain items184 XCTAssertEqual(try VaultReader(store: store, keyStore: keyStore).unlock(context: LAContext()).logins().count, 1)185 try await engine2.forget()186 XCTAssertNil(try keyStore.loadIdentity())187 XCTAssertNil(try keyStore.loadKeys(context: nil))188 }189190 func testKeychainSoftwareFallbackReportsHardwareFalse() async throws {191 let keyStore = SecureEnclaveKeyStore(service: "ai.spboucher.vault.test.\(UUID().uuidString)", policy: .none, useDataProtectionKeychain: false, preferSecureEnclave: false)192 addTeardownBlock { try? keyStore.clear() }193 XCTAssertFalse(keyStore.hardwareBacked)194 do {195 try keyStore.saveSessionToken("probe"); try keyStore.clear()196 } catch { throw XCTSkip("the Keychain is not usable in this process: \(error)") }197 let store = MemoryStore()198 let (a, _) = try await newAccount("softkeys1", store: store, keyStore: keyStore)199 let devs = try await a.engine.devices()200 XCTAssertFalse(devs[0].hardware)201 XCTAssertFalse(try XCTUnwrap(try keyStore.loadKeys(context: nil)).isHardwareBound)202 XCTAssertEqual(try keyStore.loadIdentity()?.handle, "softkeys1")203 XCTAssertNotNil(try keyStore.loadSessionToken())204 let engine2 = VaultEngine(transport: TestTransport(), store: store, keyStore: keyStore, passkeys: a.auth, platformLabel: "Test device")205 try await engine2.load()206 try await engine2.unlock(backgroundSync: false)207 try await engine2.sync() // the token restored from the Keychain is accepted208 let n = await engine2.vaults().count209 XCTAssertEqual(n, 1)210 }211212 func testStepUpUsesDeviceKeyAndFallsBackToPasskeyForWebLabelledDevices() async throws {213 let (a, _) = try await newAccount("stepup1")214 let b = try await pair(a, platform: "Second device")215 let bId = try unwrap(await b.engine.deviceIdentity).deviceId216 try psql("update sessions set strong_at = now() - interval '1 hour'")217 await assertRejects({ try await a.api.request("DELETE", "/api/v1/devices/\(bId)") }, apiCode("reauth_required"))218 let before = a.auth.getCount219 try await a.engine.revokeDevice(deviceId: bId)220 XCTAssertEqual(a.auth.getCount, before, "step-up was a device-key signature")221 XCTAssertTrue(a.api.paths.contains("POST /api/v1/auth/stepup/verify"))222 XCTAssertTrue(a.api.sent.contains("deviceProof"))223 // a device whose platform label starts with "Web" must present a passkey: the engine falls back by itself224 let (w, _) = try await newAccount("stepup2", platform: "Web test client")225 try psql("update sessions set strong_at = now() - interval '1 hour'")226 let beforeW = w.auth.getCount227 _ = try await w.engine.rotateRecoveryKey()228 XCTAssertEqual(w.auth.getCount, beforeW + 1, "passkey fallback")229 // a forged device proof is refused230 try psql("update sessions set strong_at = now() - interval '1 hour'")231 let o = try await a.api.request("POST", "/api/v1/auth/stepup/options", [:])232 let forged = SPV1.b64u(try SPV1.sign(key: SPV1.generateSigKey(), message: try SPV1.ctx("stepup", try XCTUnwrap(o["options"]?["challenge"]?.stringValue), try unwrap(await a.engine.deviceIdentity).deviceId)))233 await assertRejects({ try await a.api.request("POST", "/api/v1/auth/stepup/verify", ["challengeId": try XCTUnwrap(o["challengeId"]), "deviceProof": .string(forged)]) }, apiCode("authentication_failed"))234 }235236 func testExpiredBearerSessionRaisesNeedsSignInAndUserActionsReauthenticate() async throws {237 let (a, _) = try await newAccount("expired1")238 let v = try await personal(a)239 let changes = ChangeCounter(a.engine.changes)240 let deviceId = try unwrap(await a.engine.deviceIdentity).deviceId241 try psql("delete from sessions where device_id = '\(deviceId)'")242 // background path: a write is queued, the flag is raised, nothing prompts243 let before = a.auth.getCount244 let id = try await a.engine.saveItem(vaultId: v, item: login("While signed out"))245 var h = await a.engine.syncHealth()246 XCTAssertEqual(h.pending, 1)247 XCTAssertTrue(h.needsSignIn)248 XCTAssertEqual(a.auth.getCount, before)249 await assertRejects({ try await a.engine.sync() }, apiStatus(401))250 // user-driven action: passkey + device proof, transparently, then the action itself251 let devs = try await a.engine.devices()252 XCTAssertEqual(devs.count, 1)253 XCTAssertEqual(a.auth.getCount, before + 1)254 h = await a.engine.syncHealth()255 XCTAssertFalse(h.needsSignIn)256 try await a.engine.sync()257 h = await a.engine.syncHealth()258 XCTAssertEqual(h.pending, 0)259 XCTAssertEqual(try psql("select count(*) from records where id = '\(id)'"), "1")260 // sign-out drops the token; offline unlock still works, syncing asks for a sign-in261 await a.engine.signOut()262 XCTAssertNil(try a.keyStore.loadSessionToken())263 try await a.engine.unlockOffline()264 let count = await a.engine.list().count265 XCTAssertEqual(count, 1)266 await assertRejects({ try await a.engine.sync() }, apiStatus(401))267 let s = try await a.engine.signIn()268 XCTAssertEqual(s, .unlocked)269 try await a.engine.sync()270 XCTAssertGreaterThan(changes.count, 3, "the change stream fires")271 }272273 func testPasskeyOfAnotherAccountDoesNotEraseTheDevice() async throws {274 let (a, _) = try await newAccount("wrongacct1"), (other, _) = try await newAccount("wrongacct2")275 let v = try await personal(a)276 try await a.engine.saveItem(vaultId: v, item: login())277 // the user picks the passkey of another account on a device enrolled for account A278 let mixed = VaultEngine(transport: a.api, store: a.store, keyStore: a.keyStore, passkeys: other.auth, platformLabel: "Test device")279 try await mixed.load()280 await assertRejects({ try await mixed.signIn() }, apiCode("wrong_account"))281 XCTAssertNotNil(try a.keyStore.loadIdentity(), "the device identity is kept")282 XCTAssertEqual(try a.store.load().vaults.count, 1, "local data is kept")283 try await mixed.unlockOffline()284 let n = await mixed.list().count285 XCTAssertEqual(n, 1)286 // with the right passkey the same device signs in normally287 await a.engine.lock()288 let s = try await a.engine.signIn()289 XCTAssertEqual(s, .unlocked)290 }291292 /// A conflict whose resolution is interrupted by a network drop must not lose the local edit.293 func testConflictResolutionInterruptedByNetworkDropKeepsTheEdit() async throws {294 let (a, _) = try await newAccount("dropconf1")295 let flaky = FlakyTransport()296 let b = try await pairWith(a, transport: flaky)297 let v = try await personal(a)298 let id = try await a.engine.saveItem(vaultId: v, item: login("Flaky"))299 try await b.sync()300 flaky.offline = true301 var mine = try unwrap(await b.get(vaultId: v, id: id)).item302 mine.notes = "edit that must survive"303 try await b.saveItem(vaultId: v, id: id, item: mine)304 var theirs = try unwrap(await a.engine.get(vaultId: v, id: id)).item305 theirs.notes = "server version"306 try await a.engine.saveItem(vaultId: v, id: id, item: theirs)307 // back online, but the connection drops right after the server answered 409 to the write308 flaky.offline = false309 flaky.failAfterNextConflict = true310 try await b.sync()311 var h = await b.syncHealth()312 XCTAssertEqual(h.pending, 1, "the edit is still queued")313 XCTAssertFalse(h.online)314 try await b.sync()315 h = await b.syncHealth()316 XCTAssertEqual(h.pending, 0)317 let winner = await b.get(vaultId: v, id: id)318 XCTAssertEqual(winner?.item.notes, "server version")319 let copy = await b.list().first { $0.item.conflictOf == id }320 XCTAssertEqual(copy?.item.notes, "edit that must survive")321 try await a.engine.sync()322 let da = await a.engine.stateDigest(), db = await b.stateDigest()323 XCTAssertEqual(da, db)324 }325326 func testAuditChainConnectHumanSideAndBreachCheck() async throws {327 let (a, _) = try await newAccount("audit1")328 let v = try await personal(a)329 try await a.engine.saveItem(vaultId: v, item: login())330 _ = try await a.engine.createVault(meta: VaultMeta(name: "Second", kind: .work))331 // Connect, human side (the managed-secrets service is not started here: identities and the kill switch do not need it)332 let overview = try await a.engine.connect()333 XCTAssertFalse(overview.enabled)334 XCTAssertFalse(overview.killed)335 let identity = try await a.engine.createIdentity(name: "ci-runner", kind: "service")336 XCTAssertEqual(try SPV1.unb64u(identity.privateKey).count, 97)337 try await a.engine.setKillSwitch(engaged: true)338 var c = try await a.engine.connect()339 XCTAssertTrue(c.killed)340 XCTAssertEqual(c.identities.map(\.name), ["ci-runner"])341 try await a.engine.setKillSwitch(engaged: false)342 try await a.engine.revokeIdentity(id: identity.id)343 c = try await a.engine.connect()344 XCTAssertFalse(c.killed)345 XCTAssertEqual(c.identities.first?.revoked, true)346 await assertRejects({ try await a.engine.createManagedSecret(NewManagedSecret(name: "s", kind: "raw", config: .object(JSONObject()), value: "managed-value")) }, apiStatus(503))347 await assertRejects({ try await a.engine.decideApproval(id: SPV1.uuid(), approve: true) }, apiStatus(404))348 await assertRejects({ try await a.engine.revokeGrant(id: SPV1.uuid()) }, apiStatus(404))349350 let events = try await a.engine.audit()351 XCTAssertGreaterThanOrEqual(events.count, 6)352 XCTAssertTrue(events.map(\.kind).contains("connect.kill_engaged"))353 var ok = await a.engine.verifyAuditPage(events)354 XCTAssertTrue(ok)355 let older = try await a.engine.audit(before: events[2].id)356 XCTAssertEqual(older.first?.id, events[3].id)357 ok = await a.engine.verifyAuditPage(older)358 XCTAssertTrue(ok)359 // an altered or removed event breaks the chain360 var removed = events361 removed.remove(at: 2)362 ok = await a.engine.verifyAuditPage(removed)363 XCTAssertFalse(ok)364 try psql("update audit_events set kind = 'vault.deleted' where id = \(events[1].id)")365 let altered = try await a.engine.audit()366 ok = await a.engine.verifyAuditPage(altered)367 XCTAssertFalse(ok)368 // breach check: only the 5-character prefix leaves the device (the upstream is stubbed by the harness)369 let n = try await a.engine.breachCheck(password: SECRET_PW)370 XCTAssertEqual(n, 0)371 let prefix = SPV1.breachPrefix(SECRET_PW)372 XCTAssertTrue(a.api.paths.contains("GET /api/v1/breach/range/\(prefix.prefix)"))373 XCTAssertFalse(a.api.sent.contains(prefix.suffix))374 }375}376377/// Counts the events of the engine's change stream.378final class ChangeCounter: @unchecked Sendable {379 private let lock = NSLock()380 private var n = 0381 private var task: Task<Void, Never>?382 init(_ stream: AsyncStream<Void>) { task = Task { [weak self] in for await _ in stream { self?.bump() } } }383 deinit { task?.cancel() }384 private func bump() { lock.lock(); n += 1; lock.unlock() }385 var count: Int { lock.lock(); defer { lock.unlock() }; return n }386}387388/// Creates an empty SQLite database file (a database the app never initialised).389func sqlite3Touch(_ path: String) {390 _ = try? runTool("sqlite3", [path, "PRAGMA user_version = 1;"])391}392393/// A transport that can drop the connection right after the server answered a conflict (409) to a record write.394final class FlakyTransport: VaultTransport, @unchecked Sendable {395 private let inner = TestTransport()396 private let lock = NSLock()397 private var _failAfterNextConflict = false, _dropNext = false398 var offline: Bool { get { inner.offline } set { inner.offline = newValue } }399 var failAfterNextConflict: Bool {400 get { lock.withLock { _failAfterNextConflict } }401 set { lock.withLock { _failAfterNextConflict = newValue } }402 }403 func send(_ method: String, _ path: String, body: JSONValue?, options: TransportOptions) async throws -> Data {404 if lock.withLock({ let d = _dropNext; _dropNext = false; return d }) { throw ApiError.offline }405 do { return try await inner.send(method, path, body: body, options: options) }406 catch let e as ApiError where e.status == 409 && method == "PUT" {407 lock.withLock { if _failAfterNextConflict { _failAfterNextConflict = false; _dropNext = true } }408 throw e409 }410 }411 func setBearerToken(_ token: String?) async { await inner.setBearerToken(token) }412}413414/// Pairs a new device that uses the given transport.415func pairWith(_ trusted: Dev, transport: any VaultTransport) async throws -> VaultEngine {416 let engine = VaultEngine(transport: transport, store: MemoryStore(), keyStore: InMemoryKeyStore(), passkeys: trusted.auth, platformLabel: "Flaky device")417 guard try await engine.signIn() == .pending else { throw ShellError(description: "expected a pending session") }418 let offer = try await engine.startPairing()419 try await trusted.engine.approvePairing(try await trusted.engine.inspectPairing(code: offer.code))420 guard try await engine.checkPairing() == .done else { throw ShellError(description: "pairing did not complete") }421 return engine422}423