@noz-ele/edgca 0.1.0

package/dist/crypto.js

@@ -0,0 +1,104 @@
+import { arrayBufferFromBytes, concatBytes } from "./bytes.js";
+import { integer, readChildren, readElement, readSequenceChildren, sequence, TAG } from "./der.js";
+import { pemToDerWithLabel, privateKeyDerToPem, publicKeyDerToPem } from "./pem.js";
+const EC_ALGORITHM = {
+    name: "ECDSA",
+    namedCurve: "P-256"
+};
+const ECDSA_SIGN_ALGORITHM = {
+    name: "ECDSA",
+    hash: "SHA-256"
+};
+export async function generateKeyPair() {
+    return crypto.subtle.generateKey(EC_ALGORITHM, true, ["sign", "verify"]);
+}
+export async function signDer(privateKey, data) {
+    const raw = new Uint8Array(await crypto.subtle.sign(ECDSA_SIGN_ALGORITHM, privateKey, arrayBufferFromBytes(data)));
+    return ecdsaRawToDer(raw);
+}
+export async function verifyDer(publicKey, signatureDer, data) {
+    return crypto.subtle.verify(ECDSA_SIGN_ALGORITHM, publicKey, arrayBufferFromBytes(ecdsaDerToRaw(signatureDer)), arrayBufferFromBytes(data));
+}
+export async function digestSha256(data) {
+    return new Uint8Array(await crypto.subtle.digest("SHA-256", arrayBufferFromBytes(data)));
+}
+export async function digestSha1(data) {
+    return new Uint8Array(await crypto.subtle.digest("SHA-1", arrayBufferFromBytes(data)));
+}
+// RFC 5280 §4.2.1.2 method (1): SHA-1 of the BIT STRING subjectPublicKey value,
+// excluding the tag, length, and number of unused bits.
+export async function keyIdentifierFromSpki(spki) {
+    const root = readElement(spki);
+    if (root.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid SubjectPublicKeyInfo");
+    }
+    const children = readSequenceChildren(root);
+    const subjectPublicKey = children[1];
+    if (!subjectPublicKey || subjectPublicKey.tag !== TAG.BIT_STRING || subjectPublicKey.value.length < 1) {
+        throw new Error("Invalid SubjectPublicKeyInfo subjectPublicKey");
+    }
+    return digestSha1(subjectPublicKey.value.subarray(1));
+}
+export async function privateKeyToPem(key) {
+    const der = new Uint8Array(await crypto.subtle.exportKey("pkcs8", key));
+    return privateKeyDerToPem(der);
+}
+export async function publicKeyToPem(key) {
+    const der = new Uint8Array(await crypto.subtle.exportKey("spki", key));
+    return publicKeyDerToPem(der);
+}
+export async function exportSpki(key) {
+    return new Uint8Array(await crypto.subtle.exportKey("spki", key));
+}
+export async function importPrivateKeyPem(pem) {
+    return crypto.subtle.importKey("pkcs8", arrayBufferFromBytes(pemToDerWithLabel(pem, "PRIVATE KEY")), EC_ALGORITHM, true, ["sign"]);
+}
+export async function keyPairFromPrivateKeyPem(pem) {
+    const privateKey = await importPrivateKeyPem(pem);
+    const jwk = await crypto.subtle.exportKey("jwk", privateKey);
+    delete jwk.d;
+    jwk.key_ops = ["verify"];
+    const publicKey = await crypto.subtle.importKey("jwk", jwk, EC_ALGORITHM, true, ["verify"]);
+    return { privateKey, publicKey };
+}
+export async function importPublicKeySpki(spki) {
+    return crypto.subtle.importKey("spki", arrayBufferFromBytes(spki), EC_ALGORITHM, true, ["verify"]);
+}
+export async function assertKeyPairMatches(privateKey, publicKey) {
+    const data = new TextEncoder().encode("edgca-key-pair-check");
+    const signature = await signDer(privateKey, data);
+    const ok = await verifyDer(publicKey, signature, data);
+    if (!ok) {
+        throw new Error("Private key does not match CA certificate public key");
+    }
+}
+export function ecdsaRawToDer(raw) {
+    if (raw.length !== 64) {
+        throw new Error("P-256 ECDSA raw signature must be 64 bytes");
+    }
+    return sequence(integer(raw.subarray(0, 32)), integer(raw.subarray(32)));
+}
+export function ecdsaDerToRaw(signature) {
+    const root = readElement(signature);
+    if (root.tag !== TAG.SEQUENCE || root.end !== signature.length) {
+        throw new Error("Invalid DER ECDSA signature");
+    }
+    const [r, s] = readChildren(root.value);
+    if (!r || !s || r.tag !== TAG.INTEGER || s.tag !== TAG.INTEGER) {
+        throw new Error("Invalid DER ECDSA signature integers");
+    }
+    return concatBytes([integerToFixedWidth(r.value), integerToFixedWidth(s.value)]);
+}
+function integerToFixedWidth(value) {
+    let start = 0;
+    while (start < value.length - 1 && value[start] === 0) {
+        start += 1;
+    }
+    const trimmed = value.subarray(start);
+    if (trimmed.length > 32) {
+        throw new Error("ECDSA integer is wider than P-256");
+    }
+    const out = new Uint8Array(32);
+    out.set(trimmed, 32 - trimmed.length);
+    return out;
+}

