sliftutils 1.7.141 → 1.7.142

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.141",
+    "version": "1.7.142",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/security/machines/identity2.ts

@@ -5,36 +5,32 @@ import { getTrustedMachines } from "./machines";
 
 const MAX_SIGNED_AGE = 5 * 60 * 1000;
 
-// A request says who it is from AND who it believes it is talking to. The "to" is whatever both
-// sides use to identify the server - an IP, a machineId, a threadId - and being inside the signed
-// payload is what stops a machine in the middle: a request addressed to someone else cannot be
-// replayed at the real server, and the middleman cannot write requests of its own because it is
-// not a trusted machine.
 export type SignedRequest<T> = {
     signature: string;
     payload: {
+        // When it was signed - anything older than MAX_SIGNED_AGE is refused
         time: number;
-        to: string;
+        // Who the sender believes it is talking to: an IP, a machineId, a threadId - whatever
+        // both sides use to name the server. Being inside the signed payload is what stops a
+        // machine in the middle: a request addressed to someone else cannot be replayed at the
+        // real server, and the middleman cannot write requests of its own because it is not a
+        // trusted machine.
+        targetId: string;
+        // The thread certificate that signed this
         cert: string;
+        // The machine CA that issued cert - the machineId comes from its common name
         certIssuer: string;
         data: T;
     };
 };
 
-// The reply echoes the request it answers, with the data collapsed to its hash - resending the
-// data would say nothing the hash does not. Signed by the replying thread's certificate, which
-// chains to its machine CA, which is where the machineId comes from.
 export type SignedReply<T> = {
     signature: string;
     payload: {
         time: number;
-        request: {
-            time: number;
-            to: string;
-            cert: string;
-            certIssuer: string;
-            dataHash: string;
-        };
+        // The request this reply answers, with the data collapsed to its hash - resending the
+        // data would say nothing the hash does not
+        request: Omit<SignedRequest<unknown>["payload"], "data"> & { dataHash: string };
         cert: string;
         certIssuer: string;
         data: T;
@@ -45,12 +41,12 @@ function dataHash(data: unknown) {
     return sha256.sha256(JSON.stringify(data));
 }
 
-export function signRequest<T>(domain: string, config: { to: string; data: T }): SignedRequest<T> {
+export function signRequest<T>(domain: string, config: { targetId: string; data: T }): SignedRequest<T> {
     let threadKeyCert = getThreadKeyCert(domain);
     let issuer = getIdentityCA(domain);
-    let payload = {
+    let payload: SignedRequest<T>["payload"] = {
         time: Date.now(),
-        to: config.to,
+        targetId: config.targetId,
         cert: threadKeyCert.cert.toString(),
         certIssuer: issuer.cert.toString(),
         data: config.data,
@@ -58,11 +54,17 @@ export function signRequest<T>(domain: string, config: { to: string; data: T }):
     return { signature: sign(threadKeyCert, payload), payload };
 }
 
-/** Returns the machineId that signed, and the data. Throws if the signature, certificate chain,
-    or time do not check out, or if the request was addressed to someone we are not: ownIdentities
-    is every name this server answers to - its IPs (there are always several, internal and
-    external), its machineId, its threadId - and the signed "to" must be one of them. */
-export function verifyRequest<T>(domain: string, signed: SignedRequest<T>, ownIdentities: string[]): { machineId: string; data: T } {
+/** Returns the machineId that signed, the data, and reply - which signs a reply to exactly this
+    request, so a reply cannot be produced for a request that was never verified. Throws if the
+    signature, certificate chain, or time do not check out, or if the request was addressed to
+    someone we are not: ownIdentities is every name this server answers to - its IPs (there are
+    always several, internal and external), its machineId, its threadId - and the signed targetId
+    must be one of them. */
+export function verifyRequest<T>(domain: string, signed: SignedRequest<T>, ownIdentities: string[]): {
+    machineId: string;
+    data: T;
+    reply<R>(data: R): SignedReply<R>;
+} {
     let { signature, payload } = signed;
     let signedThreshold = Date.now() - MAX_SIGNED_AGE;
     if (payload.time < signedThreshold) {
@@ -70,30 +72,27 @@ export function verifyRequest<T>(domain: string, signed: SignedRequest<T>, ownId
     }
     verify(payload.cert, signature, payload);
     validateCertificate(domain, payload.cert, payload.certIssuer);
-    if (!ownIdentities.includes(payload.to)) {
-        throw new Error(`Request is for someone else. It is addressed to ${payload.to}, we are ${ownIdentities.join(", ")}`);
+    if (!ownIdentities.includes(payload.targetId)) {
+        throw new Error(`Request is for someone else. It is addressed to ${payload.targetId}, we are ${ownIdentities.join(", ")}`);
     }
     let machineId = getMachineId(getCommonName(payload.certIssuer), domain);
-    return { machineId, data: payload.data };
-}
-
-export function signReply<T>(domain: string, request: SignedRequest<unknown>, data: T): SignedReply<T> {
-    let threadKeyCert = getThreadKeyCert(domain);
-    let issuer = getIdentityCA(domain);
-    let payload = {
-        time: Date.now(),
-        request: {
-            time: request.payload.time,
-            to: request.payload.to,
-            cert: request.payload.cert,
-            certIssuer: request.payload.certIssuer,
-            dataHash: dataHash(request.payload.data),
+    return {
+        machineId,
+        data: payload.data,
+        reply<R>(data: R): SignedReply<R> {
+            let threadKeyCert = getThreadKeyCert(domain);
+            let issuer = getIdentityCA(domain);
+            let { data: requestData, ...requestRest } = payload;
+            let replyPayload: SignedReply<R>["payload"] = {
+                time: Date.now(),
+                request: { ...requestRest, dataHash: dataHash(requestData) },
+                cert: threadKeyCert.cert.toString(),
+                certIssuer: issuer.cert.toString(),
+                data,
+            };
+            return { signature: sign(threadKeyCert, replyPayload), payload: replyPayload };
         },
-        cert: threadKeyCert.cert.toString(),
-        certIssuer: issuer.cert.toString(),
-        data,
     };
-    return { signature: sign(threadKeyCert, payload), payload };
 }
 
 /** Returns the machineId that replied, and the data. Throws if the signature, certificate chain,
@@ -108,13 +107,9 @@ export async function verifyReply<T>(domain: string, request: SignedRequest<unkn
     }
     verify(payload.cert, signature, payload);
     validateCertificate(domain, payload.cert, payload.certIssuer);
-    let echoed = payload.request;
-    if (echoed.time !== request.payload.time
-        || echoed.to !== request.payload.to
-        || echoed.cert !== request.payload.cert
-        || echoed.certIssuer !== request.payload.certIssuer
-        || echoed.dataHash !== dataHash(request.payload.data)
-    ) {
+    let { data: requestData, ...requestRest } = request.payload;
+    let { dataHash: echoedHash, ...echoedRest } = payload.request;
+    if (echoedHash !== dataHash(requestData) || JSON.stringify(echoedRest) !== JSON.stringify(requestRest)) {
         throw new Error(`Reply answers a different request than the one we sent`);
     }
     let machineId = getMachineId(getCommonName(payload.certIssuer), domain);