@noz-ele/edgca 0.1.0

package/dist/parser.js

@@ -0,0 +1,146 @@
+import { bytesEqual } from "./bytes.js";
+import { decodeInteger, decodeOid, readChildren, readElement, readSequenceChildren, TAG } from "./der.js";
+import { importPublicKeySpki } from "./crypto.js";
+import { OID } from "./oids.js";
+export async function parseCertificateDer(der) {
+    const certificate = readElement(der);
+    if (certificate.tag !== TAG.SEQUENCE || certificate.end !== der.length) {
+        throw new Error("Invalid certificate DER");
+    }
+    const [tbsCertificate, signatureAlgorithm, signatureValue] = readSequenceChildren(certificate);
+    if (!tbsCertificate || !signatureAlgorithm || !signatureValue) {
+        throw new Error("Invalid certificate structure");
+    }
+    if (signatureValue.tag !== TAG.BIT_STRING || signatureValue.value[0] !== 0) {
+        throw new Error("Invalid certificate signature value");
+    }
+    const tbsChildren = readSequenceChildren(tbsCertificate);
+    // RFC 5280 §4.1.2.1: version is [0] EXPLICIT INTEGER. EdgCA only emits and
+    // accepts v3 (= INTEGER 2); v1 (field omitted) and v2 (INTEGER 1) are rejected.
+    // See docs/NON_GOALS.md §4.
+    const versionTag = tbsChildren[0];
+    if (!versionTag || versionTag.tag !== 0xa0) {
+        throw new Error("Unsupported X.509 version (only v3 is supported)");
+    }
+    const versionInner = readElement(versionTag.value);
+    if (versionInner.tag !== TAG.INTEGER || decodeInteger(versionInner.value) !== 2n) {
+        throw new Error("Unsupported X.509 version (only v3 is supported)");
+    }
+    let index = 1;
+    index += 1; // serialNumber
+    index += 1; // signature
+    const issuer = tbsChildren[index++];
+    index += 1; // validity
+    const subject = tbsChildren[index++];
+    const subjectPublicKeyInfo = tbsChildren[index++];
+    if (!issuer || !subject || !subjectPublicKeyInfo) {
+        throw new Error("Invalid certificate TBSCertificate structure");
+    }
+    const extensions = tbsChildren.find((element) => element.tag === 0xa3);
+    const parsedExtensions = extensions ? parseExtensions(extensions.value) : {};
+    const publicKey = await importPublicKeySpki(subjectPublicKeyInfo.raw);
+    const parsed = {
+        der,
+        tbsCertificateDer: tbsCertificate.raw,
+        signatureDer: signatureValue.value.subarray(1),
+        issuerNameDer: issuer.raw,
+        subjectNameDer: subject.raw,
+        subjectPublicKeyInfoDer: subjectPublicKeyInfo.raw,
+        publicKey,
+        isCA: parsedExtensions.isCA ?? false,
+        keyCertSign: parsedExtensions.keyCertSign ?? false
+    };
+    if (parsedExtensions.pathLenConstraint !== undefined) {
+        parsed.pathLenConstraint = parsedExtensions.pathLenConstraint;
+    }
+    if (parsedExtensions.subjectKeyIdentifier !== undefined) {
+        parsed.subjectKeyIdentifier = parsedExtensions.subjectKeyIdentifier;
+    }
+    if (parsedExtensions.authorityKeyIdentifier !== undefined) {
+        parsed.authorityKeyIdentifier = parsedExtensions.authorityKeyIdentifier;
+    }
+    return parsed;
+}
+export function assertIssuerSubjectMatches(issuer, issued) {
+    if (!bytesEqual(issuer.subjectNameDer, issued.issuerNameDer)) {
+        throw new Error("Issued certificate issuer does not match CA subject");
+    }
+}
+function parseExtensions(explicitValue) {
+    const outer = readElement(explicitValue);
+    if (outer.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid extensions structure");
+    }
+    const parsed = {};
+    for (const extension of readSequenceChildren(outer)) {
+        const children = readSequenceChildren(extension);
+        const oidElement = children[0];
+        if (!oidElement || oidElement.tag !== TAG.OBJECT_IDENTIFIER) {
+            throw new Error("Invalid extension OID");
+        }
+        let valueIndex = 1;
+        if (children[valueIndex]?.tag === TAG.BOOLEAN) {
+            valueIndex += 1;
+        }
+        const value = children[valueIndex];
+        if (!value || value.tag !== TAG.OCTET_STRING) {
+            throw new Error("Invalid extension value");
+        }
+        const extensionOid = decodeOid(oidElement.value);
+        if (extensionOid === OID.basicConstraints) {
+            Object.assign(parsed, parseBasicConstraints(value.value));
+        }
+        else if (extensionOid === OID.keyUsage) {
+            parsed.keyCertSign = parseKeyUsage(value.value).keyCertSign;
+        }
+        else if (extensionOid === OID.subjectKeyIdentifier) {
+            parsed.subjectKeyIdentifier = parseOctetString(value.value);
+        }
+        else if (extensionOid === OID.authorityKeyIdentifier) {
+            const keyIdentifier = parseAuthorityKeyIdentifier(value.value);
+            if (keyIdentifier !== undefined) {
+                parsed.authorityKeyIdentifier = keyIdentifier;
+            }
+        }
+    }
+    return parsed;
+}
+function parseBasicConstraints(value) {
+    const root = readElement(value);
+    const children = readSequenceChildren(root);
+    const result = { isCA: false };
+    if (children[0]?.tag === TAG.BOOLEAN) {
+        result.isCA = children[0].value[0] !== 0;
+    }
+    const pathLen = children.find((child) => child.tag === TAG.INTEGER);
+    if (pathLen) {
+        result.pathLenConstraint = Number(decodeInteger(pathLen.value));
+    }
+    return result;
+}
+function parseKeyUsage(value) {
+    const root = readElement(value);
+    if (root.tag !== TAG.BIT_STRING || root.value.length < 2) {
+        throw new Error("Invalid keyUsage extension");
+    }
+    const bytes = root.value.subarray(1);
+    return {
+        keyCertSign: (bytes[0] & 0x04) !== 0
+    };
+}
+function parseOctetString(value) {
+    const root = readElement(value);
+    if (root.tag !== TAG.OCTET_STRING) {
+        throw new Error("Invalid OCTET STRING extension payload");
+    }
+    return root.value;
+}
+function parseAuthorityKeyIdentifier(value) {
+    const root = readElement(value);
+    for (const child of readSequenceChildren(root)) {
+        if (child.tag === 0x80) {
+            return child.value;
+        }
+    }
+    return undefined;
+}