package/dist/der.d.ts

@@ -0,0 +1,45 @@
+export declare const TAG: {
+    readonly BOOLEAN: 1;
+    readonly INTEGER: 2;
+    readonly BIT_STRING: 3;
+    readonly OCTET_STRING: 4;
+    readonly NULL: 5;
+    readonly OBJECT_IDENTIFIER: 6;
+    readonly UTF8_STRING: 12;
+    readonly SEQUENCE: 48;
+    readonly SET: 49;
+    readonly PRINTABLE_STRING: 19;
+    readonly IA5_STRING: 22;
+    readonly UTC_TIME: 23;
+    readonly GENERALIZED_TIME: 24;
+};
+export interface DerElement {
+    tag: number;
+    headerLength: number;
+    length: number;
+    start: number;
+    end: number;
+    value: Uint8Array;
+    raw: Uint8Array;
+}
+export declare function der(tag: number, value: Uint8Array): Uint8Array;
+export declare function sequence(...children: Uint8Array[]): Uint8Array;
+export declare function set(...children: Uint8Array[]): Uint8Array;
+export declare function explicit(tagNumber: number, value: Uint8Array): Uint8Array;
+export declare function oid(value: string): Uint8Array;
+export declare function boolean(value: boolean): Uint8Array;
+export declare function integer(value: bigint | number | Uint8Array): Uint8Array;
+export declare function bitString(bytes: Uint8Array, unusedBits?: number): Uint8Array;
+export declare function octetString(bytes: Uint8Array): Uint8Array;
+export declare function utf8String(value: string): Uint8Array;
+export declare function printableString(value: string): Uint8Array;
+export declare function ia5String(value: string): Uint8Array;
+export declare function contextPrimitive(tagNumber: number, value: Uint8Array): Uint8Array;
+export declare function utcTime(date: Date): Uint8Array;
+export declare function generalizedTime(date: Date): Uint8Array;
+export declare function readElement(input: Uint8Array, offset?: number): DerElement;
+export declare function readSequenceChildren(element: DerElement): DerElement[];
+export declare function readChildren(input: Uint8Array): DerElement[];
+export declare function decodeOid(input: Uint8Array): string;
+export declare function decodeInteger(input: Uint8Array): bigint;
+//# sourceMappingURL=der.d.ts.map

