sliftutils 1.7.132 → 1.7.134

package/security/keys/deriveKeyCli.ts

@@ -0,0 +1,62 @@
+import fs from "fs/promises";
+import { expandHome } from "../helpers/paths";
+import { deriveEd25519Key } from "./deriveKey";
+import { formatOpenSSHPrivateKey, formatPublicKeyLine, parseOpenSSHPrivateKey } from "./sshKeyFile";
+
+const USAGE = `Usage: yarn derivekey <label> <source-key> <derived-key>
+
+Derives a second ed25519 key from an existing one. The same label and source key always give the
+same derived key, so it can be worked out again rather than backed up.
+
+  yarn derivekey revokegithubkey ~/authorized_keys_access/id_ed25519 ~/authorized_keys_access/id_ed25519_revoke`;
+
+async function pathExists(filePath: string) {
+    try {
+        await fs.access(filePath);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+function parseArgs(argv: string[]) {
+    if (argv.length !== 3) {
+        throw new Error(`Expected a label, a source key and a derived key, was ${argv.length} argument(s)\n${USAGE}`);
+    }
+    let [label, sourcePath, derivedPath] = argv;
+    return { label, sourcePath: expandHome(sourcePath), derivedPath: expandHome(derivedPath) };
+}
+
+async function main() {
+    let { label, sourcePath, derivedPath } = parseArgs(process.argv.slice(2));
+
+    if (!await pathExists(sourcePath)) {
+        throw new Error(`Expected a source key at ${sourcePath}, no such file exists`);
+    }
+    // Writing over a key would strand whatever it already gives access to, and the derived key can
+    // always be worked out again, so there is never a reason to overwrite.
+    if (await pathExists(derivedPath)) {
+        throw new Error(
+            `Expected ${derivedPath} to not exist, it does. Deriving the same label again gives the`
+            + ` same key, so delete it first if you want it rewritten.`
+        );
+    }
+
+    let source = parseOpenSSHPrivateKey(await fs.readFile(sourcePath, "utf8"));
+    let derived = deriveEd25519Key({ seed: source.seed, label });
+    let comment = `${source.comment || sourcePath} ${label}`.trim();
+
+    await fs.writeFile(derivedPath, formatOpenSSHPrivateKey({ seed: derived.seed, comment }), { mode: 0o600 });
+    let publicLine = formatPublicKeyLine({ publicKey: derived.publicKey, comment });
+    await fs.writeFile(`${derivedPath}.pub`, publicLine, { mode: 0o644 });
+
+    console.log(`Derived "${label}" from ${sourcePath}`);
+    console.log(`  private ${derivedPath}`);
+    console.log(`  public  ${derivedPath}.pub`);
+    console.log(publicLine.trim());
+}
+
+main().catch(e => {
+    console.error(`${e}`);
+    process.exitCode = 1;
+}).finally(() => process.exit());

package/security/keys/dist/deriveKey.ts.cache

@@ -1,19 +1,11 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 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.main = exports.deriveEd25519Key = void 0;
+//exports.deriveEd25519Key = void 0;
 const crypto_1 = __importDefault(require("crypto"));
-const promises_1 = __importDefault(require("fs/promises"));
-const paths_1 = require("../helpers/paths");
 const sshKeyFile_1 = require("./sshKeyFile");
-const USAGE = `Usage: yarn derivekey <label> <source-key> <derived-key>
-
-Derives a second ed25519 key from an existing one. The same label and source key always give the
-same derived key, so it can be worked out again rather than backed up.
-
-  yarn derivekey revokegithubkey ~/authorized_keys_access/id_ed25519 ~/authorized_keys_access/id_ed25519_revoke`;
 /** A label mixed into a key's secret to get another key, so one key can stand behind several
     identities without any of them being stored.
 
@@ -29,44 +21,5 @@ function deriveEd25519Key(config) {
     return { seed: derivedSeed, publicKey: (0, sshKeyFile_1.publicKeyFromSeed)(derivedSeed) };
 }
 exports.deriveEd25519Key = deriveEd25519Key;
-async function pathExists(filePath) {
-    try {
-        await promises_1.default.access(filePath);
-        return true;
-    }
-    catch (e) {
-        return false;
-    }
-}
-function parseArgs(argv) {
-    if (argv.length !== 3) {
-        throw new Error(`Expected a label, a source key and a derived key, was ${argv.length} argument(s)\n${USAGE}`);
-    }
-    let [label, sourcePath, derivedPath] = argv;
-    return { label, sourcePath: (0, paths_1.expandHome)(sourcePath), derivedPath: (0, paths_1.expandHome)(derivedPath) };
-}
-async function main() {
-    let { label, sourcePath, derivedPath } = parseArgs(process.argv.slice(2));
-    if (!await pathExists(sourcePath)) {
-        throw new Error(`Expected a source key at ${sourcePath}, no such file exists`);
-    }
-    // Writing over a key would strand whatever it already gives access to, and the derived key can
-    // always be worked out again, so there is never a reason to overwrite.
-    if (await pathExists(derivedPath)) {
-        throw new Error(`Expected ${derivedPath} to not exist, it does. Deriving the same label again gives the`
-            + ` same key, so delete it first if you want it rewritten.`);
-    }
-    let source = (0, sshKeyFile_1.parseOpenSSHPrivateKey)(await promises_1.default.readFile(sourcePath, "utf8"));
-    let derived = deriveEd25519Key({ seed: source.seed, label });
-    let comment = `${source.comment || sourcePath} ${label}`.trim();
-    await promises_1.default.writeFile(derivedPath, (0, sshKeyFile_1.formatOpenSSHPrivateKey)({ seed: derived.seed, comment }), { mode: 0o600 });
-    let publicLine = (0, sshKeyFile_1.formatPublicKeyLine)({ publicKey: derived.publicKey, comment });
-    await promises_1.default.writeFile(`${derivedPath}.pub`, publicLine, { mode: 0o644 });
-    console.log(`Derived "${label}" from ${sourcePath}`);
-    console.log(`  private ${derivedPath}`);
-    console.log(`  public  ${derivedPath}.pub`);
-    console.log(publicLine.trim());
-}
-exports.main = main;
-//# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "7d3b190d59d20686acd4f001d6c457d0b90d75d2ae382d6aff4571bb3310be76"; */
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "75e42547d4bd83c3e959146be41b8ccc9673817c2f5e581d7a1a17675e8b9548"; */

package/security/keys/dist/sshKeyFile.ts.cache

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
 };
@@ -64,6 +64,8 @@ function publicKeyFromSeed(seed) {
         type: "pkcs8",
     });
     // The spki wrapper is a fixed 12 byte header followed by the raw key.
