SPB Git

Repository Public

CoreScenarioTests.swift 34.4 KB 549 lines swift

1// Every scenario of tests/integration/core.test.ts, with the Swift engine on every device, against the real server.2import CryptoKit3import Foundation4import XCTest5@testable import SharedVaultKit67final class CoreScenarioTests: ServerTestCase {8    func testAccountCreationItemCrudAndServerNeverReceivesPlaintext() async throws {9        let (a, recoveryKey) = try await newAccount("alice")10        XCTAssertNotNil(recoveryKey.range(of: "^SPV1(-[0-9A-Z]{4}){14}$", options: .regularExpression))11        let v = try await personal(a)12        let id = try await a.engine.saveItem(vaultId: v, item: login())13        let got = await a.engine.get(vaultId: v, id: id)14        XCTAssertEqual(got?.item.fields["password"], SECRET_PW)15        let pendingCount = await a.engine.syncHealth().pending16        XCTAssertEqual(pendingCount, 0)17        // everything the client ever sent, and everything the database holds18        let sent = a.api.sent19        var dump = ""20        for t in ["accounts", "devices", "records", "record_history", "vaults", "vault_grants", "audit_events", "sessions", "credentials"] {21            dump += try psql("select row_to_json(t) from \(t) t") + "\n"22        }23        XCTAssertTrue(dump.contains("alice") && sent.contains("alice"), "sanity: the handle is visible, so the dump and the log are real")24        for needle in [SECRET_TITLE, SECRET_PW, SECRET_USER, "zanzibar", "note-ZQ9", "tag-zq9", "JBSWY3DPEHPK3PXP", "Personal", recoveryKey, recoveryKey.replacingOccurrences(of: "-", with: "")] {25            XCTAssertFalse(sent.contains(needle), "client sent plaintext: \(needle)")26            XCTAssertFalse(dump.contains(needle), "database holds plaintext: \(needle)")27        }28        var edited = try unwrap(await a.engine.get(vaultId: v, id: id)).item29        edited.fields["password"] = "second-password-ZQ9"30        try await a.engine.saveItem(vaultId: v, id: id, item: edited)31        let after = await a.engine.get(vaultId: v, id: id)32        XCTAssertEqual(after?.item.passwordHistory.first?.value, SECRET_PW)33        let history = try await a.engine.history(vaultId: v, id: id)34        XCTAssertEqual(history.count, 1)35        XCTAssertEqual(history.first?.item.fields["password"], SECRET_PW)36        try await a.engine.trashItem(vaultId: v, id: id)37        let trashed = await a.engine.get(vaultId: v, id: id)38        XCTAssertNotNil(trashed?.item.trashedAt)39        try await a.engine.restoreItem(vaultId: v, id: id)40        let restored = await a.engine.get(vaultId: v, id: id)41        XCTAssertNil(restored?.item.trashedAt)42        try await a.engine.deleteItem(vaultId: v, id: id)43        let gone = await a.engine.get(vaultId: v, id: id)44        XCTAssertNil(gone)45        // native session model: no cookie, the token came in the body and is kept by the key store only46        let token = try XCTUnwrap(try a.keyStore.loadSessionToken())47        XCTAssertFalse(sent.contains(token))48        XCTAssertEqual(try psql("select count(*) from sessions where token_hash = '\(SPV1.b64u(SPV1.sha256(SPV1.utf8(token))))'"), "1")49    }5051    func testTwoDevicesPairingSyncBothWaysLockUnlock() async throws {52        let (a, _) = try await newAccount("bob")53        let v = try await personal(a)54        let id = try await a.engine.saveItem(vaultId: v, item: login("From A"))55        let b = try await pair(a)56        let fromA = await b.engine.get(vaultId: v, id: id)57        XCTAssertEqual(fromA?.item.title, "From A")58        let id2 = try await b.engine.saveItem(vaultId: v, item: login("From B"))59        try await a.engine.sync()60        let fromB = await a.engine.get(vaultId: v, id: id2)61        XCTAssertEqual(fromB?.item.fields["password"], SECRET_PW)62        let da = await a.engine.stateDigest(), db = await b.engine.stateDigest()63        XCTAssertEqual(da, db)64        XCTAssertNotNil(da.range(of: "^[0-9A-F]{4} [0-9A-F]{4} [0-9A-F]{4}$", options: .regularExpression))65        let devs = try await a.engine.devices()66        XCTAssertEqual(devs.count, 2)67        XCTAssertTrue(devs.allSatisfy(\.verified))68        XCTAssertEqual(devs.filter(\.current).count, 1)69        await b.engine.lock()70        let lockedList = await b.engine.list()71        XCTAssertTrue(lockedList.isEmpty)72        await assertRejects { try await b.engine.sync() } _: { ($0 as? EngineError) == .locked }73        let s = try await b.engine.signIn()74        XCTAssertEqual(s, .unlocked)75        let n1 = await b.engine.list().count76        XCTAssertEqual(n1, 2)77        // offline unlock from the cached envelope: no request at all78        await b.engine.lock()79        b.api.offline = true80        try await b.engine.unlockOffline()81        let n2 = await b.engine.list().count82        XCTAssertEqual(n2, 2)83        b.api.offline = false84    }8586    func testPairingSubstitutedKeysDetectedAndSetupCodeAloneEnrolsNothing() async throws {87        let (a, _) = try await newAccount("carol")88        let b = device(auth: a.auth)89        _ = try await b.engine.signIn()90        let offer = try await b.engine.startPairing()91        let evil = SPV1.b64u(SPV1.generateKemKey().publicKey.x963Representation)92        let pairingId = try SPV1.decodePairingCode(offer.code).pairingId93        try psql("update pairings set enc_pub = '\(evil)' where id = '\(pairingId)'")94        await assertRejects { try await a.engine.inspectPairing(code: offer.code) } _: { if case .security = $0 as? EngineError { return true }; return false }95        // pending session (passkey only) has no access to anything encrypted96        await assertRejects({ try await b.api.request("POST", "/api/v1/sync", [:]) }, apiStatus(403))97        await assertRejects({ try await b.api.request("GET", "/api/v1/devices") }, apiStatus(403))98        let st = try await b.engine.checkPairing()99        XCTAssertEqual(st, .pending)100        // an attacker holding only the code (no passkey session, not a trusted device) cannot approve101        let mallory = device()102        await assertRejects({ try await mallory.api.request("POST", "/api/v1/pairings/\(pairingId)/approve", ["cert": .string(String(repeating: "A", count: 86)), "arkEnvelope": .string(String(repeating: "A", count: 151))]) }, apiStatus(401))103        // a rejected request is reported to the new device104        try psql("update pairings set enc_pub = (select enc_pub from devices limit 0) where false") // no-op: the substituted key stays105        let c = device(auth: a.auth)106        _ = try await c.engine.signIn()107        let offer2 = try await c.engine.startPairing()108        let req = try await a.engine.inspectPairing(code: offer2.code)109        XCTAssertEqual(req.sas, offer2.sas)110        try await a.engine.rejectPairing(req)111        let st2 = try await c.engine.checkPairing()112        XCTAssertEqual(st2, .rejected)113    }114115    func testFreshDeviceRestoreWithRecoveryKeyAndRotation() async throws {116        let (a, recoveryKey) = try await newAccount("dave")117        let v = try await personal(a)118        let id = try await a.engine.saveItem(vaultId: v, item: login("Survives"))119        let fresh = device(auth: SoftwarePasskeys(), platform: "Replacement")120        let typo = String(recoveryKey.dropLast()) + (recoveryKey.hasSuffix("A") ? "B" : "A")121        await assertRejects { try await fresh.engine.recover(handle: "dave", recoveryKey: typo) } _: { ($0 as? VaultError) == .recoveryKeyChecksum }122        XCTAssertTrue(fresh.api.paths.isEmpty, "the checksum is verified before any network request")123        let wrong = try SPV1.encodeRecoveryKey(SPV1.random(32))124        await assertRejects({ try await fresh.engine.recover(handle: "dave", recoveryKey: wrong) }, apiStatus(401))125        try await fresh.engine.recover(handle: "dave", recoveryKey: recoveryKey)126        let survived = await fresh.engine.get(vaultId: v, id: id)127        XCTAssertEqual(survived?.item.title, "Survives")128        try await fresh.engine.addPasskey(label: "new")129        let passkeys = try await fresh.engine.listPasskeys()130        XCTAssertEqual(passkeys.count, 2)131        XCTAssertTrue(passkeys.contains { $0.label == "new" })132        await fresh.engine.lock()133        let s = try await fresh.engine.signIn()134        XCTAssertEqual(s, .unlocked)135        let kinds = try await fresh.engine.audit().map(\.kind)136        XCTAssertTrue(kinds.contains("recovery.started") && kinds.contains("device.enrolled"))137        // rotation: the old key stops working, the new one works138        let rk2 = try await fresh.engine.rotateRecoveryKey()139        await assertRejects({ try await device().engine.recover(handle: "dave", recoveryKey: recoveryKey) }, apiStatus(401))140        let again = device()141        try await again.engine.recover(handle: "dave", recoveryKey: rk2)142        let n = await again.engine.list().count143        XCTAssertEqual(n, 1)144        // tolerant typing of the recovery key (lower case, no prefix, look-alike characters)145        let typed = rk2.lowercased().replacingOccurrences(of: "spv1-", with: "").replacingOccurrences(of: "0", with: "o").replacingOccurrences(of: "1", with: "l")146        let third = device()147        try await third.engine.recover(handle: "dave", recoveryKey: typed)148        let n3 = await third.engine.list().count149        XCTAssertEqual(n3, 1)150    }151152    func testOfflineEditsQueuedAndConcurrentEditsNeverLoseData() async throws {153        let (a, _) = try await newAccount("erin")154        let b = try await pair(a)155        let v = try await personal(a)156        let id = try await a.engine.saveItem(vaultId: v, item: login("Shared item"))157        try await b.engine.sync()158        b.api.offline = true159        var mine = try unwrap(await b.engine.get(vaultId: v, id: id)).item160        mine.notes = "edited offline on B"161        try await b.engine.saveItem(vaultId: v, id: id, item: mine)162        let offlineNew = try await b.engine.saveItem(vaultId: v, item: login("Created offline"))163        let h = await b.engine.syncHealth()164        XCTAssertEqual(h.pending, 2)165        XCTAssertFalse(h.online)166        let pendingItem = await b.engine.get(vaultId: v, id: id)167        XCTAssertEqual(pendingItem?.pending, true)168        var theirs = try unwrap(await a.engine.get(vaultId: v, id: id)).item169        theirs.notes = "edited online on A"170        try await a.engine.saveItem(vaultId: v, id: id, item: theirs)171        b.api.offline = false172        try await b.engine.sync()173        try await a.engine.sync()174        let h2 = await b.engine.syncHealth()175        XCTAssertEqual(h2.pending, 0)176        XCTAssertTrue(h2.online)177        for d in [a, b] {178            let it = await d.engine.get(vaultId: v, id: id)179            XCTAssertEqual(it?.item.notes, "edited online on A")180            let copy = await d.engine.list().first { $0.item.conflictOf == id }181            XCTAssertNotNil(copy, "conflict copy exists")182            XCTAssertEqual(copy?.item.notes, "edited offline on B")183            XCTAssertEqual(copy?.item.title, "Shared item (conflict copy)")184            let created = await d.engine.get(vaultId: v, id: offlineNew)185            XCTAssertNotNil(created)186        }187        let da = await a.engine.stateDigest(), db = await b.engine.stateDigest()188        XCTAssertEqual(da, db)189    }190191    func testRevokedDeviceLosesAccessAndWipesItself() async throws {192        let (a, _) = try await newAccount("frank")193        let b = try await pair(a)194        let bId = try unwrap(await b.engine.deviceIdentity).deviceId195        try await a.engine.revokeDevice(deviceId: bId)196        await assertRejects({ try await b.api.request("POST", "/api/v1/sync", [:]) }, apiStatus(401))197        await assertRejects({ try await b.engine.sync() }, apiStatus(401))198        let flagged = await b.engine.needsSignIn199        XCTAssertTrue(flagged)200        await b.engine.lock()201        await assertRejects({ try await b.engine.signIn() }, apiCode("device_revoked"))202        let identity = await b.engine.deviceIdentity203        XCTAssertNil(identity)204        XCTAssertNil(try b.keyStore.loadIdentity())205        XCTAssertNil(try b.keyStore.loadKeys(context: nil))206        XCTAssertNil(try b.keyStore.loadSessionToken())207        XCTAssertEqual(try b.store.load(), PersistedState())208        XCTAssertEqual(try psql("select ark_envelope from devices where id = '\(bId)'"), "")209        let devs = try await a.engine.devices()210        XCTAssertEqual(devs.count, 1)211    }212213    func testMaliciousServerForgedSwappedRelabelledAndRolledBackRecordsAreRejected() async throws {214        let (a, _) = try await newAccount("grace")215        let v = try await personal(a)216        let id1 = try await a.engine.saveItem(vaultId: v, item: login("One")), id2 = try await a.engine.saveItem(vaultId: v, item: login("Two"))217        var edit = try unwrap(await a.engine.get(vaultId: v, id: id1)).item218        edit.notes = "v2"219        try await a.engine.saveItem(vaultId: v, id: id1, item: edit)220        let b = try await pair(a)221        let r1 = try psql("select envelope from records where id = '\(id1)'"), r1rev = try psql("select rev from records where id = '\(id1)'")222        let r2 = try psql("select envelope from records where id = '\(id2)'")223        let old = try psql("select envelope from record_history where id = '\(id1)' and rev = 1")224        XCTAssertEqual(r1rev, "2")225        // (1) swap two ciphertexts, (2) replay revision 1 as revision 3, (3) roll back to revision 1, (4) fake a deletion — each bumps seq so clients look226        func tamper(_ set: String) throws {227            try psql("update records set \(set), seq = (select seq + 1 from vaults where id = '\(v)') where id = '\(id1)'; update vaults set seq = seq + 1 where id = '\(v)';")228        }229        func notes() async -> String? { await b.engine.get(vaultId: v, id: id1)?.item.notes }230        try tamper("envelope = '\(r2)'::jsonb")231        try await b.engine.sync()232        var n = await notes()233        XCTAssertEqual(n, "v2", "swapped ciphertext not applied")234        var warnings = await b.engine.syncHealth().warnings235        XCTAssertTrue(warnings.contains { $0.contains("failed authentication") })236        try tamper("envelope = '\(old)'::jsonb, rev = 3")237        try await b.engine.sync()238        n = await notes()239        XCTAssertEqual(n, "v2", "re-labelled old revision not applied")240        try tamper("envelope = '\(old)'::jsonb, rev = 1")241        try await b.engine.sync()242        n = await notes()243        XCTAssertEqual(n, "v2")244        warnings = await b.engine.syncHealth().warnings245        XCTAssertTrue(warnings.contains { $0.contains("rollback") })246        try tamper("envelope = '\(r1)'::jsonb, rev = \(r1rev), deleted = true")247        try await b.engine.sync()248        let still = await b.engine.get(vaultId: v, id: id1)249        XCTAssertNotNil(still, "faked deletion not applied")250        let undecryptable = await b.engine.syncHealth().undecryptable251        XCTAssertGreaterThanOrEqual(undecryptable, 2)252        // a vault-level rollback (older seq than the cursor) is reported and nothing is overwritten253        try psql("update vaults set seq = 1 where id = '\(v)'")254        try await b.engine.sync()255        warnings = await b.engine.syncHealth().warnings256        XCTAssertTrue(warnings.contains { $0.contains("older state of a vault") })257        n = await notes()258        XCTAssertEqual(n, "v2")259    }260261    func testAttachmentsChunkedUploadResumeAndTamperDetection() async throws {262        let (a, _) = try await newAccount("heidi")263        let v = try await personal(a)264        let big = SPV1.random(2 * 1024 * 1024 + 12345)265        let progress = ProgressBox()266        let ref = try await a.engine.upload(vaultId: v, name: "passeport-secret.pdf", mime: "application/pdf", data: big) { done, total in progress.set(done, total) }267        XCTAssertEqual(ref.chunks, 3)268        XCTAssertEqual(progress.last?.0, 3)269        var it = SPV1.newItem(.document, title: "Passport")270        it.attachments = [ref]271        let id = try await a.engine.saveItem(vaultId: v, item: it)272        let b = try await pair(a)273        let remoteRef = try unwrap(await b.engine.get(vaultId: v, id: id)?.item.attachments.first)274        let downloaded = try await b.engine.download(remoteRef)275        XCTAssertEqual(downloaded, big)276        XCTAssertFalse(try psql("select row_to_json(t) from attachments t").contains("passeport"))277        XCTAssertFalse(a.api.sent.contains("passeport"))278        // partial upload then resume (raw API, as in the TypeScript suite)279        let id2 = SPV1.uuid()280        let (ref2, chunks) = try SPV1.newAttachment(id: id2, name: "x", mime: "text/plain", plaintext: big)281        let declare: JSONValue = ["id": .string(id2), "chunks": .number(Double(ref2.chunks)), "size": .number(Double(ref2.size))]282        try await a.api.request("POST", "/api/v1/vaults/\(v)/attachments", declare)283        _ = try await a.api.requestRaw("PUT", "/api/v1/attachments/\(id2)/chunks/1", nil, options: TransportOptions(binary: chunks[1]))284        await assertRejects({ try await a.api.request("POST", "/api/v1/attachments/\(id2)/complete", [:]) }, apiCode("incomplete"))285        let resumed = try await a.api.request("POST", "/api/v1/vaults/\(v)/attachments", declare)286        XCTAssertEqual(resumed["uploaded"], [1])287        await assertRejects({ try await a.api.requestRaw("PUT", "/api/v1/attachments/\(id2)/chunks/0", nil, options: TransportOptions(binary: Data(chunks[0].dropFirst()))) }, apiStatus(400))288        // reordered / truncated chunks fail authentication289        assertThrowsVault(.authenticationFailed) { try SPV1.openAttachment(ref: ref2, chunks: [chunks[1], chunks[0], chunks[2]]) }290        var shorter = ref2291        shorter.chunks = 2292        assertThrowsVault(.authenticationFailed) { try SPV1.openAttachment(ref: shorter, chunks: Array(chunks.prefix(2))) }293294        // engine-level resume: an upload interrupted after the first chunk continues where it stopped295        let up = try await a.engine.prepareUpload(vaultId: v, name: "resume.bin", mime: "application/octet-stream", data: big)296        try await a.api.request("POST", "/api/v1/vaults/\(v)/attachments", ["id": .string(up.ref.id), "chunks": .number(Double(up.ref.chunks)), "size": .number(Double(up.ref.size))])297        _ = try await a.api.requestRaw("PUT", "/api/v1/attachments/\(up.ref.id)/chunks/0", nil, options: TransportOptions(binary: up.chunks[0]))298        let before = a.api.paths.count299        let done = try await a.engine.resumeUpload(up)300        let puts = a.api.paths[before...].filter { $0.hasPrefix("PUT /api/v1/attachments/\(up.ref.id)/chunks/") }301        XCTAssertEqual(puts.count, 2, "only the missing chunks are sent again")302        // download resume: chunks already fetched are not requested again303        let c0 = try await a.engine.downloadChunk(done, index: 0)304        let before2 = a.api.paths.count305        let again = try await a.engine.download(done, cached: [0: c0])306        XCTAssertEqual(again, big)307        XCTAssertEqual(a.api.paths[before2...].count, 2)308        // a chunk altered by the server is detected309        var bad = c0310        bad[bad.startIndex + 100] ^= 1311        await assertRejects { try await a.engine.download(done, cached: [0: bad]) } _: { ($0 as? VaultError) == .authenticationFailed }312    }313314    func testSharedVaultBetweenAccountsAndMemberRemovalRotatesKey() async throws {315        let (a, _) = try await newAccount("ivan"), (b, _) = try await newAccount("judy")316        let shared = try await a.engine.createVault(meta: VaultMeta(name: "Famille", kind: .shared))317        let id = try await a.engine.saveItem(vaultId: shared, item: login("Wi-Fi maison"))318        let judy = try await a.engine.lookupAccount(handle: "judy")319        XCTAssertNotNil(judy.fingerprint.range(of: "^([0-9A-F]{4} ){4}[0-9A-F]{4}$", options: .regularExpression))320        try await a.engine.addMember(vaultId: shared, member: judy, role: .reader)321        try await b.engine.sync()322        let seen = await b.engine.get(vaultId: shared, id: id)323        XCTAssertEqual(seen?.item.fields["password"], SECRET_PW)324        let name = await b.engine.vaults().first { $0.vaultId == shared }?.meta.name325        XCTAssertEqual(name, "Famille")326        await assertRejects { try await b.engine.saveItem(vaultId: shared, item: login("nope")) } _: { ($0 as? EngineError) == .readOnly }327        let envelope = try JSONValue.parse(try psql("select envelope from records where id = '\(id)'"))328        await assertRejects({ try await b.api.request("PUT", "/api/v1/vaults/\(shared)/records/\(SPV1.uuid())", ["type": "item", "baseRev": 0, "envelope": envelope]) }, apiCode("read_only"))329        try await a.engine.addMember(vaultId: shared, member: judy, role: .editor)330        try await b.engine.sync()331        let id2 = try await b.engine.saveItem(vaultId: shared, item: login("Added by Judy"))332        try await a.engine.sync()333        let added = await a.engine.get(vaultId: shared, id: id2)334        XCTAssertNotNil(added)335        // removal336        try await a.engine.rotateVaultKey(vaultId: shared, remove: [judy.accountId])337        try await b.engine.sync()338        let vaultGone = await b.engine.vaults().first { $0.vaultId == shared }339        XCTAssertNil(vaultGone)340        let itemGone = await b.engine.get(vaultId: shared, id: id)341        XCTAssertNil(itemGone)342        await assertRejects({ try await b.api.request("GET", "/api/v1/vaults/\(shared)/records/\(id)/history") }, apiStatus(404))343        let kids = try psql("select distinct envelope->>'kid' from records where vault_id = '\(shared)'")344        XCTAssertEqual(kids, "2", "all records re-encrypted under the new epoch")345        var edit = try unwrap(await a.engine.get(vaultId: shared, id: id)).item346        edit.notes = "after removal"347        try await a.engine.saveItem(vaultId: shared, id: id, item: edit)348        XCTAssertEqual(try psql("select count(*) from vault_grants where vault_id = '\(shared)' and member_id = '\(judy.accountId)'"), "0")349        let pendingCount = await a.engine.syncHealth().pending350        XCTAssertEqual(pendingCount, 0)351        // pinning of foreign keys: a server that swaps the owner's public keys is refused by the member352        let shared2 = try await a.engine.createVault(meta: VaultMeta(name: "Second", kind: .shared))353        try await a.engine.addMember(vaultId: shared2, member: judy, role: .reader)354        let ivanId = try unwrap(await a.engine.deviceIdentity).accountId355        let realSig = try psql("select sig_pub from accounts where id = '\(ivanId)'")356        try psql("update accounts set sig_pub = '\(SPV1.b64u(SPV1.generateSigKey().publicKey.x963Representation))' where id = '\(ivanId)'")357        try await b.engine.sync()358        let refused = await b.engine.vaults().first { $0.vaultId == shared2 }359        XCTAssertNil(refused, "a vault whose owner keys changed since first seen is not opened")360        let warnings = await b.engine.syncHealth().warnings361        XCTAssertTrue(warnings.contains { $0.contains("changed since first seen") })362        try psql("update accounts set sig_pub = '\(realSig)' where id = '\(ivanId)'")363    }364365    func testRelayShareToAccountAndByLinkWithViewLimitExpiryAndRevocation() async throws {366        let (a, _) = try await newAccount("kate"), (b, _) = try await newAccount("liam")367        let liam = try await a.engine.lookupAccount(handle: "liam")368        let sid = try await a.engine.shareWithAccount(item: login("Netflix"), recipient: liam, expiresInSec: 3600, maxViews: 2)369        let got = try await b.engine.openShare(id: sid)370        XCTAssertEqual(got.item.fields["password"], SECRET_PW)371        XCTAssertEqual(got.from, "kate")372        XCTAssertFalse(got.fingerprintKnown)373        let second = try await b.engine.openShare(id: sid)374        XCTAssertTrue(second.fingerprintKnown)375        await assertRejects({ try await b.engine.openShare(id: sid) }, apiStatus(404), "view limit enforced")376        XCTAssertFalse(try psql("select row_to_json(t) from shares t").contains("Netflix"))377        let lists = try await a.engine.shares()378        XCTAssertEqual(lists.sent.first?.id, sid)379        XCTAssertEqual(lists.sent.first?.views, 2)380        let url = try await a.engine.shareByLink(item: login("Door code"), origin: "https://vault.example", expiresInSec: 3600, maxViews: 1)381        let parts = try XCTUnwrap(url.range(of: "#/s/")).upperBound382        let seg = url[parts...].split(separator: "/").map(String.init)383        let shareId = seg[0], secret = try SPV1.unb64u(seg[1])384        let anon = device()385        let k = try SPV1.linkKeys(secret: secret, shareId: shareId)386        await assertRejects({ try await anon.api.request("POST", "/api/v1/public/shares/\(shareId)", ["auth": .string(SPV1.b64u(SPV1.random(32)))]) }, apiStatus(404))387        let opened = try await VaultEngine.openLinkShare(url: url, transport: anon.api)388        XCTAssertEqual(opened.title, "Door code")389        XCTAssertFalse(anon.api.sent.contains(seg[1]), "the fragment secret never reaches the server")390        await assertRejects({ try await anon.api.request("POST", "/api/v1/public/shares/\(shareId)", ["auth": .string(k.auth)]) }, apiStatus(410), "one-time retrieval")391        let url2 = try await a.engine.shareByLink(item: login("Revoked"), origin: "https://vault.example", expiresInSec: 3600, maxViews: 5)392        let seg2 = url2[try XCTUnwrap(url2.range(of: "#/s/")).upperBound...].split(separator: "/").map(String.init)393        try await a.engine.revokeShare(id: seg2[0])394        await assertRejects({ try await VaultEngine.openLinkShare(url: url2, transport: anon.api) }, apiStatus(410))395        XCTAssertEqual(try psql("select box from shares where id = '\(seg2[0])'"), "", "revocation erases the ciphertext")396        let events = try await a.engine.audit()397        let kinds = events.map(\.kind)398        XCTAssertTrue(kinds.contains("share.created") && kinds.contains("share.opened") && kinds.contains("share.revoked"))399        let chainOk = await a.engine.verifyAuditPage(events)400        XCTAssertTrue(chainOk)401    }402403    func testAccountRekeyAfterCompromiseEncryptedBackupAndRestore() async throws {404        let (a, recoveryKey) = try await newAccount("mona")405        let b = try await pair(a)406        let v = try await personal(a)407        let id = try await a.engine.saveItem(vaultId: v, item: login("Before rekey"))408        let backup = try await a.engine.exportBackup()409        XCTAssertFalse(backup.contains("Before rekey") || backup.contains(SECRET_PW))410        let bId = try unwrap(await b.engine.deviceIdentity).deviceId411        let oldEnvelope = try psql("select ark_envelope from devices where id = '\(bId)'")412        let rk2 = try await a.engine.rekeyAccount()413        XCTAssertNotEqual(try psql("select ark_envelope from devices where id = '\(bId)'"), oldEnvelope)414        XCTAssertEqual(try psql("select distinct envelope->>'kid' from records where vault_id = '\(v)'"), "2")415        // the other device was signed out; it notices, and after signing in again it reads everything with the new keys416        await assertRejects({ try await b.engine.sync() }, apiStatus(401))417        let needs = await b.engine.needsSignIn418        XCTAssertTrue(needs)419        await b.engine.lock()420        let s = try await b.engine.signIn()421        XCTAssertEqual(s, .unlocked)422        try await b.engine.sync()423        let needsAfter = await b.engine.needsSignIn424        XCTAssertFalse(needsAfter)425        let seen = await b.engine.get(vaultId: v, id: id)426        XCTAssertEqual(seen?.item.title, "Before rekey")427        // the rekeying device itself still unlocks offline with its new cached envelope428        await a.engine.lock()429        try await a.engine.unlockOffline()430        let count = await a.engine.list().count431        XCTAssertEqual(count, 1)432        await assertRejects({ try await device().engine.recover(handle: "mona", recoveryKey: recoveryKey) }, apiStatus(401))433        let fresh = device()434        try await fresh.engine.recover(handle: "mona", recoveryKey: rk2)435        let recovered = await fresh.engine.get(vaultId: v, id: id)436        XCTAssertNotNil(recovered)437        // offline backup: opens with the recovery key valid at the time, without the server438        let opened = try SPV1.openBackup(try SPV1.parseBackup(backup), secret: .recoveryKey(try SPV1.decodeRecoveryKey(recoveryKey)))439        XCTAssertEqual(opened.payload.vaults.first?.items.first?.item.title, "Before rekey")440        XCTAssertThrowsError(try SPV1.openBackup(try SPV1.parseBackup(backup), secret: .recoveryKey(try SPV1.decodeRecoveryKey(rk2))))441        await assertRejects { try await a.engine.restoreBackup(text: backup) } _: { ($0 as? EngineError) == .backupNeedsRecoveryKey }442        let n = try await a.engine.restoreBackup(text: backup, recoveryKey: recoveryKey)443        XCTAssertEqual(n, 1)444        let vaultCount = await a.engine.vaults().count445        XCTAssertEqual(vaultCount, 2)446        var tampered = try XCTUnwrap(JSONValue.parse(backup).objectValue)447        let ct = try XCTUnwrap(tampered["ct"]?.stringValue)448        tampered["ct"] = .string(String(ct.dropLast(4)) + "AAAA")449        await assertRejects { try await a.engine.restoreBackup(text: JSONValue.object(tampered).serializedString(), recoveryKey: recoveryKey) }450        // plaintext export needs a fresh step-up and leaves a trace451        let csv = try await a.engine.exportPlaintext(format: .csv)452        XCTAssertTrue(csv.contains("Before rekey") && csv.contains(SECRET_PW))453        let json = try await a.engine.exportPlaintext(format: .json)454        XCTAssertTrue(json.contains("\"vaults\": ["))455        let kinds = try await a.engine.audit().map(\.kind)456        XCTAssertTrue(kinds.contains("export.plaintext") && kinds.contains("account.rekeyed"))457    }458459    func testInvitationsAreSingleUseAndImport() async throws {460        let token = try makeInvite()461        let a = device()462        _ = try await a.engine.register(invite: token, handle: "nina")463        await assertRejects({ try await device().engine.register(invite: token, handle: "oscar") }, apiCode("invalid_invite"))464        let other = try makeInvite()465        await assertRejects({ try await device().engine.register(invite: other, handle: "nina") }, apiCode("handle_taken"))466        let res = try SPV1.importAny(fileName: "passwords.csv", text: "Title,URL,Username,Password,Notes,OTPAuth\r\n\"Ex, ample\",https://example.com,u1,\"p\"\"w\",,\r\nSecond,https://second.test,u2,pw2,\"multi\nline\",otpauth://totp/x?secret=JBSWY3DPEHPK3PXP\r\n")467        XCTAssertEqual(res.format, .apple)468        XCTAssertEqual(res.items[0].title, "Ex, ample")469        XCTAssertEqual(res.items[0].fields["password"], "p\"w")470        let v = try await personal(a)471        let n = try await a.engine.importItems(vaultId: v, items: res.items)472        XCTAssertEqual(n, 2)473        let found = await a.engine.search("second u2")474        XCTAssertEqual(found.count, 1)475        // move between vaults: a new record in the target, a tombstone in the source476        let work = try await a.engine.createVault(meta: VaultMeta(name: "Work", kind: .work))477        let moved = try await a.engine.moveItem(fromVault: v, id: found[0].recordId, toVault: work)478        let inWork = await a.engine.get(vaultId: work, id: moved)479        XCTAssertEqual(inWork?.item.title, "Second")480        let source = await a.engine.get(vaultId: v, id: found[0].recordId)481        XCTAssertNil(source)482        try await a.engine.renameVault(vaultId: work, meta: VaultMeta(name: "Travail", kind: .work))483        let renamed = await a.engine.vaults().first { $0.vaultId == work }?.meta.name484        XCTAssertEqual(renamed, "Travail")485        try await a.engine.deleteVault(vaultId: work)486        let remaining = await a.engine.vaults().map(\.vaultId)487        XCTAssertEqual(remaining, [v])488    }489}490491extension CoreScenarioTests {492    /// Writes the server refuses for good (permission lost while offline) are dropped with a warning, never retried493    /// forever and never silently kept; a write sealed under a rotated key is re-sealed and goes through.494    func testPermanentlyRefusedWritesAndStaleKeyResealing() async throws {495        let (a, _) = try await newAccount("peggy"), (b, _) = try await newAccount("quinn")496        let shared = try await a.engine.createVault(meta: VaultMeta(name: "Projet", kind: .shared))497        let id = try await a.engine.saveItem(vaultId: shared, item: login("Projet item"))498        let quinn = try await a.engine.lookupAccount(handle: "quinn")499        try await a.engine.addMember(vaultId: shared, member: quinn, role: .editor)500        try await b.engine.sync()501        // stale key: B edits offline, the owner rotates the vault key meanwhile502        b.api.offline = true503        var edit = try unwrap(await b.engine.get(vaultId: shared, id: id)).item504        edit.notes = "sealed under epoch 1"505        try await b.engine.saveItem(vaultId: shared, id: id, item: edit)506        try await a.engine.rotateVaultKey(vaultId: shared, remove: [])507        b.api.offline = false508        try await b.engine.sync()509        var h = await b.engine.syncHealth()510        XCTAssertEqual(h.pending, 0)511        XCTAssertEqual(h.warnings, [])512        try await a.engine.sync()513        let resealed = await a.engine.get(vaultId: shared, id: id)514        XCTAssertEqual(resealed?.item.notes, "sealed under epoch 1", "the offline edit was re-sealed under the new epoch, not lost")515        XCTAssertEqual(try psql("select envelope->>'kid' from records where id = '\(id)'"), "2")516        let noCopy = await b.engine.list().contains { $0.item.conflictOf != nil }517        XCTAssertFalse(noCopy)518        // refused for good: B is downgraded to reader while holding an offline edit519        b.api.offline = true520        var edit2 = try unwrap(await b.engine.get(vaultId: shared, id: id)).item521        edit2.notes = "will be refused"522        try await b.engine.saveItem(vaultId: shared, id: id, item: edit2)523        let created = try await b.engine.saveItem(vaultId: shared, item: login("Also refused"))524        try await a.engine.addMember(vaultId: shared, member: quinn, role: .reader)525        b.api.offline = false526        try await b.engine.sync()527        h = await b.engine.syncHealth()528        XCTAssertEqual(h.pending, 0, "refused writes do not stay queued")529        XCTAssertTrue(h.warnings.contains { $0.contains("refused by the server (read_only)") }, "\(h.warnings)")530        let local = await b.engine.get(vaultId: shared, id: id)531        XCTAssertEqual(local?.item.notes, "sealed under epoch 1", "the local view went back to the server's version")532        let ghost = await b.engine.get(vaultId: shared, id: created)533        XCTAssertNil(ghost)534        XCTAssertEqual(try psql("select count(*) from records where id = '\(created)'"), "0")535        await assertRejects { try await b.engine.saveItem(vaultId: shared, item: login("nope")) } _: { ($0 as? EngineError) == .readOnly }536    }537}538539final class ProgressBox: @unchecked Sendable {540    private let lock = NSLock()541    private var value: (Int, Int)?542    func set(_ a: Int, _ b: Int) { lock.lock(); value = (a, b); lock.unlock() }543    var last: (Int, Int)? { lock.lock(); defer { lock.unlock() }; return value }544}545546func assertThrowsVault<T>(_ expected: VaultError, file: StaticString = #filePath, line: UInt = #line, _ body: () throws -> T) {547    XCTAssertThrowsError(try body(), file: file, line: line) { XCTAssertEqual($0 as? VaultError, expected, file: file, line: line) }548}549
Files main
Menu

Theme