@swarp/cli 0.0.1-rc.17

package/src/certs/generate.mjs

@@ -0,0 +1,472 @@
+/**
+ * mTLS certificate generation for SWARP.
+ *
+ * Generates a self-signed CA and signs router + agent leaf certs.
+ * Uses node:crypto for key generation and signing — no openssl binary required.
+ * X.509 DER encoding is done in pure JavaScript using ASN.1 primitives.
+ */
+
+import {
+  generateKeyPairSync,
+  createSign,
+  createPrivateKey,
+  createHash,
+  randomBytes,
+  X509Certificate,
+} from 'node:crypto';
+import { writeFileSync, readFileSync, mkdirSync, existsSync, appendFileSync } from 'node:fs';
+import { join, resolve, basename } from 'node:path';
+
+// ---------------------------------------------------------------------------
+// ASN.1 / DER encoder
+// ---------------------------------------------------------------------------
+
+const TAG = {
+  BOOLEAN: 0x01,
+  INTEGER: 0x02,
+  BIT_STRING: 0x03,
+  OCTET_STRING: 0x04,
+  SEQUENCE: 0x30,
+  SET: 0x31,
+  UTF8_STRING: 0x0c,
+  UTC_TIME: 0x17,
+  OID: 0x06,
+};
+
+function derLength(len) {
+  if (len < 0x80) return Buffer.from([len]);
+  if (len <= 0xff) return Buffer.from([0x81, len]);
+  return Buffer.from([0x82, (len >> 8) & 0xff, len & 0xff]);
+}
+
+function tlv(tag, value) {
+  const v = Buffer.isBuffer(value) ? value : Buffer.from(value);
+  return Buffer.concat([Buffer.from([tag]), derLength(v.length), v]);
+}
+
+function sequence(...items) {
+  return tlv(TAG.SEQUENCE, Buffer.concat(items));
+}
+
+function set_(...items) {
+  return tlv(TAG.SET, Buffer.concat(items));
+}
+
+function integerFromBuffer(buf) {
+  const b = Buffer.isBuffer(buf) ? buf : Buffer.from(buf);
+  // Strip leading zeros — DER requires minimal integer encoding
+  let start = 0;
+  while (start < b.length - 1 && b[start] === 0x00) start++;
+  const trimmed = start > 0 ? b.subarray(start) : b;
+  // Add padding zero if high bit set (positive integer must not look negative)
+  const prefixed = trimmed[0] & 0x80 ? Buffer.concat([Buffer.from([0x00]), trimmed]) : trimmed;
+  return tlv(TAG.INTEGER, prefixed);
+}
+
+function integerFromNumber(n) {
+  let hex = BigInt(n).toString(16);
+  if (hex.length % 2 !== 0) hex = '0' + hex;
+  return integerFromBuffer(Buffer.from(hex, 'hex'));
+}
+
+function oid(dotted) {
+  const parts = dotted.split('.').map(Number);
+  const bytes = [40 * parts[0] + parts[1]];
+  for (let i = 2; i < parts.length; i++) {
+    let n = parts[i];
+    const enc = [n & 0x7f];
+    n >>= 7;
+    while (n > 0) {
+      enc.unshift((n & 0x7f) | 0x80);
+      n >>= 7;
+    }
+    bytes.push(...enc);
+  }
+  return tlv(TAG.OID, Buffer.from(bytes));
+}
+
+function utf8String(s) {
+  return tlv(TAG.UTF8_STRING, Buffer.from(s, 'utf8'));
+}
+
+function utcTime(date) {
+  const d = new Date(date);
+  const pad = (n) => String(n).padStart(2, '0');
+  const s =
+    String(d.getUTCFullYear()).slice(-2) +
+    pad(d.getUTCMonth() + 1) +
+    pad(d.getUTCDate()) +
+    pad(d.getUTCHours()) +
+    pad(d.getUTCMinutes()) +
+    pad(d.getUTCSeconds()) +
+    'Z';
+  return tlv(TAG.UTC_TIME, Buffer.from(s, 'ascii'));
+}
+
+function bitString(buf) {
+  return tlv(TAG.BIT_STRING, Buffer.concat([Buffer.from([0x00]), buf]));
+}
+
+function boolean_(val) {
+  return tlv(TAG.BOOLEAN, Buffer.from([val ? 0xff : 0x00]));
+}
+
+function contextExplicit(n, content) {
+  const tag = 0xa0 | n;
+  const v = Buffer.isBuffer(content) ? content : Buffer.from(content);
+  return Buffer.concat([Buffer.from([tag]), derLength(v.length), v]);
+}
+
+function contextImplicit(n, content) {
+  const tag = 0x80 | n;
+  const v = Buffer.isBuffer(content) ? content : Buffer.from(content);
+  return Buffer.concat([Buffer.from([tag]), derLength(v.length), v]);
+}
+
+function octetString(content) {
+  return tlv(TAG.OCTET_STRING, content);
+}
+
+// ---------------------------------------------------------------------------
+// OID constants
+// ---------------------------------------------------------------------------
+
+const OID = {
+  commonName: '2.5.4.3',
+  ecdsaWithSHA256: '1.2.840.10045.4.3.2',
+  basicConstraints: '2.5.29.19',
+  subjectKeyIdentifier: '2.5.29.14',
+  authorityKeyIdentifier: '2.5.29.35',
+  keyUsage: '2.5.29.15',
+};
+
+// ---------------------------------------------------------------------------
+// Name
+// ---------------------------------------------------------------------------
+
+function rdnSequence(cn) {
+  return sequence(
+    set_(
+      sequence(
+        oid(OID.commonName),
+        utf8String(cn),
+      ),
+    ),
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Key identifier
+// ---------------------------------------------------------------------------
+
+function computeKeyId(spkiDer) {
+  return createHash('sha1').update(spkiDer).digest().slice(0, 20);
+}
+
+// ---------------------------------------------------------------------------
+// Extensions
+// ---------------------------------------------------------------------------
+
+function buildExtensions({ isCA, subjectSpki, authoritySpki }) {
+  const exts = [];
+
+  if (isCA) {
+    const bcValue = sequence(boolean_(true));
+    exts.push(
+      sequence(
+        oid(OID.basicConstraints),
+        boolean_(true),
+        octetString(bcValue),
+      ),
+    );
+  }
+
+  const skid = computeKeyId(subjectSpki);
+  exts.push(
+    sequence(
+      oid(OID.subjectKeyIdentifier),
+      octetString(octetString(skid)),
+    ),
+  );
+
+  if (authoritySpki) {
+    const akid = computeKeyId(authoritySpki);
+    const akidContent = sequence(contextImplicit(0, akid));
+    exts.push(
+      sequence(
+        oid(OID.authorityKeyIdentifier),
+        octetString(akidContent),
+      ),
+    );
+  }
+
+  if (!isCA) {
+    // digitalSignature + keyEncipherment
+    exts.push(
+      sequence(
+        oid(OID.keyUsage),
+        boolean_(true),
+        octetString(bitString(Buffer.from([0xa0]))),
+      ),
+    );
+  }
+
+  return sequence(...exts);
+}
+
+// ---------------------------------------------------------------------------
+// TBSCertificate
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {object} opts
+ * @param {Buffer} opts.serial
+ * @param {string} opts.issuerCN
+ * @param {string} opts.subjectCN
+ * @param {Date} opts.notBefore
+ * @param {Date} opts.notAfter
+ * @param {Buffer} opts.subjectSpki - Subject SubjectPublicKeyInfo DER
+ * @param {Buffer|null} opts.authoritySpki - Issuer SubjectPublicKeyInfo DER (null for self-signed)
+ * @param {boolean} opts.isCA
+ */
+function buildTbs(opts) {
+  const { serial, issuerCN, subjectCN, notBefore, notAfter, subjectSpki, authoritySpki, isCA } = opts;
+
+  const version = contextExplicit(0, integerFromNumber(2));
+  const exts = buildExtensions({ isCA, subjectSpki, authoritySpki });
+  const extsWrapped = contextExplicit(3, exts);
+
+  return sequence(
+    version,
+    integerFromBuffer(serial),
+    sequence(oid(OID.ecdsaWithSHA256)),
+    rdnSequence(issuerCN),
+    sequence(utcTime(notBefore), utcTime(notAfter)),
+    rdnSequence(subjectCN),
+    subjectSpki,
+    extsWrapped,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Sign + wrap
+// ---------------------------------------------------------------------------
+
+function signTbs(tbsDer, privateKeyPem) {
+  const key = createPrivateKey({ key: privateKeyPem, format: 'pem', type: 'pkcs8' });
+  const signer = createSign('SHA256');
+  signer.update(tbsDer);
+  const sigDer = signer.sign(key);
+
+  return sequence(
+    tbsDer,
+    sequence(oid(OID.ecdsaWithSHA256)),
+    bitString(sigDer),
+  );
+}
+
+// ---------------------------------------------------------------------------
+// PEM helpers
+// ---------------------------------------------------------------------------
+
+function toPem(label, der) {
+  const b64 = (Buffer.isBuffer(der) ? der : Buffer.from(der)).toString('base64');
+  const lines = b64.match(/.{1,64}/g).join('\n');
+  return `-----BEGIN ${label}-----\n${lines}\n-----END ${label}-----\n`;
+}
+
+// ---------------------------------------------------------------------------
+// Key generation
+// ---------------------------------------------------------------------------
+
+const VALIDITY_DAYS = 365 * 3;
+
+function daysFromNow(days) {
+  return new Date(Date.now() + days * 24 * 60 * 60 * 1000);
+}
+
+function genKeyPair() {
+  const { privateKey: privatePem, publicKey: spkiDer } = generateKeyPairSync('ec', {
+    namedCurve: 'P-256',
+    privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+    publicKeyEncoding: { type: 'spki', format: 'der' },
+  });
+  return { privatePem, spkiDer: Buffer.from(spkiDer) };
+}
+
+function randomSerialBytes() {
+  const b = randomBytes(8);
+  b[0] &= 0x7f;
+  return b;
+}
+
+// ---------------------------------------------------------------------------
+// Certificate builders
+// ---------------------------------------------------------------------------
+
+function buildCaCert(caKey) {
+  const now = new Date();
+  const tbs = buildTbs({
+    serial: randomSerialBytes(),
+    issuerCN: 'swarp-ca',
+    subjectCN: 'swarp-ca',
+    notBefore: now,
+    notAfter: daysFromNow(VALIDITY_DAYS),
+    subjectSpki: caKey.spkiDer,
+    authoritySpki: null,
+    isCA: true,
+  });
+
+  const certDer = signTbs(tbs, caKey.privatePem);
+  return toPem('CERTIFICATE', certDer);
+}
+
+function buildLeafCert(cn, leafKey, caOpts) {
+  const { caCertPem, caKeyPem } = caOpts;
+
+  const caCert = new X509Certificate(caCertPem);
+  const caSpkiDer = Buffer.from(caCert.publicKey.export({ type: 'spki', format: 'der' }));
+
+  const now = new Date();
+  const tbs = buildTbs({
+    serial: randomSerialBytes(),
+    issuerCN: 'swarp-ca',
+    subjectCN: cn,
+    notBefore: now,
+    notAfter: daysFromNow(VALIDITY_DAYS),
+    subjectSpki: leafKey.spkiDer,
+    authoritySpki: caSpkiDer,
+    isCA: false,
+  });
+
+  const certDer = signTbs(tbs, caKeyPem);
+  return toPem('CERTIFICATE', certDer);
+}
+
+// ---------------------------------------------------------------------------
+// .gitignore helper
+// ---------------------------------------------------------------------------
+
+function ensureGitignoreEntry(outDir, fsImpl) {
+  const gitignorePath = resolve('.gitignore');
+  // Normalise to a simple dirname token (e.g. 'certs') so absolute test paths
+  // don't end up written verbatim into .gitignore.
+  const dirName = basename(resolve(outDir));
+  const entry = `${dirName}/`;
+
+  if (!fsImpl.existsSync(gitignorePath)) return;
+
+  const existing = fsImpl.readFileSync(gitignorePath, 'utf8');
+  if (existing.includes(entry)) return;
+
+  fsImpl.appendFileSync(
+    gitignorePath,
+    `\n# SWARP mTLS certificates (never commit private keys)\n${entry}\n`,
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Exported API
+// ---------------------------------------------------------------------------
+
+/**
+ * Generates a full mTLS certificate bundle and writes it to `outDir`.
+ *
+ * Output files:
+ *   ca.crt              — CA certificate (public; safe to commit)
+ *   ca.key              — CA private key  (put in GitHub Secrets; never commit)
+ *   router.crt/.key     — Router mTLS keypair
+ *   agent-example.crt/.key — Sample agent mTLS keypair
+ *
+ * Adds `outDir/` to .gitignore if the file exists and the entry is absent.
+ *
+ * @param {string} [outDir='certs'] - Output directory (created if missing)
+ * @param {object} [opts]
+ * @param {object} [opts.fs] - Filesystem shims for testing
+ */
+export async function generateCerts(outDir = 'certs', { fs: fsOverride } = {}) {
+  const fs = {
+    writeFileSync,
+    mkdirSync,
+    existsSync,
+    appendFileSync,
+    readFileSync,
+    ...fsOverride,
+  };
+  const out = resolve(outDir);
+
+  if (!fs.existsSync(out)) {
+    fs.mkdirSync(out, { recursive: true });
+  }
+
+  const caKey = genKeyPair();
+  const caCertPem = buildCaCert(caKey);
+
+  fs.writeFileSync(join(out, 'ca.crt'), caCertPem, 'utf8');
+  fs.writeFileSync(join(out, 'ca.key'), caKey.privatePem, 'utf8');
+
+  const caOpts = { caCertPem, caKeyPem: caKey.privatePem };
+
+  const routerKey = genKeyPair();
+  const routerCertPem = buildLeafCert('swarp-router', routerKey, caOpts);
+  fs.writeFileSync(join(out, 'router.crt'), routerCertPem, 'utf8');
+  fs.writeFileSync(join(out, 'router.key'), routerKey.privatePem, 'utf8');
+
+  const agentKey = genKeyPair();
+  const agentCertPem = buildLeafCert('example', agentKey, caOpts);
+  fs.writeFileSync(join(out, 'agent-example.crt'), agentCertPem, 'utf8');
+  fs.writeFileSync(join(out, 'agent-example.key'), agentKey.privatePem, 'utf8');
+
+  ensureGitignoreEntry(outDir, fs);
+
+  console.log(`\nCertificates written to ${out}/`);
+  console.log('  ca.crt                      CA certificate (safe to commit)');
+  console.log('  ca.key                      CA private key');
+  console.log('  router.crt / router.key     Router mTLS keypair');
+  console.log('  agent-example.crt / .key    Sample agent mTLS keypair');
+  console.log('\n  Put SWARP_MTLS_CA_KEY in GitHub Secrets. Never commit it.\n');
+}
+
+/**
+ * Rotates the certificate for a named agent using the existing CA.
+ * Reads ca.crt and ca.key from `outDir`, writes new agent-<name>.crt/.key.
+ *
+ * @param {string} name - Agent name used as CN and filename prefix
+ * @param {string} [outDir='certs'] - Directory containing ca.crt and ca.key
+ * @param {object} [opts]
+ * @param {object} [opts.fs] - Filesystem shims for testing
+ */
+export async function rotateCert(name, outDir = 'certs', { fs: fsOverride } = {}) {
+  const fs = {
+    writeFileSync,
+    mkdirSync,
+    existsSync,
+    appendFileSync,
+    readFileSync,
+    ...fsOverride,
+  };
+  const out = resolve(outDir);
+
+  const caKeyPath = join(out, 'ca.key');
+  const caCrtPath = join(out, 'ca.crt');
+
+  if (!fs.existsSync(caKeyPath) || !fs.existsSync(caCrtPath)) {
+    throw new Error(
+      `CA files not found in ${out}/. Run 'swarp certs generate' first.`,
+    );
+  }
+
+  const caKeyPem = fs.readFileSync(caKeyPath, 'utf8');
+  const caCertPem = fs.readFileSync(caCrtPath, 'utf8');
+
+  const leafKey = genKeyPair();
+  const leafCertPem = buildLeafCert(name, leafKey, { caCertPem, caKeyPem });
+
+  fs.writeFileSync(join(out, `agent-${name}.crt`), leafCertPem, 'utf8');
+  fs.writeFileSync(join(out, `agent-${name}.key`), leafKey.privatePem, 'utf8');
+
+  console.log(`\nRotated certificate for agent '${name}':`);
+  console.log(`  agent-${name}.crt`);
+  console.log(`  agent-${name}.key`);
+  console.log(`\n  Update SWARP_AGENT_${name.toUpperCase()}_CERT in GitHub Secrets.\n`);
+}