+    // The cast is because some @types/node versions don't accept a KeyObject here, even though the
+    // runtime always has. Consumers compile us with their own @types/node, so this has to not fail.
     return crypto_1.default.createPublicKey(privateKey).export({ format: "der", type: "spki" }).subarray(12);
 }
 exports.publicKeyFromSeed = publicKeyFromSeed;
@@ -149,5 +151,5 @@ function formatPublicKeyLine(config) {
     return `${KEY_TYPE} ${blob.toString("base64")}${comment && ` ${comment}` || ""}\n`;
 }
 exports.formatPublicKeyLine = formatPublicKeyLine;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sshKeyFile.js","sourceRoot":"","sources":["sshKeyFile.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\n\n// OpenSSH keeps private keys in its own container rather than anything node can read, so the few\n// bytes of it we need are handled here. Only unencrypted ed25519 keys are supported, which is what\n// a key used by automation is.\n\nconst MAGIC = \"openssh-key-v1\\0\";\nconst KEY_TYPE = \"ssh-ed25519\";\nconst NONE = \"none\";\nconst SEED_LENGTH = 32;\nconst PUBLIC_LENGTH = 32;\n// The one block size that matters here, since nothing is encrypted.\nconst PADDING_BLOCK = 8;\nconst PEM_LINE_LENGTH = 70;\nconst PRIVATE_HEADER = \"-----BEGIN OPENSSH PRIVATE KEY-----\";\nconst PRIVATE_FOOTER = \"-----END OPENSSH PRIVATE KEY-----\";\n// The prefix that turns a bare 32 byte seed into a pkcs8 ed25519 key node will accept.\nconst PKCS8_ED25519_PREFIX = Buffer.from(\"302e020100300506032b657004220420\", \"hex\");\n\nclass ByteReader {\n    private offset = 0;\n    constructor(private buffer: Buffer) { }\n\n    readBytes(length: number) {\n        let value = this.buffer.subarray(this.offset, this.offset + length);\n        if (value.length !== length) {\n            throw new Error(`Expected ${length} bytes at offset ${this.offset}, was ${value.length}`);\n        }\n        this.offset += length;\n        return value;\n    }\n\n    readUInt32() {\n        let value = this.buffer.readUInt32BE(this.offset);\n        this.offset += 4;\n        return value;\n    }\n\n    readString() {\n        return this.readBytes(this.readUInt32());\n    }\n}\n\nfunction writeString(value: Buffer | string) {\n    let contents = Buffer.isBuffer(value) && value || Buffer.from(value, \"utf8\");\n    let length = Buffer.alloc(4);\n    length.writeUInt32BE(contents.length);\n    return Buffer.concat([length, contents]);\n}\n\nfunction writeUInt32(value: number) {\n    let bytes = Buffer.alloc(4);\n    bytes.writeUInt32BE(value);\n    return bytes;\n}\n\n/** The public key of a seed, worked out by node rather than by reimplementing the curve. */\nexport function publicKeyFromSeed(seed: Buffer) {\n    if (seed.length !== SEED_LENGTH) {\n        throw new Error(`Expected a ${SEED_LENGTH} byte seed, was ${seed.length}`);\n    }\n    let privateKey = crypto.createPrivateKey({\n        key: Buffer.concat([PKCS8_ED25519_PREFIX, seed]),\n        format: \"der\",\n        type: \"pkcs8\",\n    });\n    // The spki wrapper is a fixed 12 byte header followed by the raw key.\n    return crypto.createPublicKey(privateKey).export({ format: \"der\", type: \"spki\" }).subarray(12);\n}\n\nexport function parseOpenSSHPrivateKey(contents: string) {\n    let body = contents.split(\"\\n\").filter(line => line.trim() && !line.startsWith(\"-----\")).join(\"\");\n    if (!contents.includes(PRIVATE_HEADER)) {\n        throw new Error(`Expected an OpenSSH private key starting with ${PRIVATE_HEADER}`);\n    }\n    let reader = new ByteReader(Buffer.from(body, \"base64\"));\n    if (reader.readBytes(MAGIC.length).toString() !== MAGIC) {\n        throw new Error(`Expected the key to start with ${JSON.stringify(MAGIC)}`);\n    }\n    let cipherName = reader.readString().toString();\n    let kdfName = reader.readString().toString();\n    reader.readString();\n    if (cipherName !== NONE || kdfName !== NONE) {\n        throw new Error(\n            `Expected an unencrypted key, was encrypted with ${cipherName}/${kdfName}.`\n            + ` Remove the passphrase with \"ssh-keygen -p\" first.`\n        );\n    }\n    let keyCount = reader.readUInt32();\n    if (keyCount !== 1) {\n        throw new Error(`Expected the key file to hold one key, held ${keyCount}`);\n    }\n    reader.readString();\n\n    let privateSection = new ByteReader(reader.readString());\n    let checkOne = privateSection.readUInt32();\n    let checkTwo = privateSection.readUInt32();\n    if (checkOne !== checkTwo) {\n        throw new Error(`Expected the key's two check values to match, were ${checkOne} and ${checkTwo}`);\n    }\n    let keyType = privateSection.readString().toString();\n    if (keyType !== KEY_TYPE) {\n        throw new Error(`Expected an ${KEY_TYPE} key, was ${keyType}`);\n    }\n    privateSection.readString();\n    // OpenSSH stores the seed and the public key together in the private field.\n    let privateValue = privateSection.readString();\n    if (privateValue.length !== SEED_LENGTH + PUBLIC_LENGTH) {\n        throw new Error(`Expected a ${SEED_LENGTH + PUBLIC_LENGTH} byte private value, was ${privateValue.length}`);\n    }\n    return {\n        seed: privateValue.subarray(0, SEED_LENGTH),\n        publicKey: privateValue.subarray(SEED_LENGTH),\n        comment: privateSection.readString().toString(),\n    };\n}\n\nexport function formatOpenSSHPrivateKey(config: { seed: Buffer; comment: string }) {\n    let { seed, comment } = config;\n    let publicKey = publicKeyFromSeed(seed);\n    let publicBlob = Buffer.concat([writeString(KEY_TYPE), writeString(publicKey)]);\n\n    // The check value only proves a passphrase decrypted correctly, and nothing here is encrypted.\n    // Taking it from the seed keeps the same input producing the same file, so deriving a key twice\n    // is something you can compare rather than something that looks different every time.\n    let check = crypto.createHash(\"sha256\").update(seed).digest().readUInt32BE(0);\n    let privateSection = Buffer.concat([\n        writeUInt32(check),\n        writeUInt32(check),\n        writeString(KEY_TYPE),\n        writeString(publicKey),\n        writeString(Buffer.concat([seed, publicKey])),\n        writeString(comment),\n    ]);\n    let paddingLength = (PADDING_BLOCK - privateSection.length % PADDING_BLOCK) % PADDING_BLOCK;\n    let padding = Buffer.from(Array.from({ length: paddingLength }, (unused, index) => index + 1));\n\n    let contents = Buffer.concat([\n        Buffer.from(MAGIC),\n        writeString(NONE),\n        writeString(NONE),\n        writeString(\"\"),\n        writeUInt32(1),\n        writeString(publicBlob),\n        writeString(Buffer.concat([privateSection, padding])),\n    ]);\n    let encoded = contents.toString(\"base64\").match(new RegExp(`.{1,${PEM_LINE_LENGTH}}`, \"g\")) || [];\n    return `${PRIVATE_HEADER}\\n${encoded.join(\"\\n\")}\\n${PRIVATE_FOOTER}\\n`;\n}\n\n/** The single line form, as it appears in authorized_keys and in a .pub file. */\nexport function formatPublicKeyLine(config: { publicKey: Buffer; comment: string }) {\n    let { publicKey, comment } = config;\n    let blob = Buffer.concat([writeString(KEY_TYPE), writeString(publicKey)]);\n    return `${KEY_TYPE} ${blob.toString(\"base64\")}${comment && ` ${comment}` || \"\"}\\n`;\n}\n"]}