package/dist/der.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"der.d.ts","sourceRoot":"","sources":["../src/der.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG;;;;;;;;;;;;;;CAcN,CAAC;AAEX,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,UAAU,CAAC;IAClB,GAAG,EAAE,UAAU,CAAC;CACjB;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,UAAU,CAE9D;AAED,wBAAgB,QAAQ,CAAC,GAAG,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,CAE9D;AAED,wBAAgB,GAAG,CAAC,GAAG,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,CAEzD;AAED,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,UAAU,CAEzE;AAED,wBAAgB,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAmB7C;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAElD;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CA4BvE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,UAAU,SAAI,GAAG,UAAU,CAMvE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAEzD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAEpD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAMzD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAEnD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,UAAU,CAEjF;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,CAO9C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,UAAU,CAMtD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,SAAI,GAAG,UAAU,CAuBrE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,EAAE,CAMtE;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,EAAE,CAW5D;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CA4CnD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAevD"}

package/dist/der.js

@@ -0,0 +1,269 @@
+import { asciiBytes, concatBytes, utf8Bytes } from "./bytes.js";
+export const TAG = {
+    BOOLEAN: 0x01,
+    INTEGER: 0x02,
+    BIT_STRING: 0x03,
+    OCTET_STRING: 0x04,
+    NULL: 0x05,
+    OBJECT_IDENTIFIER: 0x06,
+    UTF8_STRING: 0x0c,
+    SEQUENCE: 0x30,
+    SET: 0x31,
+    PRINTABLE_STRING: 0x13,
+    IA5_STRING: 0x16,
+    UTC_TIME: 0x17,
+    GENERALIZED_TIME: 0x18
+};
+export function der(tag, value) {
+    return concatBytes([new Uint8Array([tag]), encodeLength(value.length), value]);
+}
+export function sequence(...children) {
+    return der(TAG.SEQUENCE, concatBytes(children));
+}
+export function set(...children) {
+    return der(TAG.SET, concatBytes(children));
+}
+export function explicit(tagNumber, value) {
+    return der(0xa0 + tagNumber, value);
+}
+export function oid(value) {
+    const parts = value.split(".").map((part) => {
+        if (!/^(0|[1-9]\d*)$/.test(part)) {
+            throw new Error(`Invalid OID: ${value}`);
+        }
+        return Number(part);
+    });
+    if (parts.length < 2) {
+        throw new Error(`Invalid OID: ${value}`);
+    }
+    const [first, second, ...rest] = parts;
+    if (first === undefined || second === undefined || first > 2 || second > 39 && first < 2) {
+        throw new Error(`Invalid OID: ${value}`);
+    }
+    const body = [first * 40 + second, ...rest].flatMap(encodeBase128);
+    return der(TAG.OBJECT_IDENTIFIER, new Uint8Array(body));
+}
+export function boolean(value) {
+    return der(TAG.BOOLEAN, new Uint8Array([value ? 0xff : 0x00]));
+}
+export function integer(value) {
+    if (value instanceof Uint8Array) {
+        return der(TAG.INTEGER, normalizeIntegerBytes(value));
+    }
+    if (typeof value === "number") {
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new Error("INTEGER number must be a non-negative safe integer");
+        }
+        return integer(BigInt(value));
+    }
+    if (value < 0n) {
+        throw new Error("INTEGER bigint must be non-negative");
+    }
+    if (value === 0n) {
+        return der(TAG.INTEGER, new Uint8Array([0]));
+    }
+    const bytes = [];
+    let current = value;
+    while (current > 0n) {
+        bytes.unshift(Number(current & 0xffn));
+        current >>= 8n;
+    }
+    return integer(new Uint8Array(bytes));
+}
+export function bitString(bytes, unusedBits = 0) {
+    if (unusedBits < 0 || unusedBits > 7) {
+        throw new Error("BIT STRING unused bits must be between 0 and 7");
+    }
+    return der(TAG.BIT_STRING, concatBytes([new Uint8Array([unusedBits]), bytes]));
+}
+export function octetString(bytes) {
+    return der(TAG.OCTET_STRING, bytes);
+}
+export function utf8String(value) {
+    return der(TAG.UTF8_STRING, utf8Bytes(value));
+}
+export function printableString(value) {
+    if (!/^[A-Za-z0-9 '()+,\-./:=?]*$/.test(value)) {
+        throw new Error("PrintableString contains an unsupported character");
+    }
+    return der(TAG.PRINTABLE_STRING, asciiBytes(value));
+}
+export function ia5String(value) {
+    return der(TAG.IA5_STRING, asciiBytes(value));
+}
+export function contextPrimitive(tagNumber, value) {
+    return der(0x80 + tagNumber, value);
+}
+export function utcTime(date) {
+    const year = date.getUTCFullYear();
+    if (year < 1950 || year > 2049) {
+        return generalizedTime(date);
+    }
+    return der(TAG.UTC_TIME, asciiBytes(`${two(year % 100)}${timeTail(date)}`));
+}
+export function generalizedTime(date) {
+    const year = date.getUTCFullYear();
+    if (year < 1 || year > 9999) {
+        throw new Error("GeneralizedTime year must be between 0001 and 9999");
+    }
+    return der(TAG.GENERALIZED_TIME, asciiBytes(`${year.toString().padStart(4, "0")}${timeTail(date)}`));
+}
+export function readElement(input, offset = 0) {
+    if (offset >= input.length) {
+        throw new Error("Unexpected end of DER input");
+    }
+    const tag = input[offset];
+    const lengthInfo = decodeLength(input, offset + 1);
+    const start = lengthInfo.offset;
+    const end = start + lengthInfo.length;
+    if (end > input.length) {
+        throw new Error("DER length exceeds input size");
+    }
+    return {
+        tag,
+        headerLength: start - offset,
+        length: lengthInfo.length,
+        start,
+        end,
+        value: input.subarray(start, end),
+        raw: input.subarray(offset, end)
+    };
+}
+export function readSequenceChildren(element) {
+    if (element.tag !== TAG.SEQUENCE) {
+        throw new Error("Expected SEQUENCE");
+    }
+    return readChildren(element.value);
+}
+export function readChildren(input) {
+    const out = [];
+    let offset = 0;
+    while (offset < input.length) {
+        const element = readElement(input, offset);
+        out.push(element);
+        offset = element.end;
+    }
+    return out;
+}
+export function decodeOid(input) {
+    if (input.length === 0) {
+        throw new Error("Invalid empty OID");
+    }
+    // Decode the first base-128 sub-identifier (which may be multi-byte for
+    // joint-iso-itu-t OIDs whose joint value 2*40+second exceeds 127).
+    let firstSubId = 0;
+    let i = 0;
+    let firstComplete = false;
+    while (i < input.length) {
+        const byte = input[i];
+        firstSubId = firstSubId * 128 + (byte & 0x7f);
+        i += 1;
+        if ((byte & 0x80) === 0) {
+            firstComplete = true;
+            break;
+        }
+    }
+    if (!firstComplete) {
+        throw new Error("Truncated OID");
+    }
+    const parts = firstSubId < 40 ? [0, firstSubId]
+        : firstSubId < 80 ? [1, firstSubId - 40]
+            : [2, firstSubId - 80];
+    let value = 0;
+    for (; i < input.length; i += 1) {
+        const byte = input[i];
+        value = value * 128 + (byte & 0x7f);
+        if ((byte & 0x80) === 0) {
+            parts.push(value);
+            value = 0;
+        }
+    }
+    if (value !== 0) {
+        throw new Error("Truncated OID");
+    }
+    return parts.join(".");
+}
+export function decodeInteger(input) {
+    if (input.length === 0) {
+        throw new Error("Invalid empty INTEGER");
+    }
+    if ((input[0] & 0x80) !== 0) {
+        throw new Error("Negative INTEGER is unsupported");
+    }
+    let value = 0n;
+    for (const byte of input) {
+        value = (value << 8n) | BigInt(byte);
+    }
+    return value;
+}
+function encodeLength(length) {
+    if (length < 0x80) {
+        return new Uint8Array([length]);
+    }
+    const bytes = [];
+    let current = length;
+    while (current > 0) {
+        bytes.unshift(current & 0xff);
+        current >>= 8;
+    }
+    return new Uint8Array([0x80 | bytes.length, ...bytes]);
+}
+function decodeLength(input, offset) {
+    const first = input[offset];
+    if (first === undefined) {
+        throw new Error("Missing DER length");
+    }
+    if ((first & 0x80) === 0) {
+        return { length: first, offset: offset + 1 };
+    }
+    const count = first & 0x7f;
+    if (count === 0) {
+        throw new Error("Indefinite DER length is not allowed");
+    }
+    if (offset + 1 + count > input.length) {
+        throw new Error("Truncated DER length");
+    }
+    let length = 0;
+    for (let i = 0; i < count; i += 1) {
+        length = (length << 8) | input[offset + 1 + i];
+    }
+    return { length, offset: offset + 1 + count };
+}
+function encodeBase128(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error("OID component must be a non-negative safe integer");
+    }
+    if (value === 0) {
+        return [0];
+    }
+    const bytes = [];
+    let current = value;
+    while (current > 0) {
+        bytes.unshift(current & 0x7f);
+        current >>= 7;
+    }
+    for (let i = 0; i < bytes.length - 1; i += 1) {
+        bytes[i] = bytes[i] | 0x80;
+    }
+    return bytes;
+}
+function normalizeIntegerBytes(bytes) {
+    let offset = 0;
+    while (offset < bytes.length - 1 && bytes[offset] === 0) {
+        offset += 1;
+    }
+    const trimmed = bytes.subarray(offset);
+    if (trimmed.length === 0) {
+        return new Uint8Array([0]);
+    }
+    if ((trimmed[0] & 0x80) !== 0) {
+        return concatBytes([new Uint8Array([0]), trimmed]);
+    }
+    return new Uint8Array(trimmed);
+}
+function timeTail(date) {
+    return `${two(date.getUTCMonth() + 1)}${two(date.getUTCDate())}${two(date.getUTCHours())}${two(date.getUTCMinutes())}${two(date.getUTCSeconds())}Z`;
+}
+function two(value) {
+    return value.toString().padStart(2, "0");
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createRootCA, importCertificateAuthority, issueClientCert, issueIntermediateCA } from "./ca.js";
+export { pemToDer, certificateToPem } from "./pem.js";
+export { privateKeyToPem, publicKeyToPem } from "./crypto.js";
+export { verifyClientCertificateIssuedBy, type VerifyClientCertificateIssuedByOptions, type VerifyClientCertificateValidity } from "./verify.js";
+export type { CertificateAuthority, CreateRootCAOptions, ImportCertificateAuthorityOptions, IssueClientCertOptions, IssueIntermediateCAOptions, IssuedClientCertificate, SerialNumber, ShortSubjectAttributeType, Subject, SubjectAttribute, SubjectAttributeType } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,0BAA0B,EAC1B,eAAe,EACf,mBAAmB,EACpB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EACL,+BAA+B,EAC/B,KAAK,sCAAsC,EAC3C,KAAK,+BAA+B,EACrC,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,oBAAoB,EACpB,mBAAmB,EACnB,iCAAiC,EACjC,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACvB,YAAY,EACZ,yBAAyB,EACzB,OAAO,EACP,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createRootCA, importCertificateAuthority, issueClientCert, issueIntermediateCA } from "./ca.js";
+export { pemToDer, certificateToPem } from "./pem.js";
+export { privateKeyToPem, publicKeyToPem } from "./crypto.js";
+export { verifyClientCertificateIssuedBy } from "./verify.js";

