@andrewheberle/serverless-ssh-ca 0.17.13 → 0.17.15

package/src/sshsig/formats.ts

@@ -0,0 +1,226 @@
+import { Reader } from "./reader";
+
+/**
+ * Represents an SSH public key.
+ */
+export type Pubkey = {
+  pk_algo: "ssh-rsa";
+  e: Uint8Array;
+  n: Uint8Array;
+  toString(): string;
+} | {
+  pk_algo: "ssh-ed25519";
+  key: Uint8Array;
+  toString(): string;
+} | {
+  pk_algo:
+    | "ecdsa-sha2-nistp256"
+    | "ecdsa-sha2-nistp384"
+    | "ecdsa-sha2-nistp521";
+  curve: string;
+  point: Uint8Array;
+  toString(): string;
+} | {
+  pk_algo: "sk-ecdsa-sha2-nistp256@openssh.com";
+  curve: string;
+  point: Uint8Array;
+  // typically "ssh:"
+  application: string;
+  toString(): string;
+} | {
+  pk_algo: "sk-ssh-ed25519@openssh.com";
+  key: Uint8Array;
+  // typically "ssh:"
+  application: string;
+  toString(): string;
+};
+
+export function parsePubkey(
+  pk_algo: string,
+  publickey: Reader,
+  raw_publickey: ArrayBuffer,
+): Pubkey {
+  let pubkey: Pubkey;
+  if (pk_algo === "ssh-rsa") {
+    pubkey = {
+      pk_algo,
+      e: new Uint8Array(publickey.readString().bytes()),
+      n: new Uint8Array(publickey.readString().bytes()),
+      toString() {
+        return `${pk_algo} ${base64Encode(new Uint8Array(raw_publickey))}`;
+      },
+    };
+  } else if (pk_algo === "ssh-ed25519") {
+    pubkey = {
+      pk_algo,
+      key: new Uint8Array(publickey.readString().bytes()),
+      toString() {
+        return `${pk_algo} ${base64Encode(new Uint8Array(raw_publickey))}`;
+      },
+    };
+  } else if (pk_algo === "sk-ssh-ed25519@openssh.com") {
+    const key = new Uint8Array(publickey.readString().bytes());
+    const application = publickey.readString().toString();
+    pubkey = {
+      pk_algo,
+      key,
+      application,
+      toString() {
+        return `${pk_algo} ${base64Encode(new Uint8Array(raw_publickey))}`;
+      },
+    };
+  } else if (
+    pk_algo === "ecdsa-sha2-nistp256" || pk_algo === "ecdsa-sha2-nistp384" ||
+    pk_algo === "ecdsa-sha2-nistp521"
+  ) {
+    const curve = publickey.readString().toString();
+    const point = new Uint8Array(publickey.readString().bytes());
+    pubkey = {
+      pk_algo,
+      curve,
+      point,
+      toString() {
+        return `${pk_algo} ${base64Encode(new Uint8Array(raw_publickey))}`;
+      },
+    };
+  } else if (pk_algo === "sk-ecdsa-sha2-nistp256@openssh.com") {
+    const curve = publickey.readString().toString();
+    const point = new Uint8Array(publickey.readString().bytes());
+    const application = publickey.readString().toString();
+    pubkey = {
+      pk_algo,
+      curve,
+      point,
+      application,
+      toString() {
+        return `${pk_algo} ${base64Encode(new Uint8Array(raw_publickey))}`;
+      },
+    };
+  } else {
+    throw new Error(`Unsupported pk_algo: ${pk_algo}`);
+  }
+  return pubkey;
+}
+
+function base64Encode(bytes: Uint8Array) {
+  return btoa(String.fromCharCode.apply(null, bytes as unknown as number[]));
+}
+
+function base64UrlEncode(bytes: Uint8Array) {
+  return base64Encode(bytes)
+    .replace(
+      /\+/g,
+      "-",
+    )
+    .replace(/\//g, "_")
+    .replace(/=/g, "");
+}
+
+export function convertPublicKey(publickey: Pubkey): {
+  format: "jwk";
+  keyData: JsonWebKey;
+} | { format: "raw"; keyData: ArrayBuffer } {
+  const pk_algo = publickey.pk_algo;
+  if (pk_algo === "ssh-rsa") {
+    return {
+      keyData: {
+        kty: "RSA",
+        e: base64UrlEncode(publickey.e),
+        n: base64UrlEncode(publickey.n),
+      },
+      format: "jwk",
+    };
+  } else if (
+    pk_algo === "ssh-ed25519" || pk_algo === "sk-ssh-ed25519@openssh.com"
+  ) {
+    return {
+      keyData: publickey.key.buffer.slice(
+        publickey.key.byteOffset,
+        publickey.key.byteOffset + publickey.key.byteLength
+      ) as ArrayBuffer,
+      format: "raw",
+    };
+  } else if (
+    pk_algo === "ecdsa-sha2-nistp256" || pk_algo === "ecdsa-sha2-nistp384" ||
+    pk_algo === "ecdsa-sha2-nistp521" ||
+    pk_algo === "sk-ecdsa-sha2-nistp256@openssh.com"
+  ) {
+    if (publickey.point[0] !== 0x04) {
+      throw new Error("Only uncompressed (0x04) format is supported");
+    }
+
+    const point = publickey.point.slice(1);
+
+    let crv;
+    if (
+      pk_algo === "ecdsa-sha2-nistp256" ||
+      pk_algo === "sk-ecdsa-sha2-nistp256@openssh.com"
+    ) {
+      crv = "P-256";
+    } else if (pk_algo === "ecdsa-sha2-nistp384") {
+      crv = "P-384";
+    } else {
+      crv = "P-521";
+    }
+    return {
+      keyData: {
+        kty: "EC",
+        crv,
+        x: base64UrlEncode(point.slice(0, point.length / 2)),
+        y: base64UrlEncode(point.slice(point.length / 2)),
+      },
+      format: "jwk",
+    };
+  } else {
+    throw new Error(`Unsupported algo: ${pk_algo}`);
+  }
+}
+
+export function convertAlgorithm(sig_algo: string) {
+  if (sig_algo === "rsa-sha2-512") {
+    return {
+      name: "RSASSA-PKCS1-v1_5",
+      hash: { name: "SHA-512" },
+    };
+  } else if (
+    sig_algo === "ssh-ed25519" || sig_algo === "sk-ssh-ed25519@openssh.com"
+  ) {
+    return {
+      name: "Ed25519",
+      hash: { name: "SHA-512" },
+    };
+  } else if (
+    sig_algo === "ecdsa-sha2-nistp256" ||
+    sig_algo === "sk-ecdsa-sha2-nistp256@openssh.com"
+  ) {
+    return {
+      name: "ECDSA",
+      namedCurve: "P-256",
+      hash: { name: "SHA-256" },
+    };
+  } else if (sig_algo === "ecdsa-sha2-nistp384") {
+    return {
+      name: "ECDSA",
+      namedCurve: "P-384",
+      hash: { name: "SHA-384" },
+    };
+  } else if (sig_algo === "ecdsa-sha2-nistp521") {
+    return {
+      name: "ECDSA",
+      namedCurve: "P-521",
+      hash: { name: "SHA-512" },
+    };
+  } else {
+    throw new Error(`Unsupported algo: ${sig_algo}`);
+  }
+}
+
+export function convertHash(hashName: string): string {
+  if (hashName === "sha256") {
+    return "SHA-256";
+  } else if (hashName === "sha512") {
+    return "SHA-512";
+  } else {
+    throw new Error(`Unknown hash: ${hashName}`);
+  }
+}

package/src/sshsig/index.ts

@@ -0,0 +1,47 @@
+import { Sig } from "./sig";
+import { verify as rawVerify } from "./verifier";
+import { parse } from "./sig_parser";
+
+/**
+ * Verifies SSH signature against provided data.
+ *
+ * Returns `true` if the `signature` is a valid signature over `signed_data`, `false` otherwise.
+ *
+ * @param {Sig | string} signature SSH signature.
+ * @param {Uint8Array | string} signed_data Data that has been signed.
+ * @param {object} options Pass-in subtle crypto if required or a specific namespace.
+ * @returns {Promise<boolean>} Resolves to true if the signature is valid, to false otherwise.
+ */
+export async function verify(
+  signature: Sig | string,
+  signed_data: Uint8Array | string,
+  options?: {
+    subtle?: SubtleCrypto;
+		namespace?: string;
+  },
+): Promise<boolean> {
+  if (typeof options === "undefined") {
+    options = {};
+  }
+  const subtle = options.subtle || crypto.subtle;
+  if (typeof signature === "string") {
+    signature = parse(signature);
+  }
+
+	// check namespace matches if provided in options, otherwise default to
+	// signature's namespace. Reject if they don't match.
+	const namespace = options.namespace || signature.namespace;
+	if (namespace !== signature.namespace) {
+		return false;
+	}
+
+  if (typeof signed_data === "string") {
+    signed_data = new TextEncoder().encode(signed_data);
+  } else {
+    signed_data = new Uint8Array(signed_data.buffer.slice(
+      signed_data.byteOffset,
+      signed_data.byteOffset + signed_data.byteLength
+    ) as ArrayBuffer)
+  }
+  return await rawVerify(subtle, signature, signed_data as Uint8Array<ArrayBuffer>);
+}

package/src/sshsig/reader.ts

@@ -0,0 +1,59 @@
+/**
+ * Byte stream reader helper.
+ *
+ * This class exposes several helper functions for reading SSH structured data.
+ */
+export class Reader {
+	private pos = 0;
+	constructor(private view: DataView) {
+		this.view = view;
+	}
+	readUint8() {
+		return this.view.getUint8(this.pos++);
+	}
+	readUint32() {
+		const v = this.peekUint32();
+		this.pos += 4;
+		return v;
+	}
+	peekUint32() {
+		return this.view.getUint32(this.pos);
+	}
+	peekBytes(pos: number, num: number) {
+		const dv = new DataView(
+			this.view.buffer,
+			pos + this.view.byteOffset,
+			num,
+		);
+		return new Reader(dv);
+	}
+	readBytes(num: number) {
+		const reader = this.peekBytes(this.pos, num);
+		this.pos += num;
+		return reader;
+	}
+	readString() {
+		const len = this.readUint32();
+		return this.readBytes(len);
+	}
+	peekString() {
+		const len = this.peekUint32();
+		return this.peekBytes(this.pos + 4, len);
+	}
+	toString() {
+		let s = "";
+		for (let i = 0; i < this.view.byteLength; i++) {
+			s += String.fromCharCode(this.view.getUint8(i));
+		}
+		return s;
+	}
+	bytes(): ArrayBuffer {
+		return (this.view.buffer as ArrayBuffer).slice(
+			this.view.byteOffset + this.pos,
+			this.view.byteOffset + this.view.byteLength,
+		);
+	}
+	get isAtEnd() {
+		return this.pos == this.view.byteLength;
+	}
+}

package/src/sshsig/sig.ts

@@ -0,0 +1,17 @@
+import { Pubkey } from "./formats";
+
+/**
+ * Represents a parsed SSH signature.
+ */
+export interface Sig {
+  publickey: Pubkey;
+  namespace: string;
+  reserved: ArrayBuffer;
+  hash_algorithm: string;
+  signature: {
+    sig_algo: string;
+    raw_signature: ArrayBuffer;
+    flags?: number;
+    counter?: number;
+  };
+}

package/src/sshsig/sig_parser.ts

@@ -0,0 +1,90 @@
+import { Sig } from "./sig";
+import { Reader } from "./reader";
+import { parsePubkey } from "./formats";
+import { dearmor } from "./armor";
+
+/**
+ * Parse bytes into an SSH signature object.
+ *
+ * This function throws an Error when the signature is invalid or unsupported.
+ *
+ * @param {DataView | string} signature Raw bytes to parse.
+ */
+export function parse(signature: DataView | string): Sig {
+  let view;
+  if (typeof signature === "string") {
+    const bytes = dearmor(signature);
+    view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+  } else {
+    view = signature;
+  }
+  const reader = new Reader(view);
+
+  const magic = reader.readBytes(6).toString();
+  if (magic !== "SSHSIG") {
+    throw new Error("Expected SSHSIG magic value but got unexpected bytes");
+  }
+  const version = reader.readUint32();
+  if (version !== 1) {
+    throw new Error("Expected version 1 but got unexpected version");
+  }
+  const raw_publickey = reader.peekString().bytes();
+  const publickey = reader.readString();
+  const pk_algo = publickey.readString().toString();
+  const pubkey = parsePubkey(pk_algo, publickey, raw_publickey);
+  const namespace = reader.readString().toString();
+  const reserved = reader.readString().bytes();
+  const hash_algorithm = reader.readString().toString();
+  const raw_signature = reader.readString();
+  const sig_algo = raw_signature.readString().toString();
+  const sig_bytes = raw_signature.readString();
+  let bytes;
+  if (
+    sig_algo === "ecdsa-sha2-nistp256" || sig_algo === "ecdsa-sha2-nistp384" ||
+    sig_algo === "ecdsa-sha2-nistp512" ||
+    sig_algo === "sk-ecdsa-sha2-nistp256@openssh.com"
+  ) {
+    let r = new Uint8Array(sig_bytes.readString().bytes());
+	  if (r.length === 0) {
+      throw new Error("invalid ECDSA signature component")
+    }
+    if (r[0] === 0x00 && r.length % 2 == 1) {
+      r = r.slice(1);
+    }
+    let s = new Uint8Array(sig_bytes.readString().bytes());
+		if (s.length === 0) {
+      throw new Error("invalid ECDSA signature component")
+    }
+    if (s[0] === 0x00 && s.length % 2 == 1) {
+      s = s.slice(1);
+    }
+    bytes = new Uint8Array([...r, ...s]).buffer as ArrayBuffer;
+  } else {
+    bytes = sig_bytes.bytes();
+  }
+  let flags, counter;
+  if (
+    sig_algo === "sk-ecdsa-sha2-nistp256@openssh.com" ||
+    sig_algo == "sk-ssh-ed25519@openssh.com"
+  ) {
+    flags = new Uint8Array(raw_signature.readBytes(1).bytes())[0];
+    counter = raw_signature.readUint32();
+  }
+  if (!reader.isAtEnd) {
+    throw new Error(
+      "Signature was parsed but there were still bytes in the stream.",
+    );
+  }
+  return {
+    publickey: pubkey,
+    namespace,
+    reserved,
+    hash_algorithm,
+    signature: {
+      sig_algo,
+      raw_signature: bytes,
+      flags,
+      counter,
+    },
+  };
+}

package/src/sshsig/verifier.ts

@@ -0,0 +1,85 @@
+import { Sig } from "./sig";
+import { convertAlgorithm, convertHash, convertPublicKey } from "./formats";
+import { Writer } from "./writer";
+
+export async function verify(
+  subtle: SubtleCrypto,
+  signature: Sig,
+  signed_data: Uint8Array<ArrayBuffer>,
+) {
+  //https://nodejs.org/api/webcrypto.html#subtleimportkeyformat-keydata-algorithm-extractable-keyusages
+  // for 'RSASSA-PKCS1-v1_5' only spki, pkcs8 and jwk are supported
+  // https://stackoverflow.com/questions/46232571/webcrypto-importing-rsa-public-key-with-modulus-and-exponent-using-crypto-subtl
+  const { keyData, format } = convertPublicKey(signature.publickey);
+  const algorithm = convertAlgorithm(signature.signature.sig_algo);
+  const key = await subtle.importKey(
+    format as unknown as "raw",
+    keyData as unknown as BufferSource,
+    algorithm,
+    false,
+    [
+      "verify",
+    ],
+  );
+
+  const writer = new Writer(96 + signature.namespace.length);
+  // https://github.com/openssh/openssh-portable/blob/d575cf44895104e0fcb0629920fb645207218129/PROTOCOL.sshsig
+  // MAGIC_PREAMBLE
+  writer.writeBytes("SSHSIG");
+  // namespace
+  writer.writeString(signature.namespace);
+  // reserved
+  writer.writeUint32(0);
+  // hash_algorithm
+  const hash = signature.hash_algorithm;
+  writer.writeString(hash);
+  const digest = new Uint8Array(
+    await subtle.digest(
+      convertHash(hash),
+      signed_data,
+    ),
+  );
+  writer.writeString(digest);
+
+  const data = writer.bytes();
+
+  if (
+    signature.publickey.pk_algo === "sk-ecdsa-sha2-nistp256@openssh.com" ||
+    signature.publickey.pk_algo === "sk-ssh-ed25519@openssh.com"
+  ) {
+    // https://fuchsia.googlesource.com/third_party/openssh-portable/+/refs/heads/main/PROTOCOL.u2f#176
+    const u2f_data = new Writer(100);
+    u2f_data.writeBytes(
+      await subtle.digest(
+        "SHA-256",
+        Uint8Array.from(
+          Array.prototype.map.call(
+            signature.publickey.application,
+            (x) => x.charCodeAt(0),
+          ) as unknown as number[],
+        ),
+      ),
+    );
+    u2f_data.writeByte(signature.signature.flags || 0);
+    u2f_data.writeUint32(signature.signature.counter || 0);
+    u2f_data.writeBytes(
+      await subtle.digest(
+        "SHA-256",
+        data,
+      ),
+    );
+    return await subtle.verify(
+      algorithm,
+      key,
+      signature.signature.raw_signature,
+      u2f_data.bytes(),
+    );
+  }
+
+  return await subtle.verify(
+    algorithm,
+    key,
+    signature.signature.raw_signature,
+    data,
+  );
+}

package/src/sshsig/writer.ts

@@ -0,0 +1,56 @@
+/**
+ * Byte stream writer helper.
+ *
+ * This class exposes several helper functions for writing bytes into a buffer.
+ */
+export class Writer {
+  private pos = 0;
+  private buffer: ArrayBuffer;
+  private view: DataView;
+  constructor(maxByteLength: number) {
+    this.buffer = new (ArrayBuffer as unknown as {
+      new (a: number, b: { maxByteLength: number }): ArrayBuffer;
+    })(0, { maxByteLength });
+    this.view = new DataView(this.buffer);
+  }
+  private addResize(num: number) {
+    (this.buffer as unknown as { resize(num: number): void }).resize(
+      this.buffer.byteLength + num,
+    );
+  }
+  writeUint32(num: number) {
+    this.addResize(4);
+    this.view.setUint32(this.pos, num);
+    this.pos += 4;
+  }
+  writeString(bytes: ArrayLike<number> | string) {
+    this.writeUint32(bytes.length);
+    this.writeBytes(bytes);
+  }
+  writeBytes(bytes: ArrayLike<number> | string | ArrayBuffer) {
+    let uint8bytes;
+    if (typeof bytes === "string") {
+      uint8bytes = Array.prototype.map.call(
+        bytes,
+        (x) => x.charCodeAt(0),
+      ) as number[];
+    } else if (bytes instanceof ArrayBuffer) {
+      uint8bytes = new Uint8Array(bytes);
+    } else {
+      uint8bytes = bytes;
+    }
+    // it's more efficient to resize once and write all bytes
+    // instead of calling `writeByte` in each iteration
+    this.addResize(uint8bytes.length);
+    for (let i = 0; i < uint8bytes.length; i++) {
+      this.view.setUint8(this.pos++, uint8bytes[i]!);
+    }
+  }
+  writeByte(byte: number) {
+    this.addResize(1);
+    this.view.setUint8(this.pos++, byte);
+  }
+  bytes() {
+    return new Uint8Array(this.buffer);
+  }
+}

package/src/types.ts

@@ -0,0 +1,49 @@
+import { JWTPayload } from "jose"
+
+// this is the JSON payload of a certificate request
+export type CertificateSignerPayload = {
+    public_key: string
+    identity: string
+    extensions?: string[]
+	lifetime?: number
+    nonce?: string
+}
+
+export type CertificateSignerResponse = {
+    certificate: string
+}
+
+// this is the expected JWT payload for a certificate request
+export type CertificateRequestJWTPayload = {
+    email: string
+    sub: string
+    [key: string]: string | string[]
+} & JWTPayload
+
+export type SSHExtension = {
+    critical: boolean;
+    name: string;
+    data: Buffer<ArrayBuffer>
+}
+
+export interface SshCaBindings {
+    DB: D1Database
+    DB_CERTIFICATE_RETENTION: string
+    PRIVATE_KEY: SecretsStoreSecret
+    SSH_CERTIFICATE_EXTENSIONS: string
+    SSH_CERTIFICATE_LIFETIME: string
+    SSH_CERTIFICATE_INCLUDE_SELF: string
+    SSH_CERTIFICATE_PRINCIPALS: string
+    SSH_HOST_CERTIFICATE_LIFETIME: string
+    SSH_HOST_CERTIFICATE_ALLOWED_EMAILS: string
+    SSH_HOST_CERTIFICATE_ALLOWED_ROLES: string
+    ISSUER_DN: string
+	JWT_JWKS_URL: string
+	JWT_AUD: string
+	JWT_ISSUER: string
+	JWT_ALGORITHMS: string
+	JWT_SSH_CERTIFICATE_PRINCIPALS_CLAIM: string
+	SSH_HOST_CERTIFICATE_ALLOWED_ROLES_CLAIM: string
+	CERTIFICATE_REQUEST_TIME_SKEW_MAX: string
+	LOG_LEVEL: string
+}