sliftutils 1.7.143 → 1.7.145

package/misc/random.ts

@@ -42,4 +42,4 @@ export function secureRandom(): number {
         crypto.getRandomValues(randomData);
     }
     return randomDataF64[0];
-}
+}

package/package.json

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

package/security/machines/identity2.ts

@@ -1,20 +1,30 @@
+/*
+    NOTE: This whole verification process isn't secure if someone man-in-the-middles the IP. There is a way to make it more secure, but right now it is quite a bit of work. Here is the outline, though. 
+
+    a) Use libsodium, do handshake ourself over unsecured websocket (or random self signed websocket), and use ChaCha20 for encryption so it's fast
+        - This lets us use ED25519 certificates. 
+    b) Integrate with socket-function, So we can do everything with regular socket function calls. It's a lot nicer of an interface. We can even have it proxied to Python. As annoying as that is...
+    c) Use github pages to host the site, so we can also host the machine keys
+        - Every time they change, we need to redeploy, and... we don't get revocations without deploying. BUT... it's better than nothing.
+
+    NOTE: Just using real HTTPS certificates isn't really an alternative.
+        - They won't be bound to IPs
+        - Revoking them is a lot more difficult (and they won't be automatically revoked)
+        - Once you reach certain level of machines, you're going to run into problems with different certificates per machine
+        - You're still going to need a way to give servers access to either the certificates or a way to generate the certificates.
+
+    So doing it with our own code isn't about cost or difficulty. The reason we would want to implement it ourselves is because HTTPS wasn't made to create an internal network of trust. It's designed around web browsing, and it works well for that. However, for two-way authentication, there are significantly better systems.
+*/
+
 import sha256 from "js-sha256";
 import { isNode } from "socket-function/src/misc";
 import { getCommonName, getIdentityCA, getMachineId, getThreadKeyCert, sign, validateCertificate, verify } from "../../misc/https/certs";
 import { getTrustedMachines } from "./machines";
 
-const MAX_SIGNED_AGE = 5 * 60 * 1000;
-
 export type SignedRequest<T> = {
     signature: string;
     payload: {
-        // When it was signed - anything older than MAX_SIGNED_AGE is refused
-        time: number;
-        // 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.
+        // The ip we are talking to.
         targetId: string;
         // The thread certificate that signed this
         cert: string;
@@ -27,7 +37,6 @@ export type SignedRequest<T> = {
 export type SignedReply = {
     signature: string;
     payload: {
-        time: number;
         // 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 };
@@ -44,7 +53,6 @@ export function signRequest<T>(domain: string, config: { targetId: string; data:
     let threadKeyCert = getThreadKeyCert(domain);
     let issuer = getIdentityCA(domain);
     let payload: SignedRequest<T>["payload"] = {
-        time: Date.now(),
         targetId: config.targetId,
         cert: threadKeyCert.cert.toString(),
         certIssuer: issuer.cert.toString(),
@@ -54,11 +62,10 @@ export function signRequest<T>(domain: string, config: { targetId: string; data:
 }
 
 /** Returns the machineId that signed, the data, and the signed reply to send back - always
-    produced, so the caller's only job is to return it. 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.
+    produced, so the caller's only job is to return it. Throws if the signature or certificate
+    chain do not check out, or if the request was addressed to someone we are not: ownIdentities
+    is every address this server answers to - there are always several, internal and external -
+    and the signed targetId must be one of them.
 
     IMPORTANT! You still need to check the machine with isMachineAccepted if you want to know if
     the machine is trusted. We just verify that they are who they say they are, not that who they
@@ -69,10 +76,6 @@ export function verifyRequest<T>(domain: string, signed: SignedRequest<T>, ownId
     reply: SignedReply;
 } {
     let { signature, payload } = signed;
-    let signedThreshold = Date.now() - MAX_SIGNED_AGE;
-    if (payload.time < signedThreshold) {
-        throw new Error(`Signed request too old, ${payload.time} < ${signedThreshold}`);
-    }
     verify(payload.cert, signature, payload);
     validateCertificate(domain, payload.cert, payload.certIssuer);
     if (!ownIdentities.includes(payload.targetId)) {
@@ -83,7 +86,6 @@ export function verifyRequest<T>(domain: string, signed: SignedRequest<T>, ownId
     let issuer = getIdentityCA(domain);
     let { data: requestData, ...requestRest } = payload;
     let replyPayload: SignedReply["payload"] = {
-        time: Date.now(),
         request: { ...requestRest, dataHash: dataHash(requestData) },
         cert: threadKeyCert.cert.toString(),
         certIssuer: issuer.cert.toString(),
@@ -95,16 +97,12 @@ export function verifyRequest<T>(domain: string, signed: SignedRequest<T>, ownId
     };
 }
 
-/** Returns the machineId that replied. Throws if the signature, certificate chain, or time do
-    not check out, or if the reply does not answer the request we actually sent. On node the
-    replying machine must also be one of the trusted machines - the browser has no machine list,
-    so there this check is skipped. */
+/** Returns the machineId that replied. Throws if the signature or certificate chain do not check
+    out, or if the reply does not answer the request we actually sent. On node the replying
+    machine must also be one of the trusted machines - the browser has no machine list, so there
+    that check is skipped. */
 export async function verifyReply(domain: string, request: SignedRequest<unknown>, reply: SignedReply): Promise<{ machineId: string }> {
     let { signature, payload } = reply;
-    let signedThreshold = Date.now() - MAX_SIGNED_AGE;
-    if (payload.time < signedThreshold) {
-        throw new Error(`Signed reply too old, ${payload.time} < ${signedThreshold}`);
-    }
     verify(payload.cert, signature, payload);
     validateCertificate(domain, payload.cert, payload.certIssuer);
     let { data: requestData, ...requestRest } = request.payload;