package/dist/ip.d.ts

@@ -0,0 +1,2 @@
+export declare function encodeIpAddress(value: string): Uint8Array;
+//# sourceMappingURL=ip.d.ts.map

package/dist/ip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.d.ts","sourceRoot":"","sources":["../src/ip.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAEzD"}

package/dist/ip.js

@@ -0,0 +1,55 @@
+export function encodeIpAddress(value) {
+    return value.includes(":") ? encodeIpv6(value) : encodeIpv4(value);
+}
+function encodeIpv4(value) {
+    const parts = value.split(".");
+    if (parts.length !== 4) {
+        throw new Error(`Invalid IPv4 address: ${value}`);
+    }
+    return new Uint8Array(parts.map((part) => {
+        if (!/^(0|[1-9]\d*)$/.test(part)) {
+            throw new Error(`Invalid IPv4 address: ${value}`);
+        }
+        const octet = Number(part);
+        if (octet < 0 || octet > 255) {
+            throw new Error(`Invalid IPv4 address: ${value}`);
+        }
+        return octet;
+    }));
+}
+function encodeIpv6(value) {
+    const segments = value.split("::");
+    if (segments.length > 2) {
+        throw new Error(`Invalid IPv6 address: ${value}`);
+    }
+    const left = parseIpv6Groups(segments[0], value);
+    const right = parseIpv6Groups(segments[1] ?? "", value);
+    const missing = 8 - left.length - right.length;
+    if (segments.length === 2) {
+        // RFC 5952 §4.2.2: "::" must compress at least two zero groups.
+        if (missing < 2) {
+            throw new Error(`Invalid IPv6 address: ${value}`);
+        }
+    }
+    else if (missing !== 0) {
+        throw new Error(`Invalid IPv6 address: ${value}`);
+    }
+    const groups = [...left, ...new Array(missing).fill(0), ...right];
+    const out = new Uint8Array(16);
+    groups.forEach((group, index) => {
+        out[index * 2] = group >> 8;
+        out[index * 2 + 1] = group & 0xff;
+    });
+    return out;
+}
+function parseIpv6Groups(part, original) {
+    if (part === "") {
+        return [];
+    }
+    return part.split(":").map((group) => {
+        if (!/^[0-9a-fA-F]{1,4}$/.test(group)) {
+            throw new Error(`Invalid IPv6 address: ${original}`);
+        }
+        return Number.parseInt(group, 16);
+    });
+}

