secure-agents 0.0.0-stage → 0.7.2

package/dist/guard.js

@@ -0,0 +1,98 @@
+// What may leave this computer: files only from the folders (or whole computer) the person allowed, never through symlinks out of them. Secret-looking files need the person's review.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { HOME } from './config.js';
+import { SECRETS as SECRET_PATTERNS } from './scan.js';
+const SENSITIVE_NAMES = [/^\.env(\..*)?$/i, /\.pem$/i, /\.key$/i, /\.p12$/i, /\.pfx$/i, /^id_(rsa|ed25519|ecdsa|dsa)(\.pub)?$/i, /credentials/i, /secret/i, /\.kdbx$/i, /^\.npmrc$/i, /^\.netrc$/i, /^\.pgpass$/i];
+const SENSITIVE_DIRS = new Set(['.ssh', '.aws', '.gnupg', '.kube', '.docker', '.azure', '.config/gcloud']);
+/** Secure's own data (keys, vault, messages) never leaves, whatever the person allowed. */
+const secureHome = () => { try {
+    return fs.realpathSync(HOME);
+}
+catch {
+    return path.resolve(HOME);
+} };
+const isSecureData = (real) => { const h = secureHome(); return real === h || real.startsWith(h + path.sep); };
+/** Resolves a path inside one of the shared folders and checks it; never follows a link outside them. */
+export function checkFile(requested, folders, maxBytes, wholeComputer = false) {
+    const fail = (reason, abs = '') => ({ ok: false, abs, bytes: 0, sha256: '', flags: [], reason });
+    if (!folders.length)
+        return fail('No folders are shared with this agent, and it does not have access to the whole computer.');
+    let inside = false;
+    for (const folder of folders) {
+        const root = fs.realpathSync(folder);
+        const candidate = path.isAbsolute(requested) ? requested : path.join(root, requested);
+        if (path.resolve(candidate).startsWith(root + path.sep))
+            inside = true;
+        let real;
+        try {
+            real = fs.realpathSync(candidate);
+        }
+        catch {
+            continue;
+        }
+        if (real !== root && !real.startsWith(root + path.sep))
+            continue;
+        if (isSecureData(real))
+            return fail("That is Secure's own data (keys and messages); it never leaves this computer.", real);
+        const rel = path.relative(os.homedir(), real).split(path.sep).join('/');
+        const name = path.basename(real);
+        const st = fs.statSync(real);
+        if (!st.isFile())
+            return fail('That path is a folder, not a file.', real);
+        if (st.size > maxBytes)
+            return fail(`The file is ${mb(st.size)}, over this computer's limit of ${mb(maxBytes)}.`, real);
+        const flags = [];
+        if ([...SENSITIVE_DIRS].some((d) => rel === d || rel.startsWith(`${d}/`) || rel.includes(`/${d}/`)))
+            flags.push('is inside a folder that holds keys or logins');
+        if (SENSITIVE_NAMES.some((r) => r.test(name)))
+            flags.push(`"${name}" looks like a secrets file`);
+        const found = scanSecrets(real);
+        if (found.length)
+            flags.push(`contains what looks like a secret (${found.join(', ')})`);
+        return { ok: true, abs: real, bytes: st.size, sha256: hashFile(real), flags };
+    }
+    if (wholeComputer)
+        return fail(`No file at "${requested}" on that computer. Relative paths start at its home folder (~); a full path also works.`);
+    const list = folders.map(tilde).join(', ');
+    return fail(inside ? `No file at "${requested}" in the folders shared with you (${list}). Check the path; it is relative to one of them.` : `"${requested}" is outside the folders shared with you (${list}).`);
+}
+/** Checks a file this agent itself offers; the same rules, without the shared-folder rule. */
+export function checkOwnFile(p, maxBytes) {
+    const abs = path.resolve(p);
+    if (!fs.existsSync(abs))
+        return { ok: false, abs, bytes: 0, sha256: '', flags: [], reason: 'That file does not exist.' };
+    return checkFile(path.basename(abs), [path.dirname(abs)], maxBytes);
+}
+function scanSecrets(p) {
+    const fd = fs.openSync(p, 'r');
+    try {
+        const buf = Buffer.alloc(Math.min(fs.fstatSync(fd).size, 2 * 1024 * 1024));
+        fs.readSync(fd, buf, 0, buf.length, 0);
+        if (buf.includes(0))
+            return [];
+        const text = buf.toString('utf8');
+        return SECRET_PATTERNS.filter(([, r]) => r.test(text)).map(([n]) => n);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export function hashFile(p) {
+    const h = crypto.createHash('sha256');
+    const fd = fs.openSync(p, 'r');
+    try {
+        const buf = Buffer.alloc(1024 * 1024);
+        let n;
+        while ((n = fs.readSync(fd, buf, 0, buf.length, null)) > 0)
+            h.update(buf.subarray(0, n));
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    return h.digest('hex');
+}
+const tilde = (p) => p === os.homedir() || p.startsWith(os.homedir() + path.sep) ? `~${p.slice(os.homedir().length)}` : p;
+export const mb = (n) => `${(n / 1024 / 1024).toFixed(1)} MB`;

package/dist/identity.js

@@ -0,0 +1,38 @@
+// This computer's key pair: its identity on the network. The secret key never leaves the machine and is stored locked by the passphrase.
+import crypto from 'node:crypto';
+import HyperDHT from 'hyperdht';
+import { readSealed, writeSealed } from './vault.js';
+export function loadOrCreateIdentity() {
+    const saved = readSealed('identity.sealed', null);
+    if (saved)
+        return { publicKey: Buffer.from(saved.publicKey, 'hex'), secretKey: Buffer.from(saved.secretKey, 'hex') };
+    return newIdentity();
+}
+/** A fresh key pair: every paired agent sees a new computer and must pair again. */
+export function newIdentity() {
+    const kp = HyperDHT.keyPair();
+    writeSealed('identity.sealed', { publicKey: kp.publicKey.toString('hex'), secretKey: kp.secretKey.toString('hex') });
+    return kp;
+}
+/** Short number both people compare when pairing; the same on both screens only if no one is in the middle. */
+export function safetyNumber(a, b) {
+    const h = crypto.createHash('sha256').update([a, b].sort().join(':')).digest();
+    const digits = Array.from({ length: 4 }, (_, i) => String(h.readUInt32BE(i * 4) % 100000).padStart(5, '0'));
+    return digits.join(' ');
+}
+// Receipts are signed with this computer's Ed25519 key (Hyperswarm keys are Ed25519: 32-byte seed + 32-byte public key).
+const PKCS8 = Buffer.from('302e020100300506032b657004220420', 'hex');
+const SPKI = Buffer.from('302a300506032b6570032100', 'hex');
+export function sign(kp, payload) {
+    const key = crypto.createPrivateKey({ key: Buffer.concat([PKCS8, kp.secretKey.subarray(0, 32)]), format: 'der', type: 'pkcs8' });
+    return crypto.sign(null, Buffer.from(payload), key).toString('hex');
+}
+export function verify(publicKeyHex, payload, signatureHex) {
+    try {
+        const key = crypto.createPublicKey({ key: Buffer.concat([SPKI, Buffer.from(publicKeyHex, 'hex')]), format: 'der', type: 'spki' });
+        return crypto.verify(null, Buffer.from(payload), key, Buffer.from(signatureHex, 'hex'));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/invite.js

@@ -0,0 +1,52 @@
+// Invite codes: the inviter's public key plus a one-time secret, and the relay it uses if it hides its IP; typed or pasted by the other person.
+import crypto from 'node:crypto';
+const PREFIX = 'sec1-';
+const ALPHABET = 'abcdefghijklmnopqrstuvwxyz234567';
+function base32(buf) {
+    let bits = 0, value = 0, out = '';
+    for (const byte of buf) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            out += ALPHABET[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    if (bits > 0)
+        out += ALPHABET[(value << (5 - bits)) & 31];
+    return out;
+}
+function unbase32(s) {
+    let bits = 0, value = 0;
+    const out = [];
+    for (const ch of s) {
+        const v = ALPHABET.indexOf(ch);
+        if (v < 0)
+            throw new Error('This invite code has a typo.');
+        value = (value << 5) | v;
+        bits += 5;
+        if (bits >= 8) {
+            out.push((value >>> (bits - 8)) & 255);
+            bits -= 8;
+        }
+    }
+    return Buffer.from(out);
+}
+export function newSecret() { return crypto.randomBytes(16).toString('hex'); }
+export function encodeInvite(publicKey, secret, relay) {
+    return PREFIX + base32(Buffer.concat([Buffer.from(publicKey, 'hex'), Buffer.from(secret, 'hex'), relay ? Buffer.from(relay, 'hex') : Buffer.alloc(0)]));
+}
+export function decodeInvite(code) {
+    const c = code.trim().toLowerCase().replace(/\s+/g, '');
+    if (!c.startsWith(PREFIX))
+        throw new Error('That is not a Secure invite code (it should start with "sec1-").');
+    const raw = unbase32(c.slice(PREFIX.length));
+    if (raw.length !== 48 && raw.length !== 80)
+        throw new Error('This invite code is incomplete.');
+    return { publicKey: raw.subarray(0, 32).toString('hex'), secret: raw.subarray(32, 48).toString('hex'), relay: raw.length === 80 ? raw.subarray(48).toString('hex') : null };
+}
+/** Constant-time comparison for invite secrets. */
+export function sameSecret(a, b) {
+    const x = Buffer.from(a, 'hex'), y = Buffer.from(b, 'hex');
+    return x.length === y.length && crypto.timingSafeEqual(x, y);
+}