@peers-app/peers-sdk 0.25.14 → 0.25.16

package/dist/data/workflows.d.ts

@@ -2,8 +2,8 @@ import type { DataContext } from "../context/data-context";
 export declare function Workflows(dataContext?: DataContext): import("..").Table<{
     name: string;
     description: string;
-    createdAt: Date;
     updatedAt: Date;
+    createdAt: Date;
     workflowId: string;
     defaultAssistantId: string;
     instructions: {

package/dist/device/connection.d.ts

@@ -71,9 +71,9 @@ export declare class Connection {
     /** Copy of the authenticated remote device identity (empty before the handshake). */
     get remoteDeviceInfo(): {
         publicKey: string;
-        publicBoxKey: string;
         userId: string;
         deviceId: string;
+        publicBoxKey: string;
         userName?: string | undefined;
         deviceName?: string | undefined;
     };
@@ -140,6 +140,12 @@ export declare class Connection {
      * frame cipher is armed in both directions before this resolves.
      */
     doHandshake(remoteAddress: string): Promise<IDeviceHandshake>;
+    /**
+     * Resets this side and asks the remote to do the same. The remote call is a courtesy: a
+     * peer that is not a server has no `reset` handler, and a peer we just refused may already
+     * be gone, so its failure is logged and never allowed to escape as an unhandled rejection.
+     */
+    private resetRemote;
     private closeLocal;
     /** Round-trip time in milliseconds. @throws if the connection is not verified */
     ping(): Promise<number>;

package/dist/device/connection.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connection = void 0;
 exports.normalizeAddress = normalizeAddress;
+const user_context_singleton_1 = require("../context/user-context-singleton");
 const data_1 = require("../data");
+const key_change_1 = require("../identity/key-change");
 const keys_1 = require("../keys");
 const peer_device_1 = require("../types/peer-device");
 const utils_1 = require("../utils");
@@ -370,7 +372,7 @@ class Connection {
             ephemeralSecretKey = ephemeral.secretKey;
             frameCrypto = { version: 1, ephemeralBoxKey: (0, keys_1.encodeBase64)(ephemeral.publicKey) };
         }
-        const handshake = this.localDevice.getHandshake(this.connectionId, serverAddress, frameCrypto);
+        const handshake = this.localDevice.getHandshake(this.connectionId, serverAddress, frameCrypto, (0, key_change_1.peekLocalKeyContest)());
         if (ephemeralSecretKey) {
             this.pendingClientHandshake = {
                 ephemeralSecretKey,
@@ -418,7 +420,8 @@ class Connection {
             });
             frameKeys = (0, frame_cipher_1.frameKeysForRole)(derived, "server");
         }
-        const handshakeResponse = this.localDevice.handshakeResponse(signedHandshake, this.connectionId, thisServerAddress, frameCrypto);
+        const handshakeResponse = this.localDevice.handshakeResponse(signedHandshake, this.connectionId, thisServerAddress, frameCrypto, (0, key_change_1.peekLocalKeyContest)());
+        await noteHandshakeContest(_handshake.keyContest);
         this._remoteDeviceInfo = {
             userId: _handshake.userId,
             deviceId: _handshake.deviceId,
@@ -429,8 +432,7 @@ class Connection {
         };
         this.trustLevel = await this.getTrustLevel(_handshake, true);
         if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
-            this.reset();
-            this.emit("reset");
+            this.resetRemote();
             throw new Error("Untrusted connection");
         }
         this._verified = true;
@@ -465,9 +467,16 @@ class Connection {
         if (remoteDeviceInfoSigned.publicKey !== remoteDeviceInfo.publicKey) {
             throw new Error("Device info signing key does not match claimed identity key");
         }
+        if (remoteDeviceInfo.userId === this.localDevice.userId &&
+            remoteDeviceInfo.publicKey !== this.localDevice.publicKey) {
+            // The server will refuse this handshake. Decide here, while we still have the signed
+            // identity, whether the anchors say this device's key was rotated away.
+            await (0, key_change_1.detectIdentityRotatedAway)(this.localDevice, remoteDeviceInfo);
+        }
         const handshake = await this.initiateHandshake(remoteAddress, remoteDeviceInfo);
         const handshakeResponseBox = await this.emit("completeHandshake", handshake);
         const handshakeResponse = data_1.deviceHandshakeSchema.parse(await this.localDevice.openBoxedAndSignedData(handshakeResponseBox));
+        await noteHandshakeContest(handshakeResponse.keyContest);
         if (handshakeResponse.connectionId !== this.connectionId) {
             throw new Error(`Invalid connectionId ${handshakeResponse.connectionId}, expected ${this.connectionId}`);
         }
@@ -522,12 +531,22 @@ class Connection {
         }
         this.trustLevel = await this.getTrustLevel(currentRemoteDeviceInfo, true);
         if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
-            this.reset();
-            this.emit("reset");
+            this.resetRemote();
             throw new Error("Untrusted connection");
         }
         return handshakeResponse;
     }
+    /**
+     * Resets this side and asks the remote to do the same. The remote call is a courtesy: a
+     * peer that is not a server has no `reset` handler, and a peer we just refused may already
+     * be gone, so its failure is logged and never allowed to escape as an unhandled rejection.
+     */
+    resetRemote() {
+        this.reset();
+        this.emit("reset").catch((err) => {
+            console.warn(`Remote reset was not acknowledged: ${err?.error ?? err?.message ?? err}`);
+        });
+    }
     closeLocal() {
         this.reset();
         this.removeAllListeners();
@@ -559,6 +578,19 @@ class Connection {
     }
 }
 exports.Connection = Connection;
+async function noteHandshakeContest(contest) {
+    if (!contest)
+        return;
+    const userContext = (0, user_context_singleton_1.peekUserContext)();
+    if (!userContext)
+        return;
+    try {
+        await (0, key_change_1.applyKeyContest)(userContext.userDataContext, contest);
+    }
+    catch (err) {
+        console.warn("Could not apply a key contest from the handshake", err);
+    }
+}
 /** Normalizes a peer address for transport and security comparisons. */
 function normalizeAddress(address) {
     return address.toLowerCase().replace(/\/$/, "");

package/dist/device/connection.test.js

@@ -7,14 +7,19 @@ const binary_peer_connection_v2_1 = require("./binary-peer-connection-v2");
 const connection_1 = require("./connection");
 const device_1 = require("./device");
 const frame_cipher_1 = require("./frame-cipher");
+const socket_type_1 = require("./socket.type");
 function createTestSocket(localHandlers, remoteHandlers) {
     const socket = {
         id: (0, utils_1.newid)(),
         emit(eventName, args, callback) {
-            remoteHandlers.forEach(async ({ eventName: _eventName, handler }) => {
-                if (eventName === _eventName) {
-                    handler(args, callback);
-                }
+            const matching = remoteHandlers.filter(({ eventName: _eventName }) => eventName === _eventName);
+            if (matching.length === 0) {
+                // Same answer the real transports give for an event nobody handles.
+                callback?.(`No handler registered for event: ${eventName}`);
+                return;
+            }
+            matching.forEach(async ({ handler }) => {
+                handler(args, callback);
             });
         },
         on(eventName, handler) {
@@ -254,6 +259,30 @@ describe(connection_1.Connection, () => {
         const result = await clientConnection.doHandshake(serverAddress).catch((err) => String(err));
         expect(result).toMatch(/Inconsistent public keys/);
     });
+    it("refuses an untrusted client without leaving an unhandled rejection behind", async () => {
+        // The server tells the client to reset as a courtesy. A client that is not itself a
+        // server has no `reset` handler, so that call fails; the failure must not escape as an
+        // unhandled rejection, which would take down a host with no process-level handler
+        // (peers-services) every time a device presents a retired key.
+        const serverAddress = "http://localhost";
+        const { clientSocket, serverSocket } = createTestSocketPair();
+        const clientConnection = new connection_1.Connection(clientSocket, new device_1.Device());
+        const serverConnection = new connection_1.Connection(serverSocket, new device_1.Device(), [serverAddress], () => Promise.resolve(socket_type_1.TrustLevel.Untrusted));
+        const unhandled = jest.fn();
+        process.on("unhandledRejection", unhandled);
+        try {
+            const result = await clientConnection
+                .doHandshake(serverAddress)
+                .catch((err) => err?.error ?? String(err));
+            expect(result).toMatch(/Untrusted connection/);
+            await (0, utils_1.sleep)(20);
+            expect(unhandled).not.toHaveBeenCalled();
+            expect(serverConnection.verified).toBe(false);
+        }
+        finally {
+            process.off("unhandledRejection", unhandled);
+        }
+    });
     it("should handle RPC calls with large arguments and responses", async () => {
         const { clientSocket, serverSocket } = createTestSocketPair();
         const clientDevice = new device_1.Device();

package/dist/device/device.d.ts

@@ -73,13 +73,13 @@ export declare class Device implements IDeviceInfo {
      * Builds and signs the client half of a connection handshake.
      * @param frameCrypto Include to advertise frame-cipher support with this connection's ephemeral key.
      */
-    getHandshake(connectionId: string, serverAddress: string, frameCrypto?: IHandshakeFrameCrypto): ISignedObject<IDeviceHandshake>;
+    getHandshake(connectionId: string, serverAddress: string, frameCrypto?: IHandshakeFrameCrypto, keyContest?: IDeviceHandshake["keyContest"]): ISignedObject<IDeviceHandshake>;
     /**
      * Validates a client handshake (signature, claimed key, connection ID) and
      * builds the unsigned server response. `Connection` signs and boxes it.
      * @param frameCrypto Include to accept the client's frame-cipher offer with this side's ephemeral key.
      */
-    handshakeResponse(remoteHandshake: ISignedObject<IDeviceHandshake>, connectionId: string, thisServerAddress: string, frameCrypto?: IHandshakeFrameCrypto): IDeviceHandshake;
+    handshakeResponse(remoteHandshake: ISignedObject<IDeviceHandshake>, connectionId: string, thisServerAddress: string, frameCrypto?: IHandshakeFrameCrypto, keyContest?: IDeviceHandshake["keyContest"]): IDeviceHandshake;
     private deviceInfoSigned;
     /** Returns cached signed identity information, refreshing after display metadata changes. */
     getDeviceInfo(): ISignedObject<IDeviceInfo>;

package/dist/device/device.js

@@ -135,7 +135,7 @@ class Device {
      * Builds and signs the client half of a connection handshake.
      * @param frameCrypto Include to advertise frame-cipher support with this connection's ephemeral key.
      */
-    getHandshake(connectionId, serverAddress, frameCrypto) {
+    getHandshake(connectionId, serverAddress, frameCrypto, keyContest) {
         try {
             const localDeviceInfo = data_1.deviceHandshakeSchema.parse({
                 connectionId,
@@ -148,6 +148,7 @@ class Device {
                 serverAddress,
                 timestamp: Date.now(),
                 frameCrypto,
+                ...(keyContest ? { keyContest } : {}),
             });
             const localDeviceInfoSigned = this.signObjectWithSecretKey(localDeviceInfo);
             return localDeviceInfoSigned;
@@ -161,7 +162,7 @@ class Device {
      * builds the unsigned server response. `Connection` signs and boxes it.
      * @param frameCrypto Include to accept the client's frame-cipher offer with this side's ephemeral key.
      */
-    handshakeResponse(remoteHandshake, connectionId, thisServerAddress, frameCrypto) {
+    handshakeResponse(remoteHandshake, connectionId, thisServerAddress, frameCrypto, keyContest) {
         try {
             const deviceInfo = data_1.deviceHandshakeSchema.parse((0, keys_1.openSignedObject)(remoteHandshake));
             if (remoteHandshake.publicKey !== deviceInfo.publicKey) {
@@ -181,6 +182,7 @@ class Device {
                 serverAddress: thisServerAddress,
                 timestamp: Date.now(),
                 frameCrypto,
+                ...(keyContest ? { keyContest } : {}),
             });
             return handshakeResponse;
         }

package/dist/device/get-trust-level-fn.d.ts

@@ -5,5 +5,6 @@ import { TrustLevel } from "./socket.type";
  *
  * Known user keys are authoritative even for a newly observed device: a claimed identity
  * whose signing or box key differs from the stored user record is rejected as untrusted.
+ * Accepting a different key waits for the anchors on record to confirm it (identity anchors).
  */
 export declare function getTrustLevelFn(me: Pick<IDeviceInfo, "userId" | "publicKey" | "publicBoxKey">, serverUrl?: string): (deviceInfo: IDeviceInfo, _registerNew?: boolean) => Promise<TrustLevel>;

package/dist/device/get-trust-level-fn.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTrustLevelFn = getTrustLevelFn;
 const context_1 = require("../context");
 const data_1 = require("../data");
+const key_change_1 = require("../identity/key-change");
 const socket_type_1 = require("./socket.type");
 function applyReportedDeviceName(device, deviceInfo) {
     if (deviceInfo.deviceName) {
@@ -18,11 +19,18 @@ function boundStoredDeviceNames(device) {
  *
  * Known user keys are authoritative even for a newly observed device: a claimed identity
  * whose signing or box key differs from the stored user record is rejected as untrusted.
+ * Accepting a different key waits for the anchors on record to confirm it (identity anchors).
  */
 function getTrustLevelFn(me, serverUrl) {
     return async function getTrustLevel(deviceInfo, _registerNew) {
         const userContext = await (0, context_1.getUserContext)();
         const userDataContext = userContext.userDataContext;
+        if (deviceInfo.userId === me.userId && deviceInfo.publicKey !== me.publicKey) {
+            // Same user, different key. Anchors decide whether this device was rotated away.
+            // Either way the connection is refused: this device does not hold the key it was shown.
+            await (0, key_change_1.detectIdentityRotatedAway)(me, deviceInfo);
+            return socket_type_1.TrustLevel.Untrusted;
+        }
         // if this is my own device it is trusted
         if (deviceInfo.userId === me.userId &&
             deviceInfo.publicKey === me.publicKey &&
@@ -85,13 +93,29 @@ function getTrustLevelFn(me, serverUrl) {
         const effectiveUser = user ?? groupUser;
         if (effectiveUser &&
             (deviceInfo.userId !== effectiveUser.userId ||
-                deviceInfo.publicKey !== effectiveUser.publicKey ||
-                deviceInfo.publicBoxKey !== effectiveUser.publicBoxKey ||
                 (device ? deviceInfo.userId !== device.userId : false))) {
-            // deviceInfo does not align with local info about the user or device, return Untrusted
-            // TODO check if user has changed their public keys
             return socket_type_1.TrustLevel.Untrusted;
         }
+        if (effectiveUser &&
+            (deviceInfo.publicKey !== effectiveUser.publicKey ||
+                deviceInfo.publicBoxKey !== effectiveUser.publicBoxKey)) {
+            // A different box key for the key on record is a mismatch. A different signing key is
+            // accepted only when the anchors on record confirm a rotation.
+            if (deviceInfo.publicKey === effectiveUser.publicKey) {
+                return socket_type_1.TrustLevel.Untrusted;
+            }
+            const decision = await (0, key_change_1.evaluatePresentedKey)({
+                dataContext: userDataContext,
+                userId: deviceInfo.userId,
+                presentedKey: deviceInfo.publicKey,
+                presentedBoxKey: deviceInfo.publicBoxKey,
+                record: user ?? groupUser ?? undefined,
+            });
+            if (!decision.accepted) {
+                return socket_type_1.TrustLevel.Untrusted;
+            }
+            user = (await (0, data_1.Users)(userDataContext).get(deviceInfo.userId)) ?? user;
+        }
         if (userTrustLevel?.trustLevel &&
             userTrustLevel.trustLevel >= socket_type_1.TrustLevel.Trusted &&
             device?.trustLevel &&

package/dist/device/get-trust-level-fn.test.js

@@ -11,8 +11,13 @@ jest.mock("../data", () => ({
     Users: jest.fn(),
     UserTrustLevels: jest.fn(),
 }));
+jest.mock("../identity/key-change", () => ({
+    evaluatePresentedKey: jest.fn(async () => ({ accepted: false, state: "pending" })),
+    detectIdentityRotatedAway: jest.fn(async () => undefined),
+}));
 const context_1 = require("../context");
 const data_1 = require("../data");
+const key_change_1 = require("../identity/key-change");
 const mockGetUserContext = context_1.getUserContext;
 const mockDevices = data_1.Devices;
 const mockUsers = data_1.Users;
@@ -587,4 +592,94 @@ describe("getTrustLevelFn", () => {
             expect(mockUserTrustLevels).toHaveBeenCalled();
         });
     });
+    describe("anchor confirmation", () => {
+        it("accepts a different key when the anchors confirm a rotation", async () => {
+            const me = makeTestIdentity();
+            const other = makeTestIdentity();
+            const existingUser = {
+                userId: other.userId,
+                publicKey: `stored_${(0, utils_1.newid)()}`,
+                publicBoxKey: `stored_box_${(0, utils_1.newid)()}`,
+                name: "Alice",
+            };
+            const { usersTable } = setupMocks(null, existingUser, null);
+            usersTable.get.mockResolvedValueOnce(existingUser).mockResolvedValueOnce({
+                ...existingUser,
+                publicKey: other.publicKey,
+                publicBoxKey: other.publicBoxKey,
+            });
+            key_change_1.evaluatePresentedKey.mockResolvedValueOnce({
+                accepted: true,
+                state: "confirmed-rotation",
+            });
+            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me);
+            const result = await getTrustLevel(other);
+            expect(key_change_1.evaluatePresentedKey).toHaveBeenCalledWith(expect.objectContaining({
+                userId: other.userId,
+                presentedKey: other.publicKey,
+            }));
+            expect(result).toBe(socket_type_1.TrustLevel.NewDevice);
+        });
+        it("writes nothing for a contact's key the anchors have not confirmed", async () => {
+            // Pending, vetoed, and a recovery still in its delay all land here: the handshake is
+            // refused and neither a device record nor a user stub is created for the presenter.
+            const me = makeTestIdentity();
+            const other = makeTestIdentity();
+            const existingUser = {
+                userId: other.userId,
+                publicKey: `stored_${(0, utils_1.newid)()}`,
+                publicBoxKey: `stored_box_${(0, utils_1.newid)()}`,
+                name: "Alice",
+            };
+            for (const state of ["pending", "vetoed", "recovery-pending"]) {
+                const { usersTable, devTable } = setupMocks(null, existingUser, null);
+                key_change_1.evaluatePresentedKey.mockResolvedValueOnce({ accepted: false, state });
+                const result = await (0, get_trust_level_fn_1.getTrustLevelFn)(me)(other);
+                expect(result).toBe(socket_type_1.TrustLevel.Untrusted);
+                expect(usersTable.save).not.toHaveBeenCalled();
+                expect(devTable.save).not.toHaveBeenCalled();
+            }
+        });
+        it("judges a group-only contact's new key against the group row and copies nothing into the personal table", async () => {
+            const me = makeTestIdentity();
+            const other = makeTestIdentity();
+            const groupUser = {
+                userId: other.userId,
+                publicKey: `stored_${(0, utils_1.newid)()}`,
+                publicBoxKey: `stored_box_${(0, utils_1.newid)()}`,
+                name: "Alice",
+            };
+            const { usersTable, devTable } = setupMocks(null, null, null);
+            const groupUsersTable = makeUsersTable(groupUser);
+            const groupTrustTable = makeTrustTable({ trustLevel: socket_type_1.TrustLevel.Known });
+            const groupContext = { dataContextId: "group" };
+            mockGetUserContext.mockResolvedValue({
+                userDataContext: {},
+                groupDataContexts: new Map([["group", groupContext]]),
+            });
+            mockUsers.mockImplementation(((context) => context === groupContext ? groupUsersTable : usersTable));
+            mockUserTrustLevels.mockImplementation(((context) => context === groupContext ? groupTrustTable : makeTrustTable(null)));
+            key_change_1.evaluatePresentedKey.mockResolvedValueOnce({
+                accepted: true,
+                state: "confirmed-rotation",
+            });
+            const result = await (0, get_trust_level_fn_1.getTrustLevelFn)(me)(other);
+            expect(key_change_1.evaluatePresentedKey).toHaveBeenCalledWith(expect.objectContaining({ userId: other.userId, record: groupUser }));
+            // The group row is the only record; it is not copied into the personal table.
+            expect(usersTable.save).not.toHaveBeenCalled();
+            expect(groupUsersTable.save).not.toHaveBeenCalled();
+            expect(devTable.save).toHaveBeenCalledTimes(1);
+            expect(result).toBe(socket_type_1.TrustLevel.NewDevice);
+        });
+        it("treats another device of this user on a different key as untrusted", async () => {
+            const me = makeTestIdentity();
+            const otherDevice = { ...me, deviceId: (0, utils_1.newid)(), publicKey: `other_${(0, utils_1.newid)()}` };
+            setupMocks();
+            const getTrustLevel = (0, get_trust_level_fn_1.getTrustLevelFn)(me);
+            const result = await getTrustLevel(otherDevice);
+            expect(result).toBe(socket_type_1.TrustLevel.Untrusted);
+            expect(key_change_1.detectIdentityRotatedAway).toHaveBeenCalledWith(me, expect.objectContaining({ userId: me.userId, publicKey: otherDevice.publicKey }));
+            expect(mockUsers).not.toHaveBeenCalled();
+        });
+    });
 });