package/dist/name.d.ts

@@ -0,0 +1,4 @@
+import type { Subject, SubjectAttributeType } from "./types.js";
+export declare function encodeName(subject: Subject): Uint8Array;
+export declare function resolveAttributeOid(type: SubjectAttributeType): string;
+//# sourceMappingURL=name.d.ts.map

package/dist/name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"name.d.ts","sourceRoot":"","sources":["../src/name.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAA6B,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAgB3F,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAkCvD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,oBAAoB,GAAG,MAAM,CAUtE"}

package/dist/name.js

@@ -0,0 +1,71 @@
+import { sequence, set, oid, ia5String, printableString, utf8String } from "./der.js";
+import { MAX_SUBJECT_VALUE_LENGTH, SUBJECT_ATTRIBUTE_OIDS, SUBJECT_VALUE_LENGTH_LIMITS } from "./oids.js";
+const SHORT_TYPES = new Set(Object.keys(SUBJECT_ATTRIBUTE_OIDS));
+const DOTTED_OID_PATTERN = /^(?:0|1|2)\.(?:0|[1-9]\d*)(?:\.(?:0|[1-9]\d*))+$/;
+// RFC 5280 §A.1: AttributeValue string type per attribute OID.
+// C → PrintableString, emailAddress (E) → IA5String, others → UTF8String.
+const PRINTABLE_STRING_OIDS = new Set([SUBJECT_ATTRIBUTE_OIDS.C]);
+const IA5_STRING_OIDS = new Set([SUBJECT_ATTRIBUTE_OIDS.E]);
+function encodeAttributeValue(attributeOid, value) {
+    if (PRINTABLE_STRING_OIDS.has(attributeOid))
+        return printableString(value);
+    if (IA5_STRING_OIDS.has(attributeOid))
+        return ia5String(value);
+    return utf8String(value);
+}
+export function encodeName(subject) {
+    if (!Array.isArray(subject) || subject.length === 0) {
+        throw new Error("subject must be a non-empty array");
+    }
+    return sequence(...subject.map((attribute, index) => {
+        if (!attribute || typeof attribute !== "object") {
+            throw new Error(`subject[${index}] must be an object with type and value`);
+        }
+        if (typeof attribute.type !== "string") {
+            throw new Error(`subject[${index}].type must be a string`);
+        }
+        if (typeof attribute.value !== "string") {
+            throw new Error(`subject[${index}].value must be a string`);
+        }
+        if (attribute.value.length === 0) {
+            throw new Error(`subject[${index}].value must not be empty`);
+        }
+        if (containsForbiddenChar(attribute.value)) {
+            throw new Error(`subject[${index}].value contains forbidden control or bidi character`);
+        }
+        const limit = SUBJECT_VALUE_LENGTH_LIMITS[attribute.type] ?? MAX_SUBJECT_VALUE_LENGTH;
+        const codepointLength = [...attribute.value].length;
+        if (codepointLength > limit) {
+            throw new Error(`subject[${index}].value exceeds ${limit} character limit for type "${attribute.type}"`);
+        }
+        const attributeOid = resolveAttributeOid(attribute.type);
+        const value = encodeAttributeValue(attributeOid, attribute.value);
+        return set(sequence(oid(attributeOid), value));
+    }));
+}
+export function resolveAttributeOid(type) {
+    if (SHORT_TYPES.has(type)) {
+        return SUBJECT_ATTRIBUTE_OIDS[type];
+    }
+    if (DOTTED_OID_PATTERN.test(type)) {
+        return type;
+    }
+    throw new Error(`Unsupported subject attribute type: ${type}`);
+}
+// Reject C0 controls (U+0000-U+001F), DEL (U+007F), LTR/RTL marks (U+200E, U+200F),
+// bidi embedding/override (U+202A-U+202E), and bidi isolates (U+2066-U+2069).
+// Avoids embedding raw control characters in source for review safety.
+function containsForbiddenChar(value) {
+    for (let i = 0; i < value.length; i += 1) {
+        const code = value.charCodeAt(i);
+        if (code < 0x20 || code === 0x7f)
+            return true;
+        if (code === 0x200e || code === 0x200f)
+            return true;
+        if (code >= 0x202a && code <= 0x202e)
+            return true;
+        if (code >= 0x2066 && code <= 0x2069)
+            return true;
+    }
+    return false;
+}

