SPB Git

Repository Public

NativeTests.swift 24.8 KB 423 lines swift

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
Files main
Menu

Theme