package/dist/pem.d.ts

@@ -0,0 +1,7 @@
+export declare function certificateToPem(der: Uint8Array): string;
+export declare function privateKeyDerToPem(der: Uint8Array): string;
+export declare function publicKeyDerToPem(der: Uint8Array): string;
+export declare function pemToDer(pem: string): Uint8Array;
+export declare function pemToDerWithLabel(pem: string, label: string): Uint8Array;
+export declare function splitPemBlocks(pem: string): string[];
+//# sourceMappingURL=pem.d.ts.map

package/dist/pem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pem.d.ts","sourceRoot":"","sources":["../src/pem.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAExD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAE1D;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAEzD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAWhD;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAaxE;AAED,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAUpD"}

package/dist/pem.js

@@ -0,0 +1,52 @@
+import { binaryToBytes, bytesToBinary } from "./bytes.js";
+const PEM_LINE_LENGTH = 64;
+export function certificateToPem(der) {
+    return encodePem("CERTIFICATE", der);
+}
+export function privateKeyDerToPem(der) {
+    return encodePem("PRIVATE KEY", der);
+}
+export function publicKeyDerToPem(der) {
+    return encodePem("PUBLIC KEY", der);
+}
+export function pemToDer(pem) {
+    const match = /-----BEGIN (.+?)-----([\s\S]*?)-----END \1-----/.exec(pem);
+    if (!match || !match[2]) {
+        throw new Error("Invalid PEM block");
+    }
+    const base64 = match[2].replace(/\s+/g, "");
+    if (base64.length === 0) {
+        throw new Error("Invalid PEM block: empty body");
+    }
+    return binaryToBytes(atob(base64));
+}
+export function pemToDerWithLabel(pem, label) {
+    const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`-----BEGIN ${escaped}-----([\\s\\S]*?)-----END ${escaped}-----`);
+    const match = pattern.exec(pem);
+    if (!match?.[1]) {
+        throw new Error(`Invalid PEM block: expected ${label}`);
+    }
+    const base64 = match[1].replace(/\s+/g, "");
+    if (base64.length === 0) {
+        throw new Error(`Invalid PEM block: empty ${label} body`);
+    }
+    return binaryToBytes(atob(base64));
+}
+export function splitPemBlocks(pem) {
+    const blocks = [];
+    const pattern = /-----BEGIN (.+?)-----[\s\S]*?-----END \1-----/g;
+    let match;
+    while ((match = pattern.exec(pem)) !== null) {
+        blocks.push(match[0]);
+    }
+    return blocks;
+}
+function encodePem(label, der) {
+    const base64 = btoa(bytesToBinary(der));
+    const lines = [];
+    for (let i = 0; i < base64.length; i += PEM_LINE_LENGTH) {
+        lines.push(base64.slice(i, i + PEM_LINE_LENGTH));
+    }
+    return `-----BEGIN ${label}-----\n${lines.join("\n")}\n-----END ${label}-----\n`;
+}