package/dist/oids.d.ts

@@ -0,0 +1,15 @@
+import type { ShortSubjectAttributeType } from "./types.js";
+export declare const OID: {
+    readonly ecdsaWithSha256: "1.2.840.10045.4.3.2";
+    readonly basicConstraints: "2.5.29.19";
+    readonly keyUsage: "2.5.29.15";
+    readonly extendedKeyUsage: "2.5.29.37";
+    readonly subjectAltName: "2.5.29.17";
+    readonly subjectKeyIdentifier: "2.5.29.14";
+    readonly authorityKeyIdentifier: "2.5.29.35";
+    readonly clientAuth: "1.3.6.1.5.5.7.3.2";
+};
+export declare const SUBJECT_ATTRIBUTE_OIDS: Record<ShortSubjectAttributeType, string>;
+export declare const SUBJECT_VALUE_LENGTH_LIMITS: Record<ShortSubjectAttributeType, number>;
+export declare const MAX_SUBJECT_VALUE_LENGTH = 256;
+//# sourceMappingURL=oids.d.ts.map

package/dist/oids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oids.d.ts","sourceRoot":"","sources":["../src/oids.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAE5D,eAAO,MAAM,GAAG;;;;;;;;;CASN,CAAC;AAEX,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,yBAAyB,EAAE,MAAM,CAgB5E,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAAC,yBAAyB,EAAE,MAAM,CAgBjF,CAAC;AAIF,eAAO,MAAM,wBAAwB,MAAM,CAAC"}