- /* _JS_SOURCE_HASH = "57e4d1fd38c49a01bb35cf57a53a29f28eb2053b81167b87b4c17bab13251fae"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sshKeyFile.js","sourceRoot":"","sources":["sshKeyFile.ts"],"names":[],"mappings":"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","sourcesContent":["import crypto from \"crypto\";\n\n// OpenSSH keeps private keys in its own container rather than anything node can read, so the few\n// bytes of it we need are handled here. Only unencrypted ed25519 keys are supported, which is what\n// a key used by automation is.\n\nconst MAGIC = \"openssh-key-v1\\0\";\nconst KEY_TYPE = \"ssh-ed25519\";\nconst NONE = \"none\";\nconst SEED_LENGTH = 32;\nconst PUBLIC_LENGTH = 32;\n// The one block size that matters here, since nothing is encrypted.\nconst PADDING_BLOCK = 8;\nconst PEM_LINE_LENGTH = 70;\nconst PRIVATE_HEADER = \"-----BEGIN OPENSSH PRIVATE KEY-----\";\nconst PRIVATE_FOOTER = \"-----END OPENSSH PRIVATE KEY-----\";\n// The prefix that turns a bare 32 byte seed into a pkcs8 ed25519 key node will accept.\nconst PKCS8_ED25519_PREFIX = Buffer.from(\"302e020100300506032b657004220420\", \"hex\");\n\nclass ByteReader {\n    private offset = 0;\n    constructor(private buffer: Buffer) { }\n\n    readBytes(length: number) {\n        let value = this.buffer.subarray(this.offset, this.offset + length);\n        if (value.length !== length) {\n            throw new Error(`Expected ${length} bytes at offset ${this.offset}, was ${value.length}`);\n        }\n        this.offset += length;\n        return value;\n    }\n\n    readUInt32() {\n        let value = this.buffer.readUInt32BE(this.offset);\n        this.offset += 4;\n        return value;\n    }\n\n    readString() {\n        return this.readBytes(this.readUInt32());\n    }\n}\n\nfunction writeString(value: Buffer | string) {\n    let contents = Buffer.isBuffer(value) && value || Buffer.from(value, \"utf8\");\n    let length = Buffer.alloc(4);\n    length.writeUInt32BE(contents.length);\n    return Buffer.concat([length, contents]);\n}\n\nfunction writeUInt32(value: number) {\n    let bytes = Buffer.alloc(4);\n    bytes.writeUInt32BE(value);\n    return bytes;\n}\n\n/** The public key of a seed, worked out by node rather than by reimplementing the curve. */\nexport function publicKeyFromSeed(seed: Buffer) {\n    if (seed.length !== SEED_LENGTH) {\n        throw new Error(`Expected a ${SEED_LENGTH} byte seed, was ${seed.length}`);\n    }\n    let privateKey = crypto.createPrivateKey({\n        key: Buffer.concat([PKCS8_ED25519_PREFIX, seed]),\n        format: \"der\",\n        type: \"pkcs8\",\n    });\n    // The spki wrapper is a fixed 12 byte header followed by the raw key.\n    // The cast is because some @types/node versions don't accept a KeyObject here, even though the\n    // runtime always has. Consumers compile us with their own @types/node, so this has to not fail.\n    return crypto.createPublicKey(privateKey as any).export({ format: \"der\", type: \"spki\" }).subarray(12);\n}\n\nexport function parseOpenSSHPrivateKey(contents: string) {\n    let body = contents.split(\"\\n\").filter(line => line.trim() && !line.startsWith(\"-----\")).join(\"\");\n    if (!contents.includes(PRIVATE_HEADER)) {\n        throw new Error(`Expected an OpenSSH private key starting with ${PRIVATE_HEADER}`);\n    }\n    let reader = new ByteReader(Buffer.from(body, \"base64\"));\n    if (reader.readBytes(MAGIC.length).toString() !== MAGIC) {\n        throw new Error(`Expected the key to start with ${JSON.stringify(MAGIC)}`);\n    }\n    let cipherName = reader.readString().toString();\n    let kdfName = reader.readString().toString();\n    reader.readString();\n    if (cipherName !== NONE || kdfName !== NONE) {\n        throw new Error(\n            `Expected an unencrypted key, was encrypted with ${cipherName}/${kdfName}.`\n            + ` Remove the passphrase with \"ssh-keygen -p\" first.`\n        );\n    }\n    let keyCount = reader.readUInt32();\n    if (keyCount !== 1) {\n        throw new Error(`Expected the key file to hold one key, held ${keyCount}`);\n    }\n    reader.readString();\n\n    let privateSection = new ByteReader(reader.readString());\n    let checkOne = privateSection.readUInt32();\n    let checkTwo = privateSection.readUInt32();\n    if (checkOne !== checkTwo) {\n        throw new Error(`Expected the key's two check values to match, were ${checkOne} and ${checkTwo}`);\n    }\n    let keyType = privateSection.readString().toString();\n    if (keyType !== KEY_TYPE) {\n        throw new Error(`Expected an ${KEY_TYPE} key, was ${keyType}`);\n    }\n    privateSection.readString();\n    // OpenSSH stores the seed and the public key together in the private field.\n    let privateValue = privateSection.readString();\n    if (privateValue.length !== SEED_LENGTH + PUBLIC_LENGTH) {\n        throw new Error(`Expected a ${SEED_LENGTH + PUBLIC_LENGTH} byte private value, was ${privateValue.length}`);\n    }\n    return {\n        seed: privateValue.subarray(0, SEED_LENGTH),\n        publicKey: privateValue.subarray(SEED_LENGTH),\n        comment: privateSection.readString().toString(),\n    };\n}\n\nexport function formatOpenSSHPrivateKey(config: { seed: Buffer; comment: string }) {\n    let { seed, comment } = config;\n    let publicKey = publicKeyFromSeed(seed);\n    let publicBlob = Buffer.concat([writeString(KEY_TYPE), writeString(publicKey)]);\n\n    // The check value only proves a passphrase decrypted correctly, and nothing here is encrypted.\n    // Taking it from the seed keeps the same input producing the same file, so deriving a key twice\n    // is something you can compare rather than something that looks different every time.\n    let check = crypto.createHash(\"sha256\").update(seed).digest().readUInt32BE(0);\n    let privateSection = Buffer.concat([\n        writeUInt32(check),\n        writeUInt32(check),\n        writeString(KEY_TYPE),\n        writeString(publicKey),\n        writeString(Buffer.concat([seed, publicKey])),\n        writeString(comment),\n    ]);\n    let paddingLength = (PADDING_BLOCK - privateSection.length % PADDING_BLOCK) % PADDING_BLOCK;\n    let padding = Buffer.from(Array.from({ length: paddingLength }, (unused, index) => index + 1));\n\n    let contents = Buffer.concat([\n        Buffer.from(MAGIC),\n        writeString(NONE),\n        writeString(NONE),\n        writeString(\"\"),\n        writeUInt32(1),\n        writeString(publicBlob),\n        writeString(Buffer.concat([privateSection, padding])),\n    ]);\n    let encoded = contents.toString(\"base64\").match(new RegExp(`.{1,${PEM_LINE_LENGTH}}`, \"g\")) || [];\n    return `${PRIVATE_HEADER}\\n${encoded.join(\"\\n\")}\\n${PRIVATE_FOOTER}\\n`;\n}\n\n/** The single line form, as it appears in authorized_keys and in a .pub file. */\nexport function formatPublicKeyLine(config: { publicKey: Buffer; comment: string }) {\n    let { publicKey, comment } = config;\n    let blob = Buffer.concat([writeString(KEY_TYPE), writeString(publicKey)]);\n    return `${KEY_TYPE} ${blob.toString(\"base64\")}${comment && ` ${comment}` || \"\"}\\n`;\n}\n"]}
+ /* _JS_SOURCE_HASH = "629a39d201a3d9768982a87af94e10e99f5ed0cbcd68e4e6f9b783eeb6298be2"; */

package/security/keys/sshKeyFile.ts

@@ -65,7 +65,9 @@ export function publicKeyFromSeed(seed: Buffer) {
         type: "pkcs8",
     });
     // The spki wrapper is a fixed 12 byte header followed by the raw key.
