sliftutils 1.0.2 → 1.1.0

package/misc/https/dist/certs.ts.cache

@@ -0,0 +1,530 @@
+"use strict";
+/// <reference path="./node-forge-ed25519.d.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.getOwnNodeIdAllowUndefined = exports.getOwnNodeId = exports.createTestBrowserKeyCert = exports.getThreadKeyCert = exports.verifyMachineIdForPublicKey = exports.getOwnMachineId = exports.getIdentityCAPromise = exports.getIdentityCA = exports.loadIdentityCA = exports.setIdentityCARaw = exports.encodeNodeId = exports.decodeNodeIdAssert = exports.decodeNodeId = exports.getMachineId = exports.createCertFromCA = exports.generateTestCA = exports.generateRSAKeyPair = exports.generateKeyPair = exports.validateCertificate = exports.validateCACert = exports.verify = exports.sign = exports.getPublicIdentifier = exports.parseCert = exports.privateKeyToPem = exports.createX509 = exports.getCommonName = exports.identityStorageKey = exports.CA_NOT_FOUND_ERROR = void 0;
+module.allowclient = true;
+// https://www.rfc-editor.org/rfc/rfc5280#page-42
+const compileFlags_1 = require("socket-function/require/compileFlags");
+const forge = __importStar(require("node-forge"));
+const caching_1 = require("socket-function/src/caching");
+const misc_1 = require("socket-function/src/misc");
+const js_sha256_1 = __importDefault(require("js-sha256"));
+const crypto_1 = __importDefault(require("crypto"));
+const certStore_1 = require("socket-function/src/certStore");
+const measure_1 = require("socket-function/src/profiling/measure");
+const nodeCache_1 = require("socket-function/src/nodeCache");
+const SocketFunction_1 = require("socket-function/SocketFunction");
+const nodeCache_2 = require("socket-function/src/nodeCache");
+const persistentLocalStorage_1 = require("./persistentLocalStorage");
+(0, compileFlags_1.setFlag)(require, "node-forge", "allowclient", true);
+(0, compileFlags_1.setFlag)(require, "js-sha256", "allowclient", true);
+const timeInDay = 1000 * 60 * 60 * 24;
+exports.CA_NOT_FOUND_ERROR = "18aa7318-f88f-4d2d-b41f-3daf4a433827";
+exports.identityStorageKey = "machineCA_10";
+function getIdentityStore(domain) {
+    return (0, persistentLocalStorage_1.getKeyStore)(domain, exports.identityStorageKey);
+}
+function getCommonName(cert) {
+    let subject = new crypto_1.default.X509Certificate(cert).subject;
+    let subjectKVPs = new Map(subject.split(",").map(x => x.trim().split("=")).map(x => [x[0], x.slice(1).join("=")]));
+    let commonName = subjectKVPs.get("CN");
+    if (!commonName)
+        throw new Error(`No common name in subject: ${subject}`);
+    return commonName;
+}
+exports.getCommonName = getCommonName;
+function createX509(config) {
+    return (0, measure_1.measureBlock)(function createX509() {
+        let { domain, issuer, lifeSpan, keyPair } = config;
+        let certObj = forge.pki.createCertificate();
+        certObj.publicKey = keyPair.publicKey;
+        certObj.serialNumber = "01";
+        // Give it 5 minutes before now. If we give it too much time, it can look like the cert is really
+        //  old, which will trigger various processes to try to get a fresher one (as if it lasts for
+        //  1 hour, but we set notBefore to 1 month ago, it looks 1 month old, and so almost expired,
+        //  when it isn't...)
+        certObj.validity.notBefore = new Date(Date.now() - 1000 * 60 * 5);
+        certObj.validity.notAfter = new Date(Date.now() + lifeSpan);
+        const commonNameAttrs = [{ name: "commonName", value: domain }];
+        certObj.setSubject(commonNameAttrs);
+        if (issuer === "self") {
+            certObj.setIssuer(commonNameAttrs);
+        }
+        else {
+            certObj.setIssuer(forge.pki.certificateFromPem(issuer.cert.toString()).subject.attributes);
+        }
+        let extensions = [];
+        const isCA = issuer === "self";
+        if (isCA) {
+            extensions.push({ name: "basicConstraints", cA: true });
+        }
+        let localHostDomain = "127-0-0-1." + domain.split(".").slice(-2).join(".");
+        extensions.push(...[
+            { name: "keyUsage", keyCertSign: isCA, digitalSignature: true, nonRepudiation: true, keyEncipherment: true, dataEncipherment: true },
+            { name: "subjectKeyIdentifier" },
+            {
+                name: "subjectAltName",
+                altNames: [
+                    { type: 2, value: domain },
+                    { type: 2, value: "*." + domain },
+                    { type: 2, value: localHostDomain },
+                    // NOTE: No longer allow 127.0.0.1, to make this more secure. We might enable this
+                    //  behavior behind a flag, for development.
+                    //{ type: 7, ip: "127.0.0.1" }
+                ]
+            },
+            // NOTE: nameConstraints are supported with our branch. But... chrome doesn't support them, so there's no point in using them.
+            //      "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
+            // {
+            //     name: "nameConstraints",
+            //     permittedSubtrees: [
+            //         // Chrome doesn't respect nameConstraints per https://bugs.chromium.org/p/chromium/issues/detail?id=1072083,
+            //         //  as the spec decided that "free to process or ignore such information" (when present in self
+            //         //  signed certificates), and therefore the chrome implementation decided "The first order is to behave predictably",
+            //         //  so... they're not going to support it, because why have a feature in one place, if it isn't
+            //         //  on android as well... ugh...
+            //         // Works fine on Edge though
+            //         { type: 2, value: forge.util.encodeUtf8(domain) },
+            //         { type: 2, value: forge.util.encodeUtf8(localHostDomain) },
+            //     ]
+            // },
+        ]);
+        certObj.setExtensions(extensions);
+        (0, measure_1.measureBlock)(function sign() {
+            if (issuer === "self") {
+                certObj.sign(keyPair.privateKey, forge.md.sha256.create());
+            }
+            else {
+                certObj.sign(privateKeyFromPem(issuer.key.toString()), forge.md.sha256.create());
+            }
+        });
+        return (0, measure_1.measureBlock)(function toPems() {
+            return {
+                domain,
+                cert: Buffer.from(forge.pki.certificateToPem(certObj)),
+                key: Buffer.from(privateKeyToPem(keyPair.privateKey)),
+            };
+        });
+    });
+}
+exports.createX509 = createX509;
+function privateKeyToPem(buffer) {
+    if ("privateKeyBytes" in buffer) {
+        return forge.ed25519.privateKeyToPem(buffer);
+    }
+    return forge.pki.privateKeyToPem(buffer);
+}
+exports.privateKeyToPem = privateKeyToPem;
+function privateKeyFromPem(pem) {
+    // We want to guess the type correctly, as caught exceptions make debugging annoying
+    if (pem.length < 200) {
+        try {
+            return forge.ed25519.privateKeyFromPem(pem);
+        }
+        catch (_a) { }
+    }
+    try {
+        return forge.pki.privateKeyFromPem(pem);
+    }
+    catch (_b) {
+        return forge.ed25519.privateKeyFromPem(pem);
+    }
+}
+function publicKeyFromCert(cert) {
+    return parseCert(cert).publicKey;
+}
+function parseCert(PEMorDER) {
+    return forge.pki.certificateFromPem(normalizeCertToPEM(PEMorDER));
+}
+exports.parseCert = parseCert;
+// Gets a unique value to represent the public key
+function getPublicIdentifier(PEMorDER) {
+    let obj = parseCert(PEMorDER);
+    let publicKey = obj.publicKey;
+    if ("publicKeyBytes" in publicKey) {
+        return Buffer.from(publicKey.publicKeyBytes);
+    }
+    return Buffer.from(new Uint32Array(publicKey.n.data).buffer);
+}
+exports.getPublicIdentifier = getPublicIdentifier;
+function isED25519(key) {
+    return key.length < 256;
+}
+// EQUIVALENT TO: `crypto.createSign("SHA256").update(JSON.stringify(payload)).sign(keyCert.key, "binary")`
+exports.sign = (0, measure_1.measureWrap)(function sign(keyPair, data) {
+    let dataStr = JSON.stringify(data);
+    if (isED25519(keyPair.key)) {
+        let privateKey = forge.pki.ed25519.privateKeyFromPem(keyPair.key.toString());
+        return privateKey.sign(dataStr);
+    }
+    else {
+        let privateKey = forge.pki.privateKeyFromPem(keyPair.key.toString());
+        const md = forge.md.sha256.create();
+        md.update(dataStr);
+        return privateKey.sign(md);
+    }
+});
+function verify(cert, signature, data) {
+    let certObj = parseCert(cert);
+    return certObj.publicKey.verify(JSON.stringify(data), signature);
+}
+exports.verify = verify;
+function normalizeCertToPEM(PEMorDER) {
+    if (PEMorDER.toString().startsWith("-----BEGIN CERTIFICATE-----")) {
+        return PEMorDER.toString();
+    }
+    PEMorDER = PEMorDER.toString("base64");
+    return "-----BEGIN CERTIFICATE-----\n" + PEMorDER + "\n-----END CERTIFICATE-----";
+}
+function getDomainPartFromPublicKey(publicKey) {
+    let bytes;
+    if ("publicKeyBytes" in publicKey) {
+        bytes = publicKey.publicKeyBytes;
+    }
+    else if (publicKey instanceof Buffer) {
+        bytes = publicKey;
+    }
+    else {
+        bytes = Buffer.from(new Uint32Array(publicKey.n.data).buffer);
+    }
+    return "b" + js_sha256_1.default.sha256(Buffer.from(bytes)).slice(0, 16).replaceAll("+", "-").replaceAll("/", "_");
+}
+function validateCACert(domain, cert) {
+    let certParsed = parseCert(cert);
+    let subject = certParsed.subject.getField("CN").value;
+    let localhostDomain = "127-0-0-1." + subject.split(".").slice(-2).join(".");
+    let domainParts = subject.split(".").reverse();
+    let rootDomainParsed = [domainParts.shift(), domainParts.shift()].reverse().join(".");
+    if (rootDomainParsed !== domain) {
+        // This is important, as our trust store contains more then just OUR certificates,
+        //  so if we allow any domains then real domains can impersonate anyone! It has to
+        //  be one OUR domain to be trusted!
+        throw new Error(`Certificate root domain should be ${domain}, but is ${rootDomainParsed}`);
+    }
+    // TODO: Maybe just skip if it isn't a hash string?
+    if (domainParts[0] === "noproxy") {
+        domainParts.shift();
+    }
+    let certExpectedPublicKeyPart = (domainParts.shift() || "").split("-").slice(-1)[0];
+    let certActualPublicKeyPart = getDomainPartFromPublicKey(certParsed.publicKey);
+    if (certExpectedPublicKeyPart !== certActualPublicKeyPart) {
+        throw new Error(`Certificate public key in the url is ${certExpectedPublicKeyPart}, but in the cert is ${certActualPublicKeyPart}`);
+    }
+    // ALSO, require name constraints to be present, and to restrict to the "CN"
+    let nameConstraints = certParsed.getExtension("nameConstraints");
+    if (!nameConstraints) {
+        throw new Error(`Certificate must have nameConstraints`);
+    }
+    let subtrees = nameConstraints.permittedSubtrees;
+    if (!subtrees) {
+        throw new Error(`Certificate must have nameConstraints.permittedSubtrees`);
+    }
+    let subtreeValues = subtrees.map((x) => x.value);
+    // Ignore localhostDomain, as it can always safely be allowed (the same machine
+    //      is always allowed).
+    subtreeValues = subtreeValues.filter((x) => x !== localhostDomain);
+    if (subtreeValues.length !== 1 || subtreeValues[0] !== subject) {
+        throw new Error(`Certificate must have a single constrained domain (had ${JSON.stringify(subtreeValues)})`);
+    }
+    validateAltNames(certParsed, subject);
+}
+exports.validateCACert = validateCACert;
+function validateCertificate(domain, cert, issuerCert) {
+    validateCACert(domain, issuerCert);
+    let certParsed = parseCert(cert);
+    let subject = certParsed.subject.getField("CN").value;
+    let localhostDomain = "127-0-0-1." + subject.split(".").slice(-2).join(".");
+    let domainParts = subject.split(".").reverse();
+    let rootDomainParsed = [domainParts.shift(), domainParts.shift()].reverse().join(".");
+    if (rootDomainParsed !== domain) {
+        throw new Error(`Certificate root domain should be ${domain}, but is ${rootDomainParsed}`);
+    }
+    // TODO: Maybe just skip if it isn't a hash string?
+    if (domainParts[0] === "noproxy") {
+        domainParts.shift();
+    }
+    let issuerCertParsed = parseCert(issuerCert);
+    let issuerExpectedPublicKeyPart = domainParts.shift() || "";
+    let issuerActualPublicKeyPart = getDomainPartFromPublicKey(issuerCertParsed.publicKey);
+    if (issuerExpectedPublicKeyPart !== issuerActualPublicKeyPart) {
+        throw new Error(`Issuer public key in the url is ${issuerExpectedPublicKeyPart}, but in the cert is ${issuerActualPublicKeyPart}`);
+    }
+    // Take the last part
+    let certExpectedPublicKeyPart = domainParts.shift() || "";
+    let certActualPublicKeyPart = getDomainPartFromPublicKey(certParsed.publicKey);
+    if (certExpectedPublicKeyPart !== certActualPublicKeyPart) {
+        throw new Error(`Certificate public key in the url is ${certExpectedPublicKeyPart}, but in the cert is ${certActualPublicKeyPart}`);
+    }
+    let nameConstraints = issuerCertParsed.getExtension("nameConstraints");
+    if (!nameConstraints) {
+        throw new Error(`CA must have nameConstraints`);
+    }
+    let subtrees = nameConstraints.permittedSubtrees;
+    if (!subtrees) {
+        throw new Error(`CA must have nameConstraints.permittedSubtrees`);
+    }
+    let subtreeValues = subtrees.map((x) => x.value);
+    // Ignore localhostDomain, as it can always safely be allowed (the same machine
+    //      is always allowed).
+    subtreeValues = subtreeValues.filter((x) => x !== localhostDomain);
+    if (subtreeValues.length !== 1) {
+        throw new Error(`CA must have a single constrained domain (had ${JSON.stringify(subtreeValues)})`);
+    }
+    let subtree = subtreeValues[0];
+    if (subtree !== subject && !subject.endsWith("." + subtree)) {
+        throw new Error(`Certificate must be a subtree of the CA (CA: ${subtree}, cert: ${subject})`);
+    }
+    validateAltNames(certParsed, subject);
+    // Verify issuer ACTUALLY signed certParsed
+    if (!issuerCertParsed.verify(certParsed)) {
+        throw new Error(`Issuer did not sign certificate`);
+    }
+}
+exports.validateCertificate = validateCertificate;
+// Require alt names to be either equal to "CN", or a subtree of "CN"
+function validateAltNames(certParsed, subject) {
+    let localhostDomain = "127-0-0-1." + subject.split(".").slice(-2).join(".");
+    let altNamesObj = certParsed.getExtension("subjectAltName");
+    let altNames = altNamesObj === null || altNamesObj === void 0 ? void 0 : altNamesObj.altNames.map((x) => x.value);
+    // Allow localhostDomain, as it can always safely be allowed
+    altNames = altNames.filter((x) => x !== localhostDomain);
+    if (altNames.some((x) => !(x === subject
+        || x.endsWith("." + subject)
+    // Commented out, because... it is so easy to publish a 127.0.0.1 A record,
+    //  and even to generate a real cert, so, we should jsut do that, and keep it secure.
+    //  If we need this for development we can put it behind a flag, so non-development
+    //  instances are still secure.
+    // // Also allow 127.0.0.1, for local testing, for now?
+    // //  - This might be insecure if these are trusted by the browser,
+    // //      as then anyone that stores any cookies in this ip can have
+    // //      the cookies stolen. But... if this is just cross-server...
+    // //      I don't see how this could cause a security vulnerability.
+    // || x === Buffer.from([127, 0, 0, 1]).toString()
+    ))) {
+        throw new Error(`Invalid alt names. Must be subtrees of the subject (CN) ${JSON.stringify(subject)}, was ${JSON.stringify(altNames)}`);
+    }
+}
+function generateKeyPair() {
+    return (0, measure_1.measureBlock)(function generateKeyPair() {
+        // NOTE: We use ED25519 because it can generated keys about 10X faster, WHICH, is still slow
+        //  (~6ms on my machine). So we DEFINITELY don't want it to be 10X slower!
+        // NOTE: ED25519 doens't have great support in browsers, but we shouldn't need self signed certificates
+        //  in the browser anyway.
+        //  - https://security.stackexchange.com/a/236943/282367
+        //let keyPair = forge.ed25519.generateKeyPair();
+        let keyPair = forge.pki.rsa.generateKeyPair();
+        return keyPair;
+    });
+}
+exports.generateKeyPair = generateKeyPair;
+function generateRSAKeyPair() {
+    return (0, measure_1.measureBlock)(function generateKeyPair() {
+        return forge.pki.rsa.generateKeyPair();
+    });
+}
+exports.generateRSAKeyPair = generateRSAKeyPair;
+function generateTestCA(domain) {
+    const keyPair = generateKeyPair();
+    let caPublicKeyPart = getDomainPartFromPublicKey(keyPair.publicKey);
+    let fullDomain = `${caPublicKeyPart}.${domain}`;
+    if (!(0, misc_1.isNode)()) {
+        fullDomain = `${caPublicKeyPart}.${domain}`;
+    }
+    return createX509({ domain: fullDomain, issuer: "self", keyPair, lifeSpan: timeInDay * 365 * 20 });
+}
+exports.generateTestCA = generateTestCA;
+let identityCA = (0, caching_1.cache)((domain) => {
+    let identityCA = (0, caching_1.lazy)((async () => {
+        let identityCACached = getIdentityStore(domain);
+        let caCached = await identityCACached.get();
+        if (!caCached) {
+            console.log(`Generating new identity CA`);
+            const keyPair = generateKeyPair();
+            let caPublicKeyPart = getDomainPartFromPublicKey(keyPair.publicKey);
+            let fullDomain = `${caPublicKeyPart}.${domain}`;
+            if (!(0, misc_1.isNode)()) {
+                fullDomain = `${caPublicKeyPart}.${domain}`;
+            }
+            let value = createX509({ domain: fullDomain, issuer: "self", keyPair, lifeSpan: timeInDay * 365 * 20 });
+            caCached = {
+                domain: value.domain,
+                certB64: value.cert.toString("base64"),
+                keyB64: value.key.toString("base64"),
+            };
+            await identityCACached.set(caCached);
+        }
+        let result = {
+            domain: caCached.domain,
+            cert: Buffer.from(caCached.certB64, "base64"),
+            key: Buffer.from(caCached.keyB64, "base64"),
+        };
+        (0, certStore_1.trustCertificate)(result.cert.toString());
+        identityCA.set(result);
+        return result;
+    }));
+    return identityCA;
+});
+// IMPORTANT! We do not embed any debug info in this domain. If we did, it would be useful,
+//  but... potentally a security vulnerability, as if the debug info (such as a prefix)
+//  is used to identify what a certificate is for, it would be easy for an attack to
+//  forge this (as the debug info won't be secured). So it is much better to keep
+//  the certificate opaque, and then require any metadata to be actually vetted
+//  (and hopefully stored in a UI, showing IP, time, etc).
+function createCertFromCA(config) {
+    return (0, measure_1.measureBlock)(function createCertFromCA() {
+        let { CAKeyPair } = config;
+        const keyPair = generateKeyPair();
+        let domainKeyPart = getDomainPartFromPublicKey(keyPair.publicKey);
+        let fullDomain = `${domainKeyPart}.${config.CAKeyPair.domain}`;
+        return createX509({
+            domain: fullDomain,
+            issuer: CAKeyPair,
+            keyPair,
+            lifeSpan: timeInDay * 365 * 10,
+        });
+    });
+}
+exports.createCertFromCA = createCertFromCA;
+function getMachineId(domainName) {
+    return domainName.split(".").slice(-3).join(".");
+}
+exports.getMachineId = getMachineId;
+function decodeNodeId(nodeId) {
+    let locationObj = (0, nodeCache_1.getNodeIdLocation)(nodeId);
+    if (!locationObj) {
+        return undefined;
+    }
+    let parts = locationObj.address.split(".");
+    if (nodeId.startsWith("127-0-0-1.") && parts.length === 3) {
+        return {
+            threadId: "",
+            machineId: parts.at(-3) || "",
+            domain: parts.slice(-2).join("."),
+            port: locationObj.port,
+        };
+    }
+    if (parts.length < 4) {
+        return undefined;
+    }
+    return {
+        threadId: parts.at(-4) || "",
+        machineId: parts.at(-3) || "",
+        domain: parts.slice(-2).join(".") || "",
+        port: locationObj.port,
+    };
+}
+exports.decodeNodeId = decodeNodeId;
+function decodeNodeIdAssert(nodeId) {
+    let result = decodeNodeId(nodeId);
+    if (!result) {
+        throw new Error(`Invalid nodeId: ${nodeId}`);
+    }
+    return result;
+}
+exports.decodeNodeIdAssert = decodeNodeIdAssert;
+function encodeNodeId(parts) {
+    return `${parts.threadId}.${parts.machineId}.${parts.domain}:${parts.port}`;
+}
+exports.encodeNodeId = encodeNodeId;
+async function setIdentityCARaw(domain, json) {
+    let identityCACached = getIdentityStore(domain);
+    let obj = JSON.parse(json);
+    let ca = {
+        domain: obj.domain,
+        cert: Buffer.from(obj.certB64, "base64"),
+        key: Buffer.from(obj.keyB64, "base64"),
+    };
+    (0, certStore_1.trustCertificate)(ca.cert.toString());
+    identityCA(domain).set(ca);
+    getThreadKeyCertBase(domain).reset();
+    await identityCACached.set(obj);
+    (0, nodeCache_2.resetAllNodeCallFactories)();
+}
+exports.setIdentityCARaw = setIdentityCARaw;
+async function loadIdentityCA(domain) {
+    await identityCA(domain)();
+}
+exports.loadIdentityCA = loadIdentityCA;
+function getIdentityCA(domain) {
+    let value = identityCA(domain)();
+    if (value instanceof Promise) {
+        throw new Error("Identity CA is not yet loaded. Call and wait for loadIdentityCA() in your startup before accessing the identity (or call getIdentityCAPromise())");
+    }
+    return value;
+}
+exports.getIdentityCA = getIdentityCA;
+// TODO: Replace this with a database, so it is easy for us to trust CAs
+//  cross machine, and even have multiple users, etc, etc.
+function getIdentityCAPromise(domain) {
+    return identityCA(domain)();
+}
+exports.getIdentityCAPromise = getIdentityCAPromise;
+function getOwnMachineId(domain) {
+    return getMachineId(getIdentityCA(domain).domain);
+}
+exports.getOwnMachineId = getOwnMachineId;
+/** Part of the machineId comes from the publicKey, so we can use it to verify */
+function verifyMachineIdForPublicKey(config) {
+    let { machineId, publicKey } = config;
+    let domainPart = getDomainPartFromPublicKey(publicKey);
+    return machineId.split(".").at(-3) === domainPart;
+}
+exports.verifyMachineIdForPublicKey = verifyMachineIdForPublicKey;
+// NOTE: We don't have a cache per CA, as... the CA should be set first
+//  TODO: Maybe throw if they try to change the CA after they generate any certificates?
+// TODO: Regenerate certificates after enough time (as thread certs should be relatively short lived,
+//  so it is plausible for them to expire)
+//  - We will also need to provide a callback so that users of the cert can update the cert they
+//      are using as well.
+function getThreadKeyCert(domain) {
+    return getThreadKeyCertBase(domain)();
+}
+exports.getThreadKeyCert = getThreadKeyCert;
+const getThreadKeyCertBase = (0, caching_1.cache)((domain) => (0, caching_1.lazy)(() => {
+    let ca = getIdentityCA(domain);
+    return createCertFromCA({ CAKeyPair: ca });
+}));
+exports.createTestBrowserKeyCert = (0, caching_1.lazy)(async () => {
+    let keyPair = generateRSAKeyPair();
+    return await createX509({ domain: "test", issuer: "self", keyPair, lifeSpan: timeInDay * 365 * 20 });
+});
+function getOwnNodeId() {
+    let nodeId = SocketFunction_1.SocketFunction.mountedNodeId;
+    if (!nodeId) {
+        throw new Error(`Node must be mounted before nodeId is accessed`);
+    }
+    return nodeId;
+}
+exports.getOwnNodeId = getOwnNodeId;
+function getOwnNodeIdAllowUndefined() {
+    return SocketFunction_1.SocketFunction.mountedNodeId;
+}
+exports.getOwnNodeIdAllowUndefined = getOwnNodeIdAllowUndefined;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certs.js","sourceRoot":"","sources":["certs.ts"],"names":[],"mappings":";AAAA,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC;AAE1B,iDAAiD;AAEjD,uEAA+D;AAC/D,kDAAoC;AAGpC,yDAA0D;AAC1D,mDAAkD;AAClD,0DAA+B;AAC/B,oDAA4B;AAC5B,6DAAiE;AACjE,mEAA8F;AAC9F,6DAAkH;AAElH,mEAAgE;AAChE,6DAA0E;AAC1E,qEAAuD;AAEvD,IAAA,sBAAO,EAAC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;AACpD,IAAA,sBAAO,EAAC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;AAEnD,MAAM,SAAS,GAAG,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAEzB,QAAA,kBAAkB,GAAG,sCAAsC,CAAC;AAE5D,QAAA,kBAAkB,GAAG,cAAc,CAAC;AAGjD,SAAS,gBAAgB,CAAC,MAAc;IACpC,OAAO,IAAA,oCAAW,EAAsB,MAAM,EAAE,0BAAkB,CAAC,CAAC;AACxE,CAAC;AAID,SAAgB,aAAa,CAAC,IAAqB;IAC/C,IAAI,OAAO,GAAG,IAAI,gBAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;IACvD,IAAI,WAAW,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACnH,IAAI,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,CAAC,UAAU;QAAE,MAAM,IAAI,KAAK,CAAC,8BAA8B,OAAO,EAAE,CAAC,CAAC;IAC1E,OAAO,UAAU,CAAC;AACtB,CAAC;AAND,sCAMC;AAED,SAAgB,UAAU,CACtB,MAQC;IAED,OAAO,IAAA,sBAAY,EAAC,SAAS,UAAU;QACnC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;QAEnD,IAAI,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC;QAC5C,OAAO,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACtC,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC;QAC5B,iGAAiG;QACjG,6FAA6F;QAC7F,6FAA6F;QAC7F,qBAAqB;QACrB,OAAO,CAAC,QAAQ,CAAC,SAAS,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QAClE,OAAO,CAAC,QAAQ,CAAC,QAAQ,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,CAAC;QAE5D,MAAM,eAAe,GAAG,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAChE,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;QAEpC,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;YACpB,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC;QACvC,CAAC;aAAM,CAAC;YACJ,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAC/F,CAAC;QAED,IAAI,UAAU,GAAG,EAAE,CAAC;QACpB,MAAM,IAAI,GAAG,MAAM,KAAK,MAAM,CAAC;QAC/B,IAAI,IAAI,EAAE,CAAC;YACP,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5D,CAAC;QAED,IAAI,eAAe,GAAG,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAE3E,UAAU,CAAC,IAAI,CAAC,GAAG;YACf,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE;YACpI,EAAE,IAAI,EAAE,sBAAsB,EAAE;YAChC;gBACI,IAAI,EAAE,gBAAgB;gBACtB,QAAQ,EAAE;oBACN,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE;oBAC1B,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,GAAG,MAAM,EAAE;oBACjC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,eAAe,EAAE;oBACnC,kFAAkF;oBAClF,4CAA4C;oBAC5C,8BAA8B;iBACjC;aACJ;YACD,8HAA8H;YAC9H,mGAAmG;YACnG,IAAI;YACJ,+BAA+B;YAC/B,2BAA2B;YAC3B,uHAAuH;YACvH,0GAA0G;YAC1G,gIAAgI;YAChI,0GAA0G;YAC1G,2CAA2C;YAC3C,uCAAuC;YACvC,6DAA6D;YAC7D,sEAAsE;YACtE,QAAQ;YACR,KAAK;SACR,CAAC,CAAC;QACH,OAAO,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;QAGlC,IAAA,sBAAY,EAAC,SAAS,IAAI;YACtB,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;gBACpB,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,UAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;YACtE,CAAC;iBAAM,CAAC;gBACJ,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;YAC5F,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,IAAA,sBAAY,EAAC,SAAS,MAAM;YAC/B,OAAO;gBACH,MAAM;gBACN,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;gBACtD,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;aACxD,CAAC;QACN,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC;AA1FD,gCA0FC;AACD,SAAgB,eAAe,CAAC,MAAsD;IAClF,IAAI,iBAAiB,IAAI,MAAM,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAC,OAAO,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IACjD,CAAC;IACD,OAAO,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;AAC7C,CAAC;AALD,0CAKC;AACD,SAAS,iBAAiB,CAAC,GAAW;IAClC,oFAAoF;IACpF,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC;YACD,OAAO,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QAChD,CAAC;QAAC,WAAM,CAAC,CAAC,CAAC;IACf,CAAC;IACD,IAAI,CAAC;QACD,OAAO,KAAK,CAAC,GAAG,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAAC,WAAM,CAAC;QACL,OAAO,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;AACL,CAAC;AACD,SAAS,iBAAiB,CAAC,IAAY;IACnC,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC;AACrC,CAAC;AACD,SAAgB,SAAS,CAAC,QAAyB;IAC/C,OAAO,KAAK,CAAC,GAAG,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC;AACtE,CAAC;AAFD,8BAEC;AAED,kDAAkD;AAClD,SAAgB,mBAAmB,CAAC,QAAyB;IACzD,IAAI,GAAG,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC9B,IAAI,SAAS,GAAG,GAAG,CAAC,SAAS,CAAC;IAC9B,IAAI,gBAAgB,IAAI,SAAS,EAAE,CAAC;QAChC,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,cAAqB,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,WAAW,CAAE,SAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;AAC1E,CAAC;AAPD,kDAOC;AAED,SAAS,SAAS,CAAC,GAAoB;IACnC,OAAO,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC;AAC5B,CAAC;AAED,2GAA2G;AAC9F,QAAA,IAAI,GAAG,IAAA,qBAAW,EAAC,SAAS,IAAI,CAAC,OAAiC,EAAE,IAAa;IAC1F,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACzB,IAAI,UAAU,GAAI,KAAK,CAAC,GAAG,CAAC,OAAe,CAAC,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;QACtF,OAAO,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;SAAM,CAAC;QACJ,IAAI,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,iBAAiB,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC;QACrE,MAAM,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACpC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACnB,OAAO,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,SAAgB,MAAM,CAAC,IAAY,EAAE,SAAiB,EAAE,IAAa;IACjE,IAAI,OAAO,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAC9B,OAAQ,OAAO,CAAC,SAAqC,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;AAClG,CAAC;AAHD,wBAGC;AAED,SAAS,kBAAkB,CAAC,QAAyB;IACjD,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC,UAAU,CAAC,6BAA6B,CAAC,EAAE,CAAC;QAChE,OAAO,QAAQ,CAAC,QAAQ,EAAE,CAAC;IAC/B,CAAC;IACD,QAAQ,GAAG,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IACvC,OAAO,+BAA+B,GAAG,QAAQ,GAAG,6BAA6B,CAAC;AACtF,CAAC;AAED,SAAS,0BAA0B,CAAC,SAA+E;IAC/G,IAAI,KAAa,CAAC;IAClB,IAAI,gBAAgB,IAAI,SAAS,EAAE,CAAC;QAChC,KAAK,GAAG,SAAS,CAAC,cAAc,CAAC;IACrC,CAAC;SAAM,IAAI,SAAS,YAAY,MAAM,EAAE,CAAC;QACrC,KAAK,GAAG,SAAS,CAAC;IACtB,CAAC;SAAM,CAAC;QACJ,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,WAAW,CAAE,SAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,GAAG,GAAG,mBAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AAC1G,CAAC;AAED,SAAgB,cAAc,CAAC,MAAc,EAAE,IAAqB;IAChE,IAAI,UAAU,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IAEjC,IAAI,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAe,CAAC;IAChE,IAAI,eAAe,GAAG,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAE5E,IAAI,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC;IAE/C,IAAI,gBAAgB,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtF,IAAI,gBAAgB,KAAK,MAAM,EAAE,CAAC;QAC9B,kFAAkF;QAClF,kFAAkF;QAClF,oCAAoC;QACpC,MAAM,IAAI,KAAK,CAAC,qCAAqC,MAAM,YAAY,gBAAgB,EAAE,CAAC,CAAC;IAC/F,CAAC;IACD,mDAAmD;IACnD,IAAI,WAAW,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QAC/B,WAAW,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;IAED,IAAI,yBAAyB,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACpF,IAAI,uBAAuB,GAAG,0BAA0B,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAC/E,IAAI,yBAAyB,KAAK,uBAAuB,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,wCAAwC,yBAAyB,wBAAwB,uBAAuB,EAAE,CAAC,CAAC;IACxI,CAAC;IAED,4EAA4E;IAC5E,IAAI,eAAe,GAAG,UAAU,CAAC,YAAY,CAAC,iBAAiB,CAAQ,CAAC;IACxE,IAAI,CAAC,eAAe,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;IAC7D,CAAC;IACD,IAAI,QAAQ,GAAG,eAAe,CAAC,iBAAiB,CAAC;IACjD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;IAC/E,CAAC;IACD,IAAI,aAAa,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACtD,+EAA+E;IAC/E,2BAA2B;IAC3B,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC;IAC3E,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC,KAAK,OAAO,EAAE,CAAC;QAC7D,MAAM,IAAI,KAAK,CAAC,0DAA0D,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAChH,CAAC;IAED,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;AAC1C,CAAC;AA5CD,wCA4CC;AAED,SAAgB,mBAAmB,CAAC,MAAc,EAAE,IAAqB,EAAE,UAA2B;IAClG,cAAc,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAEnC,IAAI,UAAU,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;IACjC,IAAI,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAe,CAAC;IAChE,IAAI,eAAe,GAAG,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAE5E,IAAI,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC;IAE/C,IAAI,gBAAgB,GAAG,CAAC,WAAW,CAAC,KAAK,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACtF,IAAI,gBAAgB,KAAK,MAAM,EAAE,CAAC;QAC9B,MAAM,IAAI,KAAK,CAAC,qCAAqC,MAAM,YAAY,gBAAgB,EAAE,CAAC,CAAC;IAC/F,CAAC;IACD,mDAAmD;IACnD,IAAI,WAAW,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QAC/B,WAAW,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;IAED,IAAI,gBAAgB,GAAG,SAAS,CAAC,UAAU,CAAC,CAAC;IAE7C,IAAI,2BAA2B,GAAG,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC;IAC5D,IAAI,yBAAyB,GAAG,0BAA0B,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;IACvF,IAAI,2BAA2B,KAAK,yBAAyB,EAAE,CAAC;QAC5D,MAAM,IAAI,KAAK,CAAC,mCAAmC,2BAA2B,wBAAwB,yBAAyB,EAAE,CAAC,CAAC;IACvI,CAAC;IAED,qBAAqB;IACrB,IAAI,yBAAyB,GAAG,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC;IAC1D,IAAI,uBAAuB,GAAG,0BAA0B,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;IAC/E,IAAI,yBAAyB,KAAK,uBAAuB,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,wCAAwC,yBAAyB,wBAAwB,uBAAuB,EAAE,CAAC,CAAC;IACxI,CAAC;IAGD,IAAI,eAAe,GAAG,gBAAgB,CAAC,YAAY,CAAC,iBAAiB,CAAQ,CAAC;IAC9E,IAAI,CAAC,eAAe,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;IACpD,CAAC;IACD,IAAI,QAAQ,GAAG,eAAe,CAAC,iBAAiB,CAAC;IACjD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;IACtE,CAAC;IACD,IAAI,aAAa,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACtD,+EAA+E;IAC/E,2BAA2B;IAC3B,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC;IAC3E,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,iDAAiD,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IACvG,CAAC;IAED,IAAI,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;IAC/B,IAAI,OAAO,KAAK,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,GAAG,OAAO,CAAC,EAAE,CAAC;QAC1D,MAAM,IAAI,KAAK,CAAC,gDAAgD,OAAO,WAAW,OAAO,GAAG,CAAC,CAAC;IAClG,CAAC;IAED,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAEtC,2CAA2C;IAC3C,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;IACvD,CAAC;AACL,CAAC;AA7DD,kDA6DC;AAED,qEAAqE;AACrE,SAAS,gBAAgB,CAAC,UAAiC,EAAE,OAAe;IACxE,IAAI,eAAe,GAAG,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAE5E,IAAI,WAAW,GAAG,UAAU,CAAC,YAAY,CAAC,gBAAgB,CAAQ,CAAC;IACnE,IAAI,QAAQ,GAAG,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAC9D,4DAA4D;IAC5D,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC;IACjE,IACI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAS,EAAE,EAAE,CACxB,CAAC,CACG,CAAC,KAAK,OAAO;WACV,CAAC,CAAC,QAAQ,CAAC,GAAG,GAAG,OAAO,CAAC;IAC5B,2EAA2E;IAC3E,qFAAqF;IACrF,mFAAmF;IACnF,+BAA+B;IAC/B,uDAAuD;IACvD,oEAAoE;IACpE,qEAAqE;IACrE,qEAAqE;IACrE,qEAAqE;IACrE,kDAAkD;KACrD,CACJ,EACH,CAAC;QACC,MAAM,IAAI,KAAK,CAAC,2DAA2D,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC3I,CAAC;AACL,CAAC;AAGD,SAAgB,eAAe;IAC3B,OAAO,IAAA,sBAAY,EAAC,SAAS,eAAe;QACxC,4FAA4F;QAC5F,0EAA0E;QAC1E,uGAAuG;QACvG,0BAA0B;QAC1B,wDAAwD;QACxD,gDAAgD;QAChD,IAAI,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC;QAC9C,OAAO,OAAO,CAAC;IACnB,CAAC,CAAC,CAAC;AACP,CAAC;AAXD,0CAWC;AACD,SAAgB,kBAAkB;IAC9B,OAAO,IAAA,sBAAY,EAAC,SAAS,eAAe;QACxC,OAAO,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,eAAe,EAAE,CAAC;IAC3C,CAAC,CAAC,CAAC;AACP,CAAC;AAJD,gDAIC;AAED,SAAgB,cAAc,CAAC,MAAc;IACzC,MAAM,OAAO,GAAG,eAAe,EAAE,CAAC;IAClC,IAAI,eAAe,GAAG,0BAA0B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACpE,IAAI,UAAU,GAAG,GAAG,eAAe,IAAI,MAAM,EAAE,CAAC;IAChD,IAAI,CAAC,IAAA,aAAM,GAAE,EAAE,CAAC;QACZ,UAAU,GAAG,GAAG,eAAe,IAAI,MAAM,EAAE,CAAC;IAChD,CAAC;IAED,OAAO,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC,CAAC;AACvG,CAAC;AATD,wCASC;AAED,IAAI,UAAU,GAAG,IAAA,eAAK,EAAC,CAAC,MAAc,EAAE,EAAE;IACtC,IAAI,UAAU,GAAG,IAAA,cAAI,EAAC,CAAC,KAAK,IAA0B,EAAE;QACpD,IAAI,gBAAgB,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,QAAQ,GAAG,MAAM,gBAAgB,CAAC,GAAG,EAAE,CAAC;QAC5C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACZ,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;YAC1C,MAAM,OAAO,GAAG,eAAe,EAAE,CAAC;YAClC,IAAI,eAAe,GAAG,0BAA0B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YACpE,IAAI,UAAU,GAAG,GAAG,eAAe,IAAI,MAAM,EAAE,CAAC;YAChD,IAAI,CAAC,IAAA,aAAM,GAAE,EAAE,CAAC;gBACZ,UAAU,GAAG,GAAG,eAAe,IAAI,MAAM,EAAE,CAAC;YAChD,CAAC;YAED,IAAI,KAAK,GAAG,UAAU,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC,CAAC;YAExG,QAAQ,GAAG;gBACP,MAAM,EAAE,KAAK,CAAC,MAAM;gBACpB,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC;gBACtC,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC;aACvC,CAAC;YACF,MAAM,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,MAAM,GAAG;YACT,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;YAC7C,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;SAC9C,CAAC;QACF,IAAA,4BAAgB,EAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QACzC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACvB,OAAO,MAAM,CAAC;IAClB,CAAC,CAAsC,CAAC,CAAC;IACzC,OAAO,UAAU,CAAC;AACtB,CAAC,CAAC,CAAC;AAEH,2FAA2F;AAC3F,uFAAuF;AACvF,oFAAoF;AACpF,iFAAiF;AACjF,+EAA+E;AAC/E,0DAA0D;AAC1D,SAAgB,gBAAgB,CAAC,MAEhC;IACG,OAAO,IAAA,sBAAY,EAAC,SAAS,gBAAgB;QACzC,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;QAC3B,MAAM,OAAO,GAAG,eAAe,EAAE,CAAC;QAClC,IAAI,aAAa,GAAG,0BAA0B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAClE,IAAI,UAAU,GAAG,GAAG,aAAa,IAAI,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;QAC/D,OAAO,UAAU,CAAC;YACd,MAAM,EAAE,UAAU;YAClB,MAAM,EAAE,SAAS;YACjB,OAAO;YACP,QAAQ,EAAE,SAAS,GAAG,GAAG,GAAG,EAAE;SACjC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC;AAfD,4CAeC;AAED,SAAgB,YAAY,CAAC,UAAkB;IAC3C,OAAO,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACrD,CAAC;AAFD,oCAEC;AAQD,SAAgB,YAAY,CAAC,MAAc;IACvC,IAAI,WAAW,GAAG,IAAA,6BAAiB,EAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,CAAC,WAAW,EAAE,CAAC;QACf,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3C,IAAI,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxD,OAAO;YACH,QAAQ,EAAE,EAAE;YACZ,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;YAC7B,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC;YACjC,IAAI,EAAE,WAAW,CAAC,IAAI;SACzB,CAAC;IACN,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnB,OAAO,SAAS,CAAC;IACrB,CAAC;IACD,OAAO;QACH,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;QAC5B,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;QAC7B,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QACvC,IAAI,EAAE,WAAW,CAAC,IAAI;KACzB,CAAC;AACN,CAAC;AAvBD,oCAuBC;AACD,SAAgB,kBAAkB,CAAC,MAAc;IAC7C,IAAI,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,CAAC,MAAM,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,mBAAmB,MAAM,EAAE,CAAC,CAAC;IACjD,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC;AAND,gDAMC;AACD,SAAgB,YAAY,CAAC,KAAkB;IAC3C,OAAO,GAAG,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,SAAS,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;AAChF,CAAC;AAFD,oCAEC;AAEM,KAAK,UAAU,gBAAgB,CAAC,MAAc,EAAE,IAAY;IAC/D,IAAI,gBAAgB,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAChD,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAIxB,CAAC;IACF,IAAI,EAAE,GAAG;QACL,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC;QACxC,GAAG,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC;KACzC,CAAC;IACF,IAAA,4BAAgB,EAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;IACrC,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC3B,oBAAoB,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,CAAC;IACrC,MAAM,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAChC,IAAA,qCAAyB,GAAE,CAAC;AAChC,CAAC;AAjBD,4CAiBC;AAEM,KAAK,UAAU,cAAc,CAAC,MAAc;IAC/C,MAAM,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;AAC/B,CAAC;AAFD,wCAEC;AACD,SAAgB,aAAa,CAAC,MAAc;IACxC,IAAI,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;IACjC,IAAI,KAAK,YAAY,OAAO,EAAE,CAAC;QAC3B,MAAM,IAAI,KAAK,CAAC,kJAAkJ,CAAC,CAAC;IACxK,CAAC;IACD,OAAO,KAAK,CAAC;AACjB,CAAC;AAND,sCAMC;AAED,wEAAwE;AACxE,0DAA0D;AAC1D,SAAgB,oBAAoB,CAAC,MAAc;IAC/C,OAAO,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;AAChC,CAAC;AAFD,oDAEC;AAGD,SAAgB,eAAe,CAAC,MAAc;IAC1C,OAAO,YAAY,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AACtD,CAAC;AAFD,0CAEC;AAED,iFAAiF;AACjF,SAAgB,2BAA2B,CAAC,MAG3C;IACG,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IACtC,IAAI,UAAU,GAAG,0BAA0B,CAAC,SAAS,CAAC,CAAC;IACvD,OAAO,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC;AACtD,CAAC;AAPD,kEAOC;AAED,uEAAuE;AACvE,wFAAwF;AACxF,qGAAqG;AACrG,0CAA0C;AAC1C,gGAAgG;AAChG,0BAA0B;AAC1B,SAAgB,gBAAgB,CAAC,MAAc;IAC3C,OAAO,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC;AAC1C,CAAC;AAFD,4CAEC;AACD,MAAM,oBAAoB,GAAG,IAAA,eAAK,EAAC,CAAC,MAAc,EAAE,EAAE,CAAC,IAAA,cAAI,EAAC,GAAG,EAAE;IAC7D,IAAI,EAAE,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IAC/B,OAAO,gBAAgB,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC;AAC/C,CAAC,CAAC,CAAC,CAAC;AAES,QAAA,wBAAwB,GAAG,IAAA,cAAI,EAAC,KAAK,IAAI,EAAE;IACpD,IAAI,OAAO,GAAG,kBAAkB,EAAE,CAAC;IACnC,OAAO,MAAM,UAAU,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,GAAG,GAAG,GAAG,EAAE,EAAE,CAAC,CAAC;AACzG,CAAC,CAAC,CAAC;AAEH,SAAgB,YAAY;IACxB,IAAI,MAAM,GAAG,+BAAc,CAAC,aAAa,CAAC;IAC1C,IAAI,CAAC,MAAM,EAAE,CAAC;QACV,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC;AAND,oCAMC;AAED,SAAgB,0BAA0B;IACtC,OAAO,+BAAc,CAAC,aAAa,CAAC;AACxC,CAAC;AAFD,gEAEC","sourcesContent":["/// <reference path=\"./node-forge-ed25519.d.ts\" />\n\nmodule.allowclient = true;\n\n// https://www.rfc-editor.org/rfc/rfc5280#page-42\n\nimport { setFlag } from \"socket-function/require/compileFlags\";\nimport * as forge from \"node-forge\";\nimport os from \"os\";\nimport fsSync from \"fs\";\nimport { cache, lazy } from \"socket-function/src/caching\";\nimport { isNode } from \"socket-function/src/misc\";\nimport sha265 from \"js-sha256\";\nimport crypto from \"crypto\";\nimport { trustCertificate } from \"socket-function/src/certStore\";\nimport { measureBlock, measureFnc, measureWrap } from \"socket-function/src/profiling/measure\";\nimport { getNodeIdDomain, getNodeIdDomainMaybeUndefined, getNodeIdLocation } from \"socket-function/src/nodeCache\";\nimport { MaybePromise } from \"socket-function/src/types\";\nimport { SocketFunction } from \"socket-function/SocketFunction\";\nimport { resetAllNodeCallFactories } from \"socket-function/src/nodeCache\";\nimport { getKeyStore } from \"./persistentLocalStorage\";\n\nsetFlag(require, \"node-forge\", \"allowclient\", true);\nsetFlag(require, \"js-sha256\", \"allowclient\", true);\n\nconst timeInDay = 1000 * 60 * 60 * 24;\n\nexport const CA_NOT_FOUND_ERROR = \"18aa7318-f88f-4d2d-b41f-3daf4a433827\";\n\nexport const identityStorageKey = \"machineCA_10\";\nexport type IdentityStorageType = { domain: string; certB64: string; keyB64: string };\n\nfunction getIdentityStore(domain: string) {\n    return getKeyStore<IdentityStorageType>(domain, identityStorageKey);\n}\n\nexport interface X509KeyPair { domain: string; cert: Buffer; key: Buffer; }\n\nexport function getCommonName(cert: Buffer | string) {\n    let subject = new crypto.X509Certificate(cert).subject;\n    let subjectKVPs = new Map(subject.split(\",\").map(x => x.trim().split(\"=\")).map(x => [x[0], x.slice(1).join(\"=\")]));\n    let commonName = subjectKVPs.get(\"CN\");\n    if (!commonName) throw new Error(`No common name in subject: ${subject}`);\n    return commonName;\n}\n\nexport function createX509(\n    config: {\n        domain: string;\n        issuer: X509KeyPair | \"self\";\n        lifeSpan: number;\n        keyPair: {\n            publicKey: forge.Ed25519PublicKey;\n            privateKey: forge.Ed25519PrivateKey;\n        } | forge.pki.KeyPair;\n    }\n): X509KeyPair {\n    return measureBlock(function createX509() {\n        let { domain, issuer, lifeSpan, keyPair } = config;\n\n        let certObj = forge.pki.createCertificate();\n        certObj.publicKey = keyPair.publicKey;\n        certObj.serialNumber = \"01\";\n        // Give it 5 minutes before now. If we give it too much time, it can look like the cert is really\n        //  old, which will trigger various processes to try to get a fresher one (as if it lasts for\n        //  1 hour, but we set notBefore to 1 month ago, it looks 1 month old, and so almost expired,\n        //  when it isn't...)\n        certObj.validity.notBefore = new Date(Date.now() - 1000 * 60 * 5);\n        certObj.validity.notAfter = new Date(Date.now() + lifeSpan);\n\n        const commonNameAttrs = [{ name: \"commonName\", value: domain }];\n        certObj.setSubject(commonNameAttrs);\n\n        if (issuer === \"self\") {\n            certObj.setIssuer(commonNameAttrs);\n        } else {\n            certObj.setIssuer(forge.pki.certificateFromPem(issuer.cert.toString()).subject.attributes);\n        }\n\n        let extensions = [];\n        const isCA = issuer === \"self\";\n        if (isCA) {\n            extensions.push({ name: \"basicConstraints\", cA: true });\n        }\n\n        let localHostDomain = \"127-0-0-1.\" + domain.split(\".\").slice(-2).join(\".\");\n\n        extensions.push(...[\n            { name: \"keyUsage\", keyCertSign: isCA, digitalSignature: true, nonRepudiation: true, keyEncipherment: true, dataEncipherment: true },\n            { name: \"subjectKeyIdentifier\" },\n            {\n                name: \"subjectAltName\",\n                altNames: [\n                    { type: 2, value: domain },\n                    { type: 2, value: \"*.\" + domain },\n                    { type: 2, value: localHostDomain },\n                    // NOTE: No longer allow 127.0.0.1, to make this more secure. We might enable this\n                    //  behavior behind a flag, for development.\n                    //{ type: 7, ip: \"127.0.0.1\" }\n                ]\n            },\n            // NOTE: nameConstraints are supported with our branch. But... chrome doesn't support them, so there's no point in using them.\n            //      \"node-forge\": \"https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6\",\n            // {\n            //     name: \"nameConstraints\",\n            //     permittedSubtrees: [\n            //         // Chrome doesn't respect nameConstraints per https://bugs.chromium.org/p/chromium/issues/detail?id=1072083,\n            //         //  as the spec decided that \"free to process or ignore such information\" (when present in self\n            //         //  signed certificates), and therefore the chrome implementation decided \"The first order is to behave predictably\",\n            //         //  so... they're not going to support it, because why have a feature in one place, if it isn't\n            //         //  on android as well... ugh...\n            //         // Works fine on Edge though\n            //         { type: 2, value: forge.util.encodeUtf8(domain) },\n            //         { type: 2, value: forge.util.encodeUtf8(localHostDomain) },\n            //     ]\n            // },\n        ]);\n        certObj.setExtensions(extensions);\n\n\n        measureBlock(function sign() {\n            if (issuer === \"self\") {\n                certObj.sign(keyPair.privateKey as any, forge.md.sha256.create());\n            } else {\n                certObj.sign(privateKeyFromPem(issuer.key.toString()) as any, forge.md.sha256.create());\n            }\n        });\n\n        return measureBlock(function toPems() {\n            return {\n                domain,\n                cert: Buffer.from(forge.pki.certificateToPem(certObj)),\n                key: Buffer.from(privateKeyToPem(keyPair.privateKey)),\n            };\n        });\n    });\n}\nexport function privateKeyToPem(buffer: forge.pki.PrivateKey | forge.Ed25519PrivateKey) {\n    if (\"privateKeyBytes\" in buffer) {\n        return forge.ed25519.privateKeyToPem(buffer);\n    }\n    return forge.pki.privateKeyToPem(buffer);\n}\nfunction privateKeyFromPem(pem: string) {\n    // We want to guess the type correctly, as caught exceptions make debugging annoying\n    if (pem.length < 200) {\n        try {\n            return forge.ed25519.privateKeyFromPem(pem);\n        } catch { }\n    }\n    try {\n        return forge.pki.privateKeyFromPem(pem);\n    } catch {\n        return forge.ed25519.privateKeyFromPem(pem);\n    }\n}\nfunction publicKeyFromCert(cert: string) {\n    return parseCert(cert).publicKey;\n}\nexport function parseCert(PEMorDER: string | Buffer) {\n    return forge.pki.certificateFromPem(normalizeCertToPEM(PEMorDER));\n}\n\n// Gets a unique value to represent the public key\nexport function getPublicIdentifier(PEMorDER: string | Buffer): Buffer {\n    let obj = parseCert(PEMorDER);\n    let publicKey = obj.publicKey;\n    if (\"publicKeyBytes\" in publicKey) {\n        return Buffer.from(publicKey.publicKeyBytes as any);\n    }\n    return Buffer.from(new Uint32Array((publicKey as any).n.data).buffer);\n}\n\nfunction isED25519(key: string | Buffer) {\n    return key.length < 256;\n}\n\n// EQUIVALENT TO: `crypto.createSign(\"SHA256\").update(JSON.stringify(payload)).sign(keyCert.key, \"binary\")`\nexport const sign = measureWrap(function sign(keyPair: { key: string | Buffer }, data: unknown): string {\n    let dataStr = JSON.stringify(data);\n    if (isED25519(keyPair.key)) {\n        let privateKey = (forge.pki.ed25519 as any).privateKeyFromPem(keyPair.key.toString());\n        return privateKey.sign(dataStr);\n    } else {\n        let privateKey = forge.pki.privateKeyFromPem(keyPair.key.toString());\n        const md = forge.md.sha256.create();\n        md.update(dataStr);\n        return privateKey.sign(md);\n    }\n});\n\nexport function verify(cert: string, signature: string, data: unknown) {\n    let certObj = parseCert(cert);\n    return (certObj.publicKey as forge.pki.rsa.PublicKey).verify(JSON.stringify(data), signature);\n}\n\nfunction normalizeCertToPEM(PEMorDER: string | Buffer): string {\n    if (PEMorDER.toString().startsWith(\"-----BEGIN CERTIFICATE-----\")) {\n        return PEMorDER.toString();\n    }\n    PEMorDER = PEMorDER.toString(\"base64\");\n    return \"-----BEGIN CERTIFICATE-----\\n\" + PEMorDER + \"\\n-----END CERTIFICATE-----\";\n}\n\nfunction getDomainPartFromPublicKey(publicKey: { publicKeyBytes: Buffer } | forge.pki.KeyPair[\"publicKey\"] | Buffer) {\n    let bytes: Buffer;\n    if (\"publicKeyBytes\" in publicKey) {\n        bytes = publicKey.publicKeyBytes;\n    } else if (publicKey instanceof Buffer) {\n        bytes = publicKey;\n    } else {\n        bytes = Buffer.from(new Uint32Array((publicKey as any).n.data).buffer);\n    }\n    return \"b\" + sha265.sha256(Buffer.from(bytes)).slice(0, 16).replaceAll(\"+\", \"-\").replaceAll(\"/\", \"_\");\n}\n\nexport function validateCACert(domain: string, cert: string | Buffer) {\n    let certParsed = parseCert(cert);\n\n    let subject = certParsed.subject.getField(\"CN\").value as string;\n    let localhostDomain = \"127-0-0-1.\" + subject.split(\".\").slice(-2).join(\".\");\n\n    let domainParts = subject.split(\".\").reverse();\n\n    let rootDomainParsed = [domainParts.shift(), domainParts.shift()].reverse().join(\".\");\n    if (rootDomainParsed !== domain) {\n        // This is important, as our trust store contains more then just OUR certificates,\n        //  so if we allow any domains then real domains can impersonate anyone! It has to\n        //  be one OUR domain to be trusted!\n        throw new Error(`Certificate root domain should be ${domain}, but is ${rootDomainParsed}`);\n    }\n    // TODO: Maybe just skip if it isn't a hash string?\n    if (domainParts[0] === \"noproxy\") {\n        domainParts.shift();\n    }\n\n    let certExpectedPublicKeyPart = (domainParts.shift() || \"\").split(\"-\").slice(-1)[0];\n    let certActualPublicKeyPart = getDomainPartFromPublicKey(certParsed.publicKey);\n    if (certExpectedPublicKeyPart !== certActualPublicKeyPart) {\n        throw new Error(`Certificate public key in the url is ${certExpectedPublicKeyPart}, but in the cert is ${certActualPublicKeyPart}`);\n    }\n\n    // ALSO, require name constraints to be present, and to restrict to the \"CN\"\n    let nameConstraints = certParsed.getExtension(\"nameConstraints\") as any;\n    if (!nameConstraints) {\n        throw new Error(`Certificate must have nameConstraints`);\n    }\n    let subtrees = nameConstraints.permittedSubtrees;\n    if (!subtrees) {\n        throw new Error(`Certificate must have nameConstraints.permittedSubtrees`);\n    }\n    let subtreeValues = subtrees.map((x: any) => x.value);\n    // Ignore localhostDomain, as it can always safely be allowed (the same machine\n    //      is always allowed).\n    subtreeValues = subtreeValues.filter((x: string) => x !== localhostDomain);\n    if (subtreeValues.length !== 1 || subtreeValues[0] !== subject) {\n        throw new Error(`Certificate must have a single constrained domain (had ${JSON.stringify(subtreeValues)})`);\n    }\n\n    validateAltNames(certParsed, subject);\n}\n\nexport function validateCertificate(domain: string, cert: Buffer | string, issuerCert: Buffer | string) {\n    validateCACert(domain, issuerCert);\n\n    let certParsed = parseCert(cert);\n    let subject = certParsed.subject.getField(\"CN\").value as string;\n    let localhostDomain = \"127-0-0-1.\" + subject.split(\".\").slice(-2).join(\".\");\n\n    let domainParts = subject.split(\".\").reverse();\n\n    let rootDomainParsed = [domainParts.shift(), domainParts.shift()].reverse().join(\".\");\n    if (rootDomainParsed !== domain) {\n        throw new Error(`Certificate root domain should be ${domain}, but is ${rootDomainParsed}`);\n    }\n    // TODO: Maybe just skip if it isn't a hash string?\n    if (domainParts[0] === \"noproxy\") {\n        domainParts.shift();\n    }\n\n    let issuerCertParsed = parseCert(issuerCert);\n\n    let issuerExpectedPublicKeyPart = domainParts.shift() || \"\";\n    let issuerActualPublicKeyPart = getDomainPartFromPublicKey(issuerCertParsed.publicKey);\n    if (issuerExpectedPublicKeyPart !== issuerActualPublicKeyPart) {\n        throw new Error(`Issuer public key in the url is ${issuerExpectedPublicKeyPart}, but in the cert is ${issuerActualPublicKeyPart}`);\n    }\n\n    // Take the last part\n    let certExpectedPublicKeyPart = domainParts.shift() || \"\";\n    let certActualPublicKeyPart = getDomainPartFromPublicKey(certParsed.publicKey);\n    if (certExpectedPublicKeyPart !== certActualPublicKeyPart) {\n        throw new Error(`Certificate public key in the url is ${certExpectedPublicKeyPart}, but in the cert is ${certActualPublicKeyPart}`);\n    }\n\n\n    let nameConstraints = issuerCertParsed.getExtension(\"nameConstraints\") as any;\n    if (!nameConstraints) {\n        throw new Error(`CA must have nameConstraints`);\n    }\n    let subtrees = nameConstraints.permittedSubtrees;\n    if (!subtrees) {\n        throw new Error(`CA must have nameConstraints.permittedSubtrees`);\n    }\n    let subtreeValues = subtrees.map((x: any) => x.value);\n    // Ignore localhostDomain, as it can always safely be allowed (the same machine\n    //      is always allowed).\n    subtreeValues = subtreeValues.filter((x: string) => x !== localhostDomain);\n    if (subtreeValues.length !== 1) {\n        throw new Error(`CA must have a single constrained domain (had ${JSON.stringify(subtreeValues)})`);\n    }\n\n    let subtree = subtreeValues[0];\n    if (subtree !== subject && !subject.endsWith(\".\" + subtree)) {\n        throw new Error(`Certificate must be a subtree of the CA (CA: ${subtree}, cert: ${subject})`);\n    }\n\n    validateAltNames(certParsed, subject);\n\n    // Verify issuer ACTUALLY signed certParsed\n    if (!issuerCertParsed.verify(certParsed)) {\n        throw new Error(`Issuer did not sign certificate`);\n    }\n}\n\n// Require alt names to be either equal to \"CN\", or a subtree of \"CN\"\nfunction validateAltNames(certParsed: forge.pki.Certificate, subject: string) {\n    let localhostDomain = \"127-0-0-1.\" + subject.split(\".\").slice(-2).join(\".\");\n\n    let altNamesObj = certParsed.getExtension(\"subjectAltName\") as any;\n    let altNames = altNamesObj?.altNames.map((x: any) => x.value);\n    // Allow localhostDomain, as it can always safely be allowed\n    altNames = altNames.filter((x: string) => x !== localhostDomain);\n    if (\n        altNames.some((x: string) =>\n            !(\n                x === subject\n                || x.endsWith(\".\" + subject)\n                // Commented out, because... it is so easy to publish a 127.0.0.1 A record,\n                //  and even to generate a real cert, so, we should jsut do that, and keep it secure.\n                //  If we need this for development we can put it behind a flag, so non-development\n                //  instances are still secure.\n                // // Also allow 127.0.0.1, for local testing, for now?\n                // //  - This might be insecure if these are trusted by the browser,\n                // //      as then anyone that stores any cookies in this ip can have\n                // //      the cookies stolen. But... if this is just cross-server...\n                // //      I don't see how this could cause a security vulnerability.\n                // || x === Buffer.from([127, 0, 0, 1]).toString()\n            )\n        )\n    ) {\n        throw new Error(`Invalid alt names. Must be subtrees of the subject (CN) ${JSON.stringify(subject)}, was ${JSON.stringify(altNames)}`);\n    }\n}\n\n\nexport function generateKeyPair() {\n    return measureBlock(function generateKeyPair() {\n        // NOTE: We use ED25519 because it can generated keys about 10X faster, WHICH, is still slow\n        //  (~6ms on my machine). So we DEFINITELY don't want it to be 10X slower!\n        // NOTE: ED25519 doens't have great support in browsers, but we shouldn't need self signed certificates\n        //  in the browser anyway.\n        //  - https://security.stackexchange.com/a/236943/282367\n        //let keyPair = forge.ed25519.generateKeyPair();\n        let keyPair = forge.pki.rsa.generateKeyPair();\n        return keyPair;\n    });\n}\nexport function generateRSAKeyPair() {\n    return measureBlock(function generateKeyPair() {\n        return forge.pki.rsa.generateKeyPair();\n    });\n}\n\nexport function generateTestCA(domain: string) {\n    const keyPair = generateKeyPair();\n    let caPublicKeyPart = getDomainPartFromPublicKey(keyPair.publicKey);\n    let fullDomain = `${caPublicKeyPart}.${domain}`;\n    if (!isNode()) {\n        fullDomain = `${caPublicKeyPart}.${domain}`;\n    }\n\n    return createX509({ domain: fullDomain, issuer: \"self\", keyPair, lifeSpan: timeInDay * 365 * 20 });\n}\n\nlet identityCA = cache((domain: string) => {\n    let identityCA = lazy((async (): Promise<X509KeyPair> => {\n        let identityCACached = getIdentityStore(domain);\n        let caCached = await identityCACached.get();\n        if (!caCached) {\n            console.log(`Generating new identity CA`);\n            const keyPair = generateKeyPair();\n            let caPublicKeyPart = getDomainPartFromPublicKey(keyPair.publicKey);\n            let fullDomain = `${caPublicKeyPart}.${domain}`;\n            if (!isNode()) {\n                fullDomain = `${caPublicKeyPart}.${domain}`;\n            }\n\n            let value = createX509({ domain: fullDomain, issuer: \"self\", keyPair, lifeSpan: timeInDay * 365 * 20 });\n\n            caCached = {\n                domain: value.domain,\n                certB64: value.cert.toString(\"base64\"),\n                keyB64: value.key.toString(\"base64\"),\n            };\n            await identityCACached.set(caCached);\n        }\n        let result = {\n            domain: caCached.domain,\n            cert: Buffer.from(caCached.certB64, \"base64\"),\n            key: Buffer.from(caCached.keyB64, \"base64\"),\n        };\n        trustCertificate(result.cert.toString());\n        identityCA.set(result);\n        return result;\n    }) as (() => MaybePromise<X509KeyPair>));\n    return identityCA;\n});\n\n// IMPORTANT! We do not embed any debug info in this domain. If we did, it would be useful,\n//  but... potentally a security vulnerability, as if the debug info (such as a prefix)\n//  is used to identify what a certificate is for, it would be easy for an attack to\n//  forge this (as the debug info won't be secured). So it is much better to keep\n//  the certificate opaque, and then require any metadata to be actually vetted\n//  (and hopefully stored in a UI, showing IP, time, etc).\nexport function createCertFromCA(config: {\n    CAKeyPair: X509KeyPair;\n}): X509KeyPair {\n    return measureBlock(function createCertFromCA() {\n        let { CAKeyPair } = config;\n        const keyPair = generateKeyPair();\n        let domainKeyPart = getDomainPartFromPublicKey(keyPair.publicKey);\n        let fullDomain = `${domainKeyPart}.${config.CAKeyPair.domain}`;\n        return createX509({\n            domain: fullDomain,\n            issuer: CAKeyPair,\n            keyPair,\n            lifeSpan: timeInDay * 365 * 10,\n        });\n    });\n}\n\nexport function getMachineId(domainName: string) {\n    return domainName.split(\".\").slice(-3).join(\".\");\n}\n\nexport type NodeIdParts = {\n    threadId: string;\n    machineId: string;\n    domain: string;\n    port: number;\n};\nexport function decodeNodeId(nodeId: string): NodeIdParts | undefined {\n    let locationObj = getNodeIdLocation(nodeId);\n    if (!locationObj) {\n        return undefined;\n    }\n    let parts = locationObj.address.split(\".\");\n    if (nodeId.startsWith(\"127-0-0-1.\") && parts.length === 3) {\n        return {\n            threadId: \"\",\n            machineId: parts.at(-3) || \"\",\n            domain: parts.slice(-2).join(\".\"),\n            port: locationObj.port,\n        };\n    }\n    if (parts.length < 4) {\n        return undefined;\n    }\n    return {\n        threadId: parts.at(-4) || \"\",\n        machineId: parts.at(-3) || \"\",\n        domain: parts.slice(-2).join(\".\") || \"\",\n        port: locationObj.port,\n    };\n}\nexport function decodeNodeIdAssert(nodeId: string): NodeIdParts {\n    let result = decodeNodeId(nodeId);\n    if (!result) {\n        throw new Error(`Invalid nodeId: ${nodeId}`);\n    }\n    return result;\n}\nexport function encodeNodeId(parts: NodeIdParts) {\n    return `${parts.threadId}.${parts.machineId}.${parts.domain}:${parts.port}`;\n}\n\nexport async function setIdentityCARaw(domain: string, json: string) {\n    let identityCACached = getIdentityStore(domain);\n    let obj = JSON.parse(json) as {\n        domain: string;\n        certB64: string;\n        keyB64: string;\n    };\n    let ca = {\n        domain: obj.domain,\n        cert: Buffer.from(obj.certB64, \"base64\"),\n        key: Buffer.from(obj.keyB64, \"base64\"),\n    };\n    trustCertificate(ca.cert.toString());\n    identityCA(domain).set(ca);\n    getThreadKeyCertBase(domain).reset();\n    await identityCACached.set(obj);\n    resetAllNodeCallFactories();\n}\n\nexport async function loadIdentityCA(domain: string) {\n    await identityCA(domain)();\n}\nexport function getIdentityCA(domain: string): X509KeyPair {\n    let value = identityCA(domain)();\n    if (value instanceof Promise) {\n        throw new Error(\"Identity CA is not yet loaded. Call and wait for loadIdentityCA() in your startup before accessing the identity (or call getIdentityCAPromise())\");\n    }\n    return value;\n}\n\n// TODO: Replace this with a database, so it is easy for us to trust CAs\n//  cross machine, and even have multiple users, etc, etc.\nexport function getIdentityCAPromise(domain: string): MaybePromise<X509KeyPair> {\n    return identityCA(domain)();\n}\n\n\nexport function getOwnMachineId(domain: string) {\n    return getMachineId(getIdentityCA(domain).domain);\n}\n\n/** Part of the machineId comes from the publicKey, so we can use it to verify */\nexport function verifyMachineIdForPublicKey(config: {\n    machineId: string;\n    publicKey: Buffer;\n}): boolean {\n    let { machineId, publicKey } = config;\n    let domainPart = getDomainPartFromPublicKey(publicKey);\n    return machineId.split(\".\").at(-3) === domainPart;\n}\n\n// NOTE: We don't have a cache per CA, as... the CA should be set first\n//  TODO: Maybe throw if they try to change the CA after they generate any certificates?\n// TODO: Regenerate certificates after enough time (as thread certs should be relatively short lived,\n//  so it is plausible for them to expire)\n//  - We will also need to provide a callback so that users of the cert can update the cert they\n//      are using as well.\nexport function getThreadKeyCert(domain: string) {\n    return getThreadKeyCertBase(domain)();\n}\nconst getThreadKeyCertBase = cache((domain: string) => lazy(() => {\n    let ca = getIdentityCA(domain);\n    return createCertFromCA({ CAKeyPair: ca });\n}));\n\nexport const createTestBrowserKeyCert = lazy(async () => {\n    let keyPair = generateRSAKeyPair();\n    return await createX509({ domain: \"test\", issuer: \"self\", keyPair, lifeSpan: timeInDay * 365 * 20 });\n});\n\nexport function getOwnNodeId(): string {\n    let nodeId = SocketFunction.mountedNodeId;\n    if (!nodeId) {\n        throw new Error(`Node must be mounted before nodeId is accessed`);\n    }\n    return nodeId;\n}\n\nexport function getOwnNodeIdAllowUndefined() {\n    return SocketFunction.mountedNodeId;\n}"]}
+ /* _JS_SOURCE_HASH = "be134c2204a9b9ba8ae9e00631d6a5b87b56d49723154c00ab8e24807b63c905"; */