package/dist/oids.js

@@ -0,0 +1,48 @@
+export const OID = {
+    ecdsaWithSha256: "1.2.840.10045.4.3.2",
+    basicConstraints: "2.5.29.19",
+    keyUsage: "2.5.29.15",
+    extendedKeyUsage: "2.5.29.37",
+    subjectAltName: "2.5.29.17",
+    subjectKeyIdentifier: "2.5.29.14",
+    authorityKeyIdentifier: "2.5.29.35",
+    clientAuth: "1.3.6.1.5.5.7.3.2"
+};
+export const SUBJECT_ATTRIBUTE_OIDS = {
+    CN: "2.5.4.3",
+    O: "2.5.4.10",
+    OU: "2.5.4.11",
+    C: "2.5.4.6",
+    ST: "2.5.4.8",
+    L: "2.5.4.7",
+    E: "1.2.840.113549.1.9.1",
+    DC: "0.9.2342.19200300.100.1.25",
+    SERIALNUMBER: "2.5.4.5",
+    STREET: "2.5.4.9",
+    POSTALCODE: "2.5.4.17",
+    TITLE: "2.5.4.12",
+    GIVENNAME: "2.5.4.42",
+    SURNAME: "2.5.4.4",
+    UID: "0.9.2342.19200300.100.1.1"
+};
+// RFC 5280 Appendix A.1 ub-* upper bounds (character counts).
+export const SUBJECT_VALUE_LENGTH_LIMITS = {
+    CN: 64,
+    O: 64,
+    OU: 64,
+    C: 4,
+    ST: 128,
+    L: 128,
+    E: 255,
+    DC: 63,
+    SERIALNUMBER: 64,
+    STREET: 128,
+    POSTALCODE: 16,
+    TITLE: 64,
+    GIVENNAME: 16,
+    SURNAME: 40,
+    UID: 256
+};
+// Default cap for unknown (dotted-OID) attributes. Matches the largest known
+// ub-* limit (UID = 256). Callers needing more must use a known short type.
+export const MAX_SUBJECT_VALUE_LENGTH = 256;