package/dist/types.d.ts

@@ -0,0 +1,59 @@
+export type ShortSubjectAttributeType = "CN" | "O" | "OU" | "C" | "ST" | "L" | "E" | "DC" | "SERIALNUMBER" | "STREET" | "POSTALCODE" | "TITLE" | "GIVENNAME" | "SURNAME" | "UID";
+export type DottedOid = `${number}.${number}${string}`;
+export type SubjectAttributeType = ShortSubjectAttributeType | DottedOid;
+export interface SubjectAttribute {
+    type: SubjectAttributeType;
+    value: string;
+}
+export type Subject = SubjectAttribute[];
+export type SerialNumber = bigint | number | string | Uint8Array;
+export interface CertificateAuthority {
+    certPem: string;
+    privateKeyPem: string;
+    publicKeyPem: string;
+    certDer: Uint8Array;
+    privateKey: CryptoKey;
+    publicKey: CryptoKey;
+    issuerChainPem: string;
+}
+export interface IssuedClientCertificate {
+    certPem: string;
+    privateKeyPem: string;
+    publicKeyPem: string;
+    certDer: Uint8Array;
+    privateKey: CryptoKey;
+    publicKey: CryptoKey;
+    certChainPem: string;
+}
+export interface CreateRootCAOptions {
+    subject: Subject;
+    days: number;
+    notBefore?: Date;
+    serialNumber?: SerialNumber;
+    pathLenConstraint?: number;
+    privateKeyPem?: string;
+}
+export interface IssueIntermediateCAOptions {
+    ca: CertificateAuthority;
+    subject: Subject;
+    days: number;
+    notBefore?: Date;
+    serialNumber?: SerialNumber;
+    pathLenConstraint?: number;
+    privateKeyPem?: string;
+}
+export interface IssueClientCertOptions {
+    ca: CertificateAuthority;
+    subject: Subject;
+    days: number;
+    notBefore?: Date;
+    serialNumber?: SerialNumber;
+    dnsNames?: string[];
+    ipAddresses?: string[];
+}
+export interface ImportCertificateAuthorityOptions {
+    certPem: string;
+    privateKeyPem: string;
+    issuerChainPem?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GACjC,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,IAAI,GACJ,GAAG,GACH,GAAG,GACH,IAAI,GACJ,cAAc,GACd,QAAQ,GACR,YAAY,GACZ,OAAO,GACP,WAAW,GACX,SAAS,GACT,KAAK,CAAC;AAEV,MAAM,MAAM,SAAS,GAAG,GAAG,MAAM,IAAI,MAAM,GAAG,MAAM,EAAE,CAAC;AAEvD,MAAM,MAAM,oBAAoB,GAAG,yBAAyB,GAAG,SAAS,CAAC;AAEzE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,oBAAoB,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,OAAO,GAAG,gBAAgB,EAAE,CAAC;AAEzC,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,CAAC;AAEjE,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,UAAU,CAAC;IACpB,UAAU,EAAE,SAAS,CAAC;IACtB,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,UAAU,CAAC;IACpB,UAAU,EAAE,SAAS,CAAC;IACtB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,oBAAoB,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,oBAAoB,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,iCAAiC;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/verify.d.ts

@@ -0,0 +1,46 @@
+import type { CertificateAuthority } from "./types.js";
+export interface VerifyClientCertificateValidity {
+    notBefore: Date | number;
+    notAfter: Date | number;
+    now?: Date | number;
+}
+export interface VerifyClientCertificateIssuedByOptions {
+    ca: CertificateAuthority;
+    certPem: string;
+    validity?: VerifyClientCertificateValidity;
+}
+/**
+ * Confirms that `options.certPem` was issued by `options.ca`.
+ *
+ * This is **not** mTLS verification, and does not even attempt to be.
+ * At most it is *issuance verification*: "the presented certificate was
+ * issued by the specified CA" — which is **not** the same as authenticating
+ * that the presenter is the certificate's legitimate owner.
+ *
+ * A client certificate is, by design, presentable to anyone, and its
+ * contents are trivially copyable. You must assume that anyone could be
+ * holding a valid copy. Therefore possession of valid certificate data
+ * **never** proves legitimate ownership.
+ *
+ * Proving legitimate ownership additionally requires verifying possession
+ * of the corresponding private key (a signature made by it, verified
+ * against the certificate's public key). The TLS handshake's
+ * `CertificateVerify` message normally provides this, but the Cloudflare
+ * Workers runtime does not expose that signature to the application. On
+ * non-Enterprise plans, Cloudflare's TLS layer also does not know about
+ * your self-managed CA, so `request.cf.tlsClientAuth.certVerified` will
+ * not be `"SUCCESS"` for certificates EdgCA issued. Application code on
+ * Workers (Enterprise excluded) has no way to verify proof-of-possession.
+ *
+ * Implication: anyone who has obtained a copy of a valid certificate
+ * (logs, leaked storage, network capture, etc.) can present it and pass
+ * this check. Use this as a minimum identity-check layer, not as
+ * authentication. For real authentication, use Cloudflare Enterprise mTLS
+ * at the TLS layer, or add an application-layer challenge-response that
+ * has the client sign a server-issued nonce with its private key.
+ *
+ * Also out of scope (not checked here): `BasicConstraints CA=false`,
+ * `EKU clientAuth`, revocation, and chain walking.
+ */
+export declare function verifyClientCertificateIssuedBy(options: VerifyClientCertificateIssuedByOptions): Promise<boolean>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../src/verify.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,MAAM,WAAW,+BAA+B;IAC9C,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;IACzB,QAAQ,EAAE,IAAI,GAAG,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,sCAAsC;IACrD,EAAE,EAAE,oBAAoB,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,+BAA+B,CAAC;CAC5C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,sCAAsC,GAC9C,OAAO,CAAC,OAAO,CAAC,CAwBlB"}

package/dist/verify.js

@@ -0,0 +1,73 @@
+import { bytesEqual } from "./bytes.js";
+import { keyIdentifierFromSpki, verifyDer } from "./crypto.js";
+import { pemToDerWithLabel } from "./pem.js";
+import { parseCertificateDer } from "./parser.js";
+/**
+ * Confirms that `options.certPem` was issued by `options.ca`.
+ *
+ * This is **not** mTLS verification, and does not even attempt to be.
+ * At most it is *issuance verification*: "the presented certificate was
+ * issued by the specified CA" — which is **not** the same as authenticating
+ * that the presenter is the certificate's legitimate owner.
+ *
+ * A client certificate is, by design, presentable to anyone, and its
+ * contents are trivially copyable. You must assume that anyone could be
+ * holding a valid copy. Therefore possession of valid certificate data
+ * **never** proves legitimate ownership.
+ *
+ * Proving legitimate ownership additionally requires verifying possession
+ * of the corresponding private key (a signature made by it, verified
+ * against the certificate's public key). The TLS handshake's
+ * `CertificateVerify` message normally provides this, but the Cloudflare
+ * Workers runtime does not expose that signature to the application. On
+ * non-Enterprise plans, Cloudflare's TLS layer also does not know about
+ * your self-managed CA, so `request.cf.tlsClientAuth.certVerified` will
+ * not be `"SUCCESS"` for certificates EdgCA issued. Application code on
+ * Workers (Enterprise excluded) has no way to verify proof-of-possession.
+ *
+ * Implication: anyone who has obtained a copy of a valid certificate
+ * (logs, leaked storage, network capture, etc.) can present it and pass
+ * this check. Use this as a minimum identity-check layer, not as
+ * authentication. For real authentication, use Cloudflare Enterprise mTLS
+ * at the TLS layer, or add an application-layer challenge-response that
+ * has the client sign a server-issued nonce with its private key.
+ *
+ * Also out of scope (not checked here): `BasicConstraints CA=false`,
+ * `EKU clientAuth`, revocation, and chain walking.
+ */
+export async function verifyClientCertificateIssuedBy(options) {
+    if (options.validity && !isWithinValidity(options.validity)) {
+        return false;
+    }
+    const certDer = pemToDerWithLabel(options.certPem, "CERTIFICATE");
+    const cert = await parseCertificateDer(certDer);
+    const issuer = await parseCertificateDer(options.ca.certDer);
+    if (!bytesEqual(cert.issuerNameDer, issuer.subjectNameDer)) {
+        return false;
+    }
+    if (!cert.authorityKeyIdentifier) {
+        return false;
+    }
+    const issuerSki = issuer.subjectKeyIdentifier ??
+        (await keyIdentifierFromSpki(issuer.subjectPublicKeyInfoDer));
+    if (!bytesEqual(cert.authorityKeyIdentifier, issuerSki)) {
+        return false;
+    }
+    return verifyDer(options.ca.publicKey, cert.signatureDer, cert.tbsCertificateDer);
+}
+function isWithinValidity(validity) {
+    const notBefore = toEpochMs(validity.notBefore, "validity.notBefore");
+    const notAfter = toEpochMs(validity.notAfter, "validity.notAfter");
+    const now = validity.now !== undefined ? toEpochMs(validity.now, "validity.now") : Date.now();
+    if (notBefore > notAfter) {
+        throw new Error("validity.notBefore must be less than or equal to validity.notAfter");
+    }
+    return notBefore <= now && now <= notAfter;
+}
+function toEpochMs(value, name) {
+    const ms = value instanceof Date ? value.getTime() : value;
+    if (typeof ms !== "number" || !Number.isFinite(ms)) {
+        throw new Error(`${name} must be a finite Date or epoch milliseconds number`);
+    }
+    return ms;
+}

package/dist/x509.d.ts

@@ -0,0 +1,34 @@
+import type { SerialNumber } from "./types.js";
+export interface CertificateBuildInput {
+    serialNumber?: SerialNumber | undefined;
+    notBefore?: Date | undefined;
+    days: number;
+    issuerNameDer: Uint8Array;
+    subjectNameDer: Uint8Array;
+    subjectPublicKeyInfoDer: Uint8Array;
+    extensions: Uint8Array[];
+}
+export interface TbsCertificateResult {
+    tbsCertificateDer: Uint8Array;
+    serialNumberDer: Uint8Array;
+    notBefore: Date;
+    notAfter: Date;
+}
+export declare function buildTbsCertificate(input: CertificateBuildInput): TbsCertificateResult;
+export declare function buildCertificate(tbsCertificateDer: Uint8Array, signatureDer: Uint8Array): Uint8Array;
+export declare function ecdsaWithSha256AlgorithmIdentifier(): Uint8Array;
+export declare function basicConstraintsCaExtension(pathLenConstraint: number): Uint8Array;
+export declare function basicConstraintsLeafExtension(): Uint8Array;
+export declare function keyUsageExtension(usages: readonly KeyUsageBit[]): Uint8Array;
+export declare function extendedKeyUsageClientAuthExtension(): Uint8Array;
+export declare function subjectKeyIdentifierExtension(keyIdentifier: Uint8Array): Uint8Array;
+export declare function authorityKeyIdentifierExtension(keyIdentifier: Uint8Array): Uint8Array;
+export declare function subjectAltNameExtension(dnsNames?: readonly string[], ipAddresses?: readonly string[]): Uint8Array | undefined;
+declare const KEY_USAGE_BITS: {
+    readonly digitalSignature: 0;
+    readonly keyCertSign: 5;
+    readonly cRLSign: 6;
+};
+type KeyUsageBit = keyof typeof KEY_USAGE_BITS;
+export {};
+//# sourceMappingURL=x509.d.ts.map

package/dist/x509.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"x509.d.ts","sourceRoot":"","sources":["../src/x509.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,MAAM,WAAW,qBAAqB;IACpC,YAAY,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IACxC,SAAS,CAAC,EAAE,IAAI,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,UAAU,CAAC;IAC1B,cAAc,EAAE,UAAU,CAAC;IAC3B,uBAAuB,EAAE,UAAU,CAAC;IACpC,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,iBAAiB,EAAE,UAAU,CAAC;IAC9B,eAAe,EAAE,UAAU,CAAC;IAC5B,SAAS,EAAE,IAAI,CAAC;IAChB,QAAQ,EAAE,IAAI,CAAC;CAChB;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,qBAAqB,GAAG,oBAAoB,CAoBtF;AAED,wBAAgB,gBAAgB,CAAC,iBAAiB,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,GAAG,UAAU,CAEpG;AAED,wBAAgB,kCAAkC,IAAI,UAAU,CAE/D;AAED,wBAAgB,2BAA2B,CAAC,iBAAiB,EAAE,MAAM,GAAG,UAAU,CAMjF;AAED,wBAAgB,6BAA6B,IAAI,UAAU,CAE1D;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,GAAG,UAAU,CAgB5E;AAED,wBAAgB,mCAAmC,IAAI,UAAU,CAEhE;AAED,wBAAgB,6BAA6B,CAAC,aAAa,EAAE,UAAU,GAAG,UAAU,CAEnF;AAED,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,UAAU,GAAG,UAAU,CAErF;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,GAAG,SAAS,CAmC7H;AAwID,QAAA,MAAM,cAAc;;;;CAIV,CAAC;AAEX,KAAK,WAAW,GAAG,MAAM,OAAO,cAAc,CAAC"}

package/dist/x509.js

@@ -0,0 +1,197 @@
+import { asciiBytes, concatBytes } from "./bytes.js";
+import { bitString, boolean, contextPrimitive, der, explicit, generalizedTime, integer, octetString, oid, readElement, sequence, TAG, utcTime } from "./der.js";
+import { encodeIpAddress } from "./ip.js";
+import { OID } from "./oids.js";
+export function buildTbsCertificate(input) {
+    const { notBefore, notAfter } = resolveValidity(input.notBefore, input.days);
+    const serialNumberDer = encodeSerialNumber(input.serialNumber);
+    const tbsCertificateDer = sequence(explicit(0, integer(2)), serialNumberDer, ecdsaWithSha256AlgorithmIdentifier(), input.issuerNameDer, sequence(encodeTime(notBefore), encodeTime(notAfter)), input.subjectNameDer, input.subjectPublicKeyInfoDer, explicit(3, sequence(...input.extensions)));
+    return {
+        tbsCertificateDer,
+        serialNumberDer,
+        notBefore,
+        notAfter
+    };
+}
+export function buildCertificate(tbsCertificateDer, signatureDer) {
+    return sequence(tbsCertificateDer, ecdsaWithSha256AlgorithmIdentifier(), bitString(signatureDer));
+}
+export function ecdsaWithSha256AlgorithmIdentifier() {
+    return sequence(oid(OID.ecdsaWithSha256));
+}
+export function basicConstraintsCaExtension(pathLenConstraint) {
+    return extension(OID.basicConstraints, true, sequence(boolean(true), integer(pathLenConstraint)));
+}
+export function basicConstraintsLeafExtension() {
+    return extension(OID.basicConstraints, true, sequence());
+}
+export function keyUsageExtension(usages) {
+    let maxBit = 0;
+    for (const usage of usages) {
+        maxBit = Math.max(maxBit, KEY_USAGE_BITS[usage]);
+    }
+    const byteLength = Math.floor(maxBit / 8) + 1;
+    const bytes = new Uint8Array(byteLength);
+    for (const usage of usages) {
+        const bit = KEY_USAGE_BITS[usage];
+        bytes[Math.floor(bit / 8)] |= 0x80 >> (bit % 8);
+    }
+    const unusedBits = byteLength * 8 - maxBit - 1;
+    return extension(OID.keyUsage, true, bitString(bytes, unusedBits));
+}
+export function extendedKeyUsageClientAuthExtension() {
+    return extension(OID.extendedKeyUsage, false, sequence(oid(OID.clientAuth)));
+}
+export function subjectKeyIdentifierExtension(keyIdentifier) {
+    return extension(OID.subjectKeyIdentifier, false, octetString(keyIdentifier));
+}
+export function authorityKeyIdentifierExtension(keyIdentifier) {
+    return extension(OID.authorityKeyIdentifier, false, sequence(contextPrimitive(0, keyIdentifier)));
+}
+export function subjectAltNameExtension(dnsNames, ipAddresses) {
+    assertOptionalStringArray("dnsNames", dnsNames);
+    assertOptionalStringArray("ipAddresses", ipAddresses);
+    const names = [];
+    const seenDnsNames = new Set();
+    const seenIpAddresses = new Set();
+    for (const dnsName of dnsNames ?? []) {
+        if (typeof dnsName !== "string" || dnsName.length > 253 || !DNS_NAME_PATTERN.test(dnsName)) {
+            throw new Error(`Invalid SAN dNSName: ${dnsName}`);
+        }
+        if (seenDnsNames.has(dnsName)) {
+            throw new Error(`Duplicate SAN dNSName: ${dnsName}`);
+        }
+        seenDnsNames.add(dnsName);
+        names.push(der(0x82, asciiBytes(dnsName)));
+    }
+    for (const ipAddress of ipAddresses ?? []) {
+        if (typeof ipAddress !== "string") {
+            throw new Error(`Invalid SAN iPAddress: ${ipAddress}`);
+        }
+        const encoded = encodeIpAddress(ipAddress);
+        // Compare by encoded bytes so that textually different forms of the same IP
+        // (e.g. "::1" vs "0:0:0:0:0:0:0:1") are correctly recognized as duplicates.
+        const key = encoded.join(",");
+        if (seenIpAddresses.has(key)) {
+            throw new Error(`Duplicate SAN iPAddress: ${ipAddress}`);
+        }
+        seenIpAddresses.add(key);
+        names.push(der(0x87, encoded));
+    }
+    return names.length > 0 ? extension(OID.subjectAltName, false, sequence(...names)) : undefined;
+}
+// RFC 1035 §2.3.1 preferred name syntax: each label starts and ends with [A-Za-z0-9],
+// may contain hyphens internally, and is at most 63 characters. Optional leading "*." wildcard.
+const DNS_LABEL = /[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?/;
+const DNS_NAME_PATTERN = new RegExp(`^(\\*\\.)?${DNS_LABEL.source}(?:\\.${DNS_LABEL.source})*$`);
+function assertOptionalStringArray(name, values) {
+    if (values !== undefined && !Array.isArray(values)) {
+        throw new Error(`${name} must be an array`);
+    }
+}
+function extension(extensionOid, critical, valueDer) {
+    return sequence(oid(extensionOid), ...(critical ? [boolean(true)] : []), octetString(valueDer));
+}
+function encodeSerialNumber(serialNumber) {
+    const encoded = encodeSerialNumberDer(serialNumber);
+    const element = readElement(encoded);
+    if (element.length > 20) {
+        throw new Error("serialNumber encoded value must not exceed 20 octets");
+    }
+    if (element.value.every((byte) => byte === 0)) {
+        throw new Error("serialNumber must be a positive integer");
+    }
+    return encoded;
+}
+function encodeSerialNumberDer(serialNumber) {
+    if (serialNumber === undefined) {
+        const bytes = new Uint8Array(16);
+        crypto.getRandomValues(bytes);
+        bytes[0] = bytes[0] & 0x7f;
+        if (bytes.every((byte) => byte === 0)) {
+            bytes[15] = 1;
+        }
+        return integer(bytes);
+    }
+    if (serialNumber instanceof Uint8Array) {
+        if (serialNumber.length === 0) {
+            throw new Error("serialNumber Uint8Array must not be empty");
+        }
+        if (serialNumber.length > 20) {
+            throw new Error("serialNumber Uint8Array must not exceed 20 octets");
+        }
+        return integer(serialNumber);
+    }
+    if (typeof serialNumber === "string") {
+        if (/^\d+$/.test(serialNumber)) {
+            if (serialNumber.length > SERIAL_NUMBER_MAX_DECIMAL_DIGITS) {
+                throw new Error(`serialNumber decimal string must not exceed ${SERIAL_NUMBER_MAX_DECIMAL_DIGITS} digits`);
+            }
+            return integer(BigInt(serialNumber));
+        }
+        if (/^[0-9a-fA-F]+$/.test(serialNumber)) {
+            if (serialNumber.length > SERIAL_NUMBER_MAX_HEX_CHARS) {
+                throw new Error(`serialNumber hex string must not exceed ${SERIAL_NUMBER_MAX_HEX_CHARS} characters (20 octets)`);
+            }
+            const normalized = serialNumber.length % 2 === 0 ? serialNumber : `0${serialNumber}`;
+            const bytes = new Uint8Array(normalized.length / 2);
+            for (let i = 0; i < normalized.length; i += 2) {
+                bytes[i / 2] = Number.parseInt(normalized.slice(i, i + 2), 16);
+            }
+            return integer(bytes);
+        }
+        throw new Error("serialNumber string must be decimal digits or hex");
+    }
+    return integer(serialNumber);
+}
+// Maximum string-input lengths chosen so that any string passing this check
+// also passes the post-encode 20-octet limit:
+//   - 47-digit decimal: max value 10^47 - 1 < 2^159, fits in 20 octets without leading 0x00.
+//     (48-digit values up to 10^48 - 1 ≈ 9.99e47 exceed 2^159 ≈ 7.27e47, so the leading 0x00
+//      sign byte would push the encoded length to 21 octets.)
+//   - 39-char hex: pads to 40 chars with a leading "0", giving 20 octets whose top byte
+//     0x0X has the high bit clear, so no extra sign byte is added.
+//     (40-char hex with leading nibble 0x8-0xf would add a leading 0x00 → 21 octets.)
+const SERIAL_NUMBER_MAX_DECIMAL_DIGITS = 47;
+const SERIAL_NUMBER_MAX_HEX_CHARS = 39;
+function resolveValidity(notBeforeInput, days) {
+    if (typeof days !== "number" || !Number.isInteger(days) || days <= 0) {
+        throw new Error("days must be a positive integer");
+    }
+    if (notBeforeInput !== undefined && !(notBeforeInput instanceof Date)) {
+        throw new Error("notBefore must be a Date");
+    }
+    const notBefore = notBeforeInput === undefined ? new Date() : new Date(notBeforeInput.getTime());
+    const notBeforeMs = notBefore.getTime();
+    if (!Number.isFinite(notBeforeMs)) {
+        throw new Error("notBefore must be a valid Date");
+    }
+    assertYearInRange(notBefore.getUTCFullYear(), "notBefore");
+    const notAfterMs = notBeforeMs + days * 86_400_000;
+    if (!Number.isFinite(notAfterMs)) {
+        throw new Error("notAfter must be a valid Date");
+    }
+    const notAfter = new Date(notAfterMs);
+    if (!Number.isFinite(notAfter.getTime())) {
+        throw new Error("notAfter must be a valid Date");
+    }
+    assertYearInRange(notAfter.getUTCFullYear(), "notAfter");
+    return {
+        notBefore,
+        notAfter
+    };
+}
+function encodeTime(date) {
+    const year = date.getUTCFullYear();
+    return year >= 1950 && year <= 2049 ? utcTime(date) : generalizedTime(date);
+}
+function assertYearInRange(year, fieldName) {
+    if (year < 1 || year > 9999) {
+        throw new Error(`${fieldName} year must be between 0001 and 9999`);
+    }
+}
+const KEY_USAGE_BITS = {
+    digitalSignature: 0,
+    keyCertSign: 5,
+    cRLSign: 6
+};