-    return crypto.createPublicKey(privateKey).export({ format: "der", type: "spki" }).subarray(12);
+    // The cast is because some @types/node versions don't accept a KeyObject here, even though the
+    // runtime always has. Consumers compile us with their own @types/node, so this has to not fail.
+    return crypto.createPublicKey(privateKey as any).export({ format: "der", type: "spki" }).subarray(12);
 }
 
 export function parseOpenSSHPrivateKey(contents: string) {

package/security/machines/addMachine.ts

@@ -1,16 +1,12 @@
-import os from "os";
 import { runPromise } from "socket-function/src/runPromise";
+import { getOwnMachineId, loadIdentityCA } from "../../misc/https/certs";
 import { getOwnIPs } from "../../misc/ownIPs";
-import { describeHost } from "../helpers/remoteSSH";
-import { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from "./identity";
 import { resolveKeysRepo } from "../authorizedKeys/keysRepo";
 import { signRepo } from "../signedFiles/signFiles";
-import { getMachines, setMachines } from "./machines";
+import { getMachines, getOrCreateRemoteMachineId, setMachines } from "./machines";
 
 const GIT_KEYWORD = "git";
 const COMMIT_MESSAGE = "trusting a machine";
-// A machine id is the base32 hash of a public key, written with a leading b. Nothing else that can
-// appear in these arguments looks like that, which is what tells it apart from an ssh target.
 const MACHINE_ID = /^b[a-z2-7]{20}$/;
 const USAGE = `Usage:
   yarn addmachine <domain> [${GIT_KEYWORD}]
@@ -29,11 +25,9 @@ It edits the keys repo this machine reads, wherever that is, not whatever direct
 from. With ${GIT_KEYWORD} it signs, commits and pushes; without it nothing else will believe any of
 this until you do.`;
 
-/** A domain, then either nothing, an ssh host, or a machine id and the addresses it may talk from. */
 function parseArgs(argv: string[]) {
     let pushToGit = argv.includes(GIT_KEYWORD);
-    let positional = argv.filter(arg => arg !== GIT_KEYWORD);
-    let [domain, second, ...rest] = positional;
+    let [domain, second, ...rest] = argv.filter(arg => arg !== GIT_KEYWORD);
     if (!domain) {
         throw new Error(`Expected a domain\n${USAGE}`);
     }
@@ -55,70 +49,47 @@ function parseArgs(argv: string[]) {
     return { domain, host: second, machineId: "", addresses: [] as string[], pushToGit };
 }
 
-export async function main() {
-    let { domain, host, machineId, addresses, pushToGit } = parseArgs(process.argv.slice(2));
-    // The same repo the acceptance check reads. Editing anything else would write a machine list
-    // nothing on this machine ever looks at.
-    let { repoPath } = await resolveKeysRepo();
-
-    let describe = machineId;
+/** Which machine to trust, and from which addresses. A named machine and its addresses as given, a
+    machine reached over ssh at the address it was named by, or this machine at its own addresses. */
+async function resolveMachine(config: { domain: string; host: string; machineId: string; addresses: string[] }) {
+    let { domain, host, machineId, addresses } = config;
     if (machineId) {
-        // Named outright, so there is nothing to ask anyone. The id is the hash of that machine's
-        // public key, so naming it is enough - it still has to prove it holds the key before any
-        // of this means anything.
-        describe = `${machineId} (named)`;
-    } else if (!host) {
-        let identity = await localIdentity(domain);
-        if (!identity) {
-            throw new Error(
-                `Expected an identity for ${domain} in ${os.homedir()}, this machine has none.\n`
-                + `It has: ${(await localDomains()).join(", ") || "no identities at all"}\n`
-                + `One is generated the first time something runs here under a domain, so run that`
-                + ` first, or name another machine to add instead.`
-            );
-        }
-        machineId = identity.machineId;
-        describe = identity.fullDomain;
-        addresses = await getOwnIPs();
-        if (!addresses.length) {
-            throw new Error(`Expected this machine to have an address anything else can see, it has none`);
-        }
-    } else {
-        // Nothing there under this domain means it gets one. Its own from this point on: the key
-        // is written there and nothing keeps a copy.
-        let found = await remoteIdentity(host, domain);
-        if (!found) {
-            console.log(`${describeHost(host)} has no identity for ${domain}, generating one`);
-        }
-        let identity: Identity = found || await createRemoteIdentity({ host, domain });
-        machineId = identity.machineId;
-        describe = identity.fullDomain;
-        // The address it was named by is the address it talks to us from, which is the one thing
-        // it cannot lie about.
-        addresses = [host];
+        return { machineId, addresses };
     }
+    if (host) {
+        return { machineId: await getOrCreateRemoteMachineId(host, domain), addresses: [host] };
+    }
+    await loadIdentityCA(domain);
+    let ownAddresses = await getOwnIPs();
+    if (!ownAddresses.length) {
+        throw new Error(`Expected this machine to have an address anything else can see, it has none`);
+    }
+    return { machineId: getOwnMachineId(domain), addresses: ownAddresses };
+}
+
+async function main() {
+    let { domain, host, machineId, addresses, pushToGit } = parseArgs(process.argv.slice(2));
+    let { repoPath } = await resolveKeysRepo();
+    let target = await resolveMachine({ domain, host, machineId, addresses });
 
-    // The whole list is read and written back, because setting is by the set: writing this one
-    // machine alone would remove every other machine from the repo.
     let machines = await getMachines(repoPath);
-    let existing = machines.find(machine => machine.machineId === machineId);
+    let existing = machines.find(machine => machine.machineId === target.machineId);
     let ips = [...(existing?.ips || [])];
-    let added = addresses.filter(address => !ips.includes(address));
+    let added = target.addresses.filter(address => !ips.includes(address));
     if (existing) {
         existing.ips = [...ips, ...added];
     } else {
-        machines.push({ machineId, ips: [...added], addedAt: "" });
+        machines.push({ machineId: target.machineId, ips: [...added], addedAt: "" });
     }
     await setMachines({ repoPath, machines });
 
-    console.log(`\nTrusting machine ${machineId}`);
+    console.log(`\nTrusting machine ${target.machineId}`);
     console.log(`Allowing IP ${[...ips, ...added].join(", ")}`);
     if (added.length) {
-        console.log(`  added to machines/${machineId}.json: ${added.join(", ")}`);
+        console.log(`  added to machines/${target.machineId}.json: ${added.join(", ")}`);
     } else {
-        console.log(`  already allowed from ${addresses.join(", ")}`);
+        console.log(`  already allowed from ${target.addresses.join(", ")}`);
     }
-    console.log(`  identity ${describe}`);
     console.log(`  in ${repoPath}`);
 
     if (!pushToGit) {
@@ -126,11 +97,14 @@ export async function main() {
         console.log(`\`\`\`\nyarn signfiles ${GIT_KEYWORD}\n\`\`\``);
         return;
     }
-    // Signed here rather than left as a step to remember, the same as unrevoke does it. A machine
-    // list nobody signed is ignored by every machine that reads it.
     await signRepo({ repoPath });
     await runPromise(`git add -A`, { cwd: repoPath });
     await runPromise(`git commit -m "${COMMIT_MESSAGE}"`, { cwd: repoPath });
     await runPromise(`git push`, { cwd: repoPath });
-    console.log(`\nSigned, committed and pushed. Machines pick it up as they sync.`);
+    console.log(`\nSigned, committed and pushed. Machines will pick it up the next time they poll, within 60 seconds.`);
 }
+
+main().catch(e => {
+    console.error(`${e}`);
+    process.exitCode = 1;
+}).finally(() => process.exit());

package/security/machines/dist/addMachine.ts.cache

@@ -1,89 +1,104 @@
 "use strict";
-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.main = void 0;
-const os_1 = __importDefault(require("os"));
+const runPromise_1 = require("socket-function/src/runPromise");
+const certs_1 = require("../../misc/https/certs");
 const ownIPs_1 = require("../../misc/ownIPs");
-const remoteSSH_1 = require("../helpers/remoteSSH");
-const identity_1 = require("./identity");
 const keysRepo_1 = require("../authorizedKeys/keysRepo");
+const signFiles_1 = require("../signedFiles/signFiles");
 const machines_1 = require("./machines");
-const USAGE = `Usage: yarn addmachine <domain> [ip]
+const GIT_KEYWORD = "git";
+const COMMIT_MESSAGE = "trusting a machine";
+const MACHINE_ID = /^b[a-z2-7]{20}$/;
+const USAGE = `Usage:
+  yarn addmachine <domain> [${GIT_KEYWORD}]
+  yarn addmachine <domain> <ssh-host> [${GIT_KEYWORD}]
+  yarn addmachine <domain> <machine-id> <ip> [ip...] [${GIT_KEYWORD}]
 
 The domain is required: a machine has a different identity, and so a different machine id, under
 every domain it runs under, so there is no such thing as "this machine" without one.
 
-With no ip it adds this machine, with its own addresses. With an ip it asks that machine over ssh
-for its identity under that domain, gives it one if it has none, and adds it under that address.
+With nothing else it adds this machine, with its own addresses. With an ssh host it asks that
+machine for its identity under that domain, gives it one if it has none, and adds it under that
+address. With a machine id it adds exactly that machine at exactly those addresses, without
+talking to anything.
 
 It edits the keys repo this machine reads, wherever that is, not whatever directory this was run
-from. Nothing is signed or pushed here. Run "yarn signfiles git" in that repo afterwards, or no
-machine will believe any of it.`;
-async function main() {
-    let argv = process.argv.slice(2);
-    if (!argv.length || argv.length > 2) {
-        throw new Error(`Expected a domain and optionally an ip, was ${argv.length} argument(s)\n${USAGE}`);
+from. With ${GIT_KEYWORD} it signs, commits and pushes; without it nothing else will believe any of
+this until you do.`;
+function parseArgs(argv) {
+    let pushToGit = argv.includes(GIT_KEYWORD);
+    let [domain, second, ...rest] = argv.filter(arg => arg !== GIT_KEYWORD);
+    if (!domain) {
+        throw new Error(`Expected a domain\n${USAGE}`);
     }
-    let [domain, host = ""] = argv;
-    // The same repo the acceptance check reads. Editing anything else would write a machine list
-    // nothing on this machine ever looks at.
-    let { repoPath } = await (0, keysRepo_1.resolveKeysRepo)();
-    let identity;
-    let addresses;
-    if (!host) {
-        let found = await (0, identity_1.localIdentity)(domain);
-        if (!found) {
-            throw new Error(`Expected an identity for ${domain} in ${os_1.default.homedir()}, this machine has none.\n`
-                + `It has: ${(await (0, identity_1.localDomains)()).join(", ") || "no identities at all"}\n`
-                + `One is generated the first time something runs here under a domain, so run that`
-                + ` first, or name another machine to add instead.`);
-        }
-        identity = found;
-        addresses = await (0, ownIPs_1.getOwnIPs)();
-        if (!addresses.length) {
-            throw new Error(`Expected this machine to have an address anything else can see, it has none`);
-        }
+    if (!second) {
+        return { domain, host: "", machineId: "", addresses: [], pushToGit };
     }
-    else {
-        // Nothing there under this domain means it gets one. Its own from this point on: the key
-        // is written there and nothing keeps a copy.
-        let found = await (0, identity_1.remoteIdentity)(host, domain);
-        if (!found) {
-            console.log(`${(0, remoteSSH_1.describeHost)(host)} has no identity for ${domain}, generating one`);
+    if (MACHINE_ID.test(second)) {
+        if (!rest.length) {
+            throw new Error(`Expected at least one address for ${second}, was none\n${USAGE}`);
         }
-        identity = found || await (0, identity_1.createRemoteIdentity)({ host, domain });
-        // The address it was named by is the address it talks to us from, which is the one thing
-        // it cannot lie about.
-        addresses = [host];
+        return { domain, host: "", machineId: second, addresses: rest, pushToGit };
+    }
+    if (rest.length) {
+        throw new Error(`Expected nothing after the ssh host ${second}, was ${rest.join(" ")}.\n`
+            + `Addresses are only given alongside a machine id.\n${USAGE}`);
+    }
+    return { domain, host: second, machineId: "", addresses: [], pushToGit };
+}
+/** Which machine to trust, and from which addresses. A named machine and its addresses as given, a
+    machine reached over ssh at the address it was named by, or this machine at its own addresses. */
+async function resolveMachine(config) {
+    let { domain, host, machineId, addresses } = config;
+    if (machineId) {
+        return { machineId, addresses };
+    }
+    if (host) {
+        return { machineId: await (0, machines_1.getOrCreateRemoteMachineId)(host, domain), addresses: [host] };
     }
-    // The whole list is read and written back, because setting is by the set: writing this one
-    // machine alone would remove every other machine from the repo.
+    await (0, certs_1.loadIdentityCA)(domain);
+    let ownAddresses = await (0, ownIPs_1.getOwnIPs)();
+    if (!ownAddresses.length) {
+        throw new Error(`Expected this machine to have an address anything else can see, it has none`);
+    }
+    return { machineId: (0, certs_1.getOwnMachineId)(domain), addresses: ownAddresses };
+}
+async function main() {
+    let { domain, host, machineId, addresses, pushToGit } = parseArgs(process.argv.slice(2));
+    let { repoPath } = await (0, keysRepo_1.resolveKeysRepo)();
+    let target = await resolveMachine({ domain, host, machineId, addresses });
     let machines = await (0, machines_1.getMachines)(repoPath);
-    let existing = machines.find(machine => machine.machineId === identity.machineId);
+    let existing = machines.find(machine => machine.machineId === target.machineId);
     let ips = [...((existing === null || existing === void 0 ? void 0 : existing.ips) || [])];
-    let added = addresses.filter(address => !ips.includes(address));
+    let added = target.addresses.filter(address => !ips.includes(address));
     if (existing) {
         existing.ips = [...ips, ...added];
     }
     else {
-        machines.push({ machineId: identity.machineId, ips: [...added], addedAt: "" });
+        machines.push({ machineId: target.machineId, ips: [...added], addedAt: "" });
     }
     await (0, machines_1.setMachines)({ repoPath, machines });
-    console.log(`\nTrusting machine ${identity.machineId}`);
+    console.log(`\nTrusting machine ${target.machineId}`);
     console.log(`Allowing IP ${[...ips, ...added].join(", ")}`);
     if (added.length) {
-        console.log(`  added to machines/${identity.machineId}.json: ${added.join(", ")}`);
+        console.log(`  added to machines/${target.machineId}.json: ${added.join(", ")}`);
     }
     else {
-        console.log(`  already allowed from ${addresses.join(", ")}`);
+        console.log(`  already allowed from ${target.addresses.join(", ")}`);
     }
-    console.log(`  identity ${identity.fullDomain}`);
     console.log(`  in ${repoPath}`);
-    console.log(`\nNothing believes this until it is signed. In that repo, run:`);
-    console.log(`\`\`\`\nyarn signfiles git\n\`\`\``);
+    if (!pushToGit) {
+        console.log(`\nNothing believes this until it is signed. In that repo, run:`);
+        console.log(`\`\`\`\nyarn signfiles ${GIT_KEYWORD}\n\`\`\``);
+        return;
+    }
+    await (0, signFiles_1.signRepo)({ repoPath });
+    await (0, runPromise_1.runPromise)(`git add -A`, { cwd: repoPath });
+    await (0, runPromise_1.runPromise)(`git commit -m "${COMMIT_MESSAGE}"`, { cwd: repoPath });
+    await (0, runPromise_1.runPromise)(`git push`, { cwd: repoPath });
+    console.log(`\nSigned, committed and pushed. Machines pick it up as they sync.`);
 }
 exports.main = main;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"addMachine.js","sourceRoot":"","sources":["addMachine.ts"],"names":[],"mappings":"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","sourcesContent":["import os from \"os\";\nimport { getOwnIPs } from \"../../misc/ownIPs\";\nimport { describeHost } from \"../helpers/remoteSSH\";\nimport { createRemoteIdentity, Identity, localDomains, localIdentity, remoteIdentity } from \"./identity\";\nimport { resolveKeysRepo } from \"../authorizedKeys/keysRepo\";\nimport { getMachines, setMachines } from \"./machines\";\n\nconst USAGE = `Usage: yarn addmachine <domain> [ip]\n\nThe domain is required: a machine has a different identity, and so a different machine id, under\nevery domain it runs under, so there is no such thing as \"this machine\" without one.\n\nWith no ip it adds this machine, with its own addresses. With an ip it asks that machine over ssh\nfor its identity under that domain, gives it one if it has none, and adds it under that address.\n\nIt edits the keys repo this machine reads, wherever that is, not whatever directory this was run\nfrom. Nothing is signed or pushed here. Run \"yarn signfiles git\" in that repo afterwards, or no\nmachine will believe any of it.`;\n\nexport async function main() {\n    let argv = process.argv.slice(2);\n    if (!argv.length || argv.length > 2) {\n        throw new Error(`Expected a domain and optionally an ip, was ${argv.length} argument(s)\\n${USAGE}`);\n    }\n    let [domain, host = \"\"] = argv;\n    // The same repo the acceptance check reads. Editing anything else would write a machine list\n    // nothing on this machine ever looks at.\n    let { repoPath } = await resolveKeysRepo();\n\n    let identity: Identity;\n    let addresses: string[];\n    if (!host) {\n        let found = await localIdentity(domain);\n        if (!found) {\n            throw new Error(\n                `Expected an identity for ${domain} in ${os.homedir()}, this machine has none.\\n`\n                + `It has: ${(await localDomains()).join(\", \") || \"no identities at all\"}\\n`\n                + `One is generated the first time something runs here under a domain, so run that`\n                + ` first, or name another machine to add instead.`\n            );\n        }\n        identity = found;\n        addresses = await getOwnIPs();\n        if (!addresses.length) {\n            throw new Error(`Expected this machine to have an address anything else can see, it has none`);\n        }\n    } else {\n        // Nothing there under this domain means it gets one. Its own from this point on: the key\n        // is written there and nothing keeps a copy.\n        let found = await remoteIdentity(host, domain);\n        if (!found) {\n            console.log(`${describeHost(host)} has no identity for ${domain}, generating one`);\n        }\n        identity = found || await createRemoteIdentity({ host, domain });\n        // The address it was named by is the address it talks to us from, which is the one thing\n        // it cannot lie about.\n        addresses = [host];\n    }\n\n    // The whole list is read and written back, because setting is by the set: writing this one\n    // machine alone would remove every other machine from the repo.\n    let machines = await getMachines(repoPath);\n    let existing = machines.find(machine => machine.machineId === identity.machineId);\n    let ips = [...(existing?.ips || [])];\n    let added = addresses.filter(address => !ips.includes(address));\n    if (existing) {\n        existing.ips = [...ips, ...added];\n    } else {\n        machines.push({ machineId: identity.machineId, ips: [...added], addedAt: \"\" });\n    }\n    await setMachines({ repoPath, machines });\n\n    console.log(`\\nTrusting machine ${identity.machineId}`);\n    console.log(`Allowing IP ${[...ips, ...added].join(\", \")}`);\n    if (added.length) {\n        console.log(`  added to machines/${identity.machineId}.json: ${added.join(\", \")}`);\n    } else {\n        console.log(`  already allowed from ${addresses.join(\", \")}`);\n    }\n    console.log(`  identity ${identity.fullDomain}`);\n    console.log(`  in ${repoPath}`);\n    console.log(`\\nNothing believes this until it is signed. In that repo, run:`);\n    console.log(`\\`\\`\\`\\nyarn signfiles git\\n\\`\\`\\``);\n}\n"]}
- /* _JS_SOURCE_HASH = "a28aef51d4e5c15665559ba6341cc219350f5b54987e7f2f257ccacaf827c938"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"addMachine.js","sourceRoot":"","sources":["addMachine.ts"],"names":[],"mappings":"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","sourcesContent":["import { runPromise } from \"socket-function/src/runPromise\";\nimport { getOwnMachineId, loadIdentityCA } from \"../../misc/https/certs\";\nimport { getOwnIPs } from \"../../misc/ownIPs\";\nimport { resolveKeysRepo } from \"../authorizedKeys/keysRepo\";\nimport { signRepo } from \"../signedFiles/signFiles\";\nimport { getMachines, getOrCreateRemoteMachineId, setMachines } from \"./machines\";\n\nconst GIT_KEYWORD = \"git\";\nconst COMMIT_MESSAGE = \"trusting a machine\";\nconst MACHINE_ID = /^b[a-z2-7]{20}$/;\nconst USAGE = `Usage:\n  yarn addmachine <domain> [${GIT_KEYWORD}]\n  yarn addmachine <domain> <ssh-host> [${GIT_KEYWORD}]\n  yarn addmachine <domain> <machine-id> <ip> [ip...] [${GIT_KEYWORD}]\n\nThe domain is required: a machine has a different identity, and so a different machine id, under\nevery domain it runs under, so there is no such thing as \"this machine\" without one.\n\nWith nothing else it adds this machine, with its own addresses. With an ssh host it asks that\nmachine for its identity under that domain, gives it one if it has none, and adds it under that\naddress. With a machine id it adds exactly that machine at exactly those addresses, without\ntalking to anything.\n\nIt edits the keys repo this machine reads, wherever that is, not whatever directory this was run\nfrom. With ${GIT_KEYWORD} it signs, commits and pushes; without it nothing else will believe any of\nthis until you do.`;\n\nfunction parseArgs(argv: string[]) {\n    let pushToGit = argv.includes(GIT_KEYWORD);\n    let [domain, second, ...rest] = argv.filter(arg => arg !== GIT_KEYWORD);\n    if (!domain) {\n        throw new Error(`Expected a domain\\n${USAGE}`);\n    }\n    if (!second) {\n        return { domain, host: \"\", machineId: \"\", addresses: [] as string[], pushToGit };\n    }\n    if (MACHINE_ID.test(second)) {\n        if (!rest.length) {\n            throw new Error(`Expected at least one address for ${second}, was none\\n${USAGE}`);\n        }\n        return { domain, host: \"\", machineId: second, addresses: rest, pushToGit };\n    }\n    if (rest.length) {\n        throw new Error(\n            `Expected nothing after the ssh host ${second}, was ${rest.join(\" \")}.\\n`\n            + `Addresses are only given alongside a machine id.\\n${USAGE}`\n        );\n    }\n    return { domain, host: second, machineId: \"\", addresses: [] as string[], pushToGit };\n}\n\n/** Which machine to trust, and from which addresses. A named machine and its addresses as given, a\n    machine reached over ssh at the address it was named by, or this machine at its own addresses. */\nasync function resolveMachine(config: { domain: string; host: string; machineId: string; addresses: string[] }) {\n    let { domain, host, machineId, addresses } = config;\n    if (machineId) {\n        return { machineId, addresses };\n    }\n    if (host) {\n        return { machineId: await getOrCreateRemoteMachineId(host, domain), addresses: [host] };\n    }\n    await loadIdentityCA(domain);\n    let ownAddresses = await getOwnIPs();\n    if (!ownAddresses.length) {\n        throw new Error(`Expected this machine to have an address anything else can see, it has none`);\n    }\n    return { machineId: getOwnMachineId(domain), addresses: ownAddresses };\n}\n\nexport async function main() {\n    let { domain, host, machineId, addresses, pushToGit } = parseArgs(process.argv.slice(2));\n    let { repoPath } = await resolveKeysRepo();\n    let target = await resolveMachine({ domain, host, machineId, addresses });\n\n    let machines = await getMachines(repoPath);\n    let existing = machines.find(machine => machine.machineId === target.machineId);\n    let ips = [...(existing?.ips || [])];\n    let added = target.addresses.filter(address => !ips.includes(address));\n    if (existing) {\n        existing.ips = [...ips, ...added];\n    } else {\n        machines.push({ machineId: target.machineId, ips: [...added], addedAt: \"\" });\n    }\n    await setMachines({ repoPath, machines });\n\n    console.log(`\\nTrusting machine ${target.machineId}`);\n    console.log(`Allowing IP ${[...ips, ...added].join(\", \")}`);\n    if (added.length) {\n        console.log(`  added to machines/${target.machineId}.json: ${added.join(\", \")}`);\n    } else {\n        console.log(`  already allowed from ${target.addresses.join(\", \")}`);\n    }\n    console.log(`  in ${repoPath}`);\n\n    if (!pushToGit) {\n        console.log(`\\nNothing believes this until it is signed. In that repo, run:`);\n        console.log(`\\`\\`\\`\\nyarn signfiles ${GIT_KEYWORD}\\n\\`\\`\\``);\n        return;\n    }\n    await signRepo({ repoPath });\n    await runPromise(`git add -A`, { cwd: repoPath });\n    await runPromise(`git commit -m \"${COMMIT_MESSAGE}\"`, { cwd: repoPath });\n    await runPromise(`git push`, { cwd: repoPath });\n    console.log(`\\nSigned, committed and pushed. Machines pick it up as they sync.`);\n}\n"]}
+ /* _JS_SOURCE_HASH = "3d491d73de08b943e4ddc9a408f3a9ba1a1ef135a74d5ad48fbd91667d9b58cf"; */