package/dist/parser.d.ts

@@ -0,0 +1,17 @@
+export interface ParsedCertificate {
+    der: Uint8Array;
+    tbsCertificateDer: Uint8Array;
+    signatureDer: Uint8Array;
+    issuerNameDer: Uint8Array;
+    subjectNameDer: Uint8Array;
+    subjectPublicKeyInfoDer: Uint8Array;
+    publicKey: CryptoKey;
+    isCA: boolean;
+    pathLenConstraint?: number;
+    keyCertSign: boolean;
+    subjectKeyIdentifier?: Uint8Array;
+    authorityKeyIdentifier?: Uint8Array;
+}
+export declare function parseCertificateDer(der: Uint8Array): Promise<ParsedCertificate>;
+export declare function assertIssuerSubjectMatches(issuer: ParsedCertificate, issued: ParsedCertificate): void;
+//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,UAAU,CAAC;IAChB,iBAAiB,EAAE,UAAU,CAAC;IAC9B,YAAY,EAAE,UAAU,CAAC;IACzB,aAAa,EAAE,UAAU,CAAC;IAC1B,cAAc,EAAE,UAAU,CAAC;IAC3B,uBAAuB,EAAE,UAAU,CAAC;IACpC,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE,OAAO,CAAC;IACd,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC;IACrB,oBAAoB,CAAC,EAAE,UAAU,CAAC;IAClC,sBAAsB,CAAC,EAAE,UAAU,CAAC;CACrC;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAkErF;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAIrG"}