@noz-ele/edgca 0.1.0 → 0.2.0

package/README.md

@@ -9,15 +9,19 @@ The scope is intentionally narrow:
 - Create a self-signed root CA.
 - Issue an intermediate CA from a root CA.
 - Issue an mTLS client certificate and private key from an intermediate CA.
+- Issue an mTLS client certificate from a caller-provided public key (no private key returned). Pairs with the CSR helpers below.
+- Parse a PKCS#10 CSR (subject, requested SAN, public key, raw extensions/attributes) and verify its proof-of-possession signature.
 - Decide whether a received client certificate was issued by your own CA.
-- Encode/decode certificates and keys as PEM/DER.
+- Encode/decode certificates as PEM/DER. Keys are exchanged as `CryptoKey` only — the library never returns or accepts string forms (PEM, JWK, etc.) of private keys.
 - Delegate all cryptographic operations to `globalThis.crypto.subtle`.
 
+ECDSA on **NIST P-256, P-384, and P-521** is supported throughout (signing, verification, CSR parsing). RSA, EdDSA, and other curves are intentionally out of scope.
+
 > ⚠ **Not a PKI runtime.** EdgCA is an issuance toolkit, not a general-purpose PKI library or runtime. It does **not** provide chain validation, revocation (CRL/OCSP), key storage, or rotation. `verifyClientCertificateIssuedBy` is **not** mTLS verification and does **not** authenticate the presenter — see [Verify](#verify-cloudflare-worker) below. Operating a CA safely is the caller's responsibility. Full list: [docs/en/NON_GOALS.md](https://github.com/noz-ele/EdgCA/blob/main/docs/en/NON_GOALS.md).
 
 ## Status
 
-EdgCA is in **v0.1.x — early stabilization**. The author is currently validating the library against real Cloudflare Workers deployments, and the API surface may still shift. To keep that validation focused, **external Issues and PRs are temporarily restricted** and will be re-opened once the API settles. Reading, cloning, forking, and `npm install` are unaffected.
+EdgCA is in **v0.2.x — early stabilization**. The author is currently validating the library against real Cloudflare Workers deployments, and the API surface may still shift. To keep that validation focused, **external Issues and PRs are temporarily restricted** and will be re-opened once the API settles. Reading, cloning, forking, and `npm install` are unaffected.
 
 ## Install
 
@@ -57,10 +61,12 @@ const client = await issueClientCert({
 });
 
 // Persist these via your secrets manager / KV / vault.
-// Treat client.privateKeyPem as a secret — never log or transmit it.
+// `client.privateKey` is a CryptoKey. To persist it, export with
+// crypto.subtle.exportKey("pkcs8", client.privateKey) (or another form)
+// and treat the resulting bytes as a secret — never log or transmit them.
 //   client.certPem        — public certificate
 //   client.certChainPem   — full chain to present during mTLS
-//   client.privateKeyPem  — secret, hand off only over a trusted channel
+//   client.privateKey     — secret CryptoKey, hand off only over a trusted channel
 ```
 
 The basic shape is:
@@ -117,12 +123,22 @@ These parsers live in the caller, not in the library, because (a) we do not want
 ### Example
 
 ```ts
-import { importCertificateAuthority, verifyClientCertificateIssuedBy } from "@noz-ele/edgca";
+import { importCertificateAuthority, pemToDer, verifyClientCertificateIssuedBy } from "@noz-ele/edgca";
 
 // At Worker startup: import the CA loaded from your vault once.
+// The library accepts the private key as a CryptoKey only — convert from
+// whatever persistence format you use (PKCS#8 PEM, JWK, raw bytes, ...).
+const pkcs8Der = pemToDer(env.CA_PRIVATE_KEY_PEM);
+const privateKey = await crypto.subtle.importKey(
+  "pkcs8",
+  pkcs8Der,
+  { name: "ECDSA", namedCurve: "P-256" },
+  /* extractable */ false,
+  ["sign"]
+);
 const ca = await importCertificateAuthority({
   certPem: env.CA_CERT_PEM,
-  privateKeyPem: env.CA_PRIVATE_KEY_PEM
+  privateKey
 });
 
 export default {
@@ -169,6 +185,42 @@ export default {
 - "Not issued by us" and "outside the validity window" return `false`; malformed PEM/DER throws. The two error categories are deliberately split.
 - Pass the **direct issuer (one cert)** as `ca`. Verifying a leaf issued via an intermediate against the root will return `false` — chain walking is not performed.
 
+## Issue from a CSR
+
+When a client manages its own private key and submits a PKCS#10 CSR, EdgCA parses the CSR, verifies its proof-of-possession signature, and issues a certificate that embeds the CSR's public key. The library does **not** auto-adopt the CSR's claimed subject / SAN — the caller passes those explicitly, derived from whatever policy applies in the application layer.
+
+```ts
+import {
+  importCertificateAuthority,
+  issueClientCertForPublicKey,
+  parseCertificateSigningRequest,
+  verifyCertificateSigningRequestSignature
+} from "@noz-ele/edgca";
+
+const csr = await parseCertificateSigningRequest(csrPemFromClient);
+if (!await verifyCertificateSigningRequestSignature(csr)) {
+  return new Response("CSR proof-of-possession failed", { status: 400 });
+}
+
+// Application decides what subject and SAN to issue with. The CSR's claimed
+// values are available on csr.subject / csr.requestedDnsNames /
+// csr.requestedIpAddresses, but treating them as authoritative is a policy
+// decision that lives outside EdgCA.
+const issued = await issueClientCertForPublicKey({
+  ca,
+  publicKey: csr.publicKey,
+  subject: policyDerivedSubject,
+  days: 30,
+  dnsNames: policyDerivedDnsNames
+});
+// issued has certPem / certDer / certChainPem only — no privateKey, because
+// the client owns it.
+```
+
+CSRs signed with anything other than `ecdsa-with-SHA256` / `ecdsa-with-SHA384` / `ecdsa-with-SHA512` are rejected at parse time with an explicit error. CSR-level attributes other than `extensionRequest` are surfaced as raw DER under `csr.otherAttributes` for callers that need them; X.509 extensions other than SAN are surfaced under `csr.requestedExtensions` as `{ oid, critical, valueDer }` for caller-side decoding.
+
+POP verification proves only that whoever produced the CSR holds the matching private key. **It is not authorization.** Combine it with whatever transport-level (mTLS) and application-level checks make sense for your enrollment flow.
+
 ## Subject
 
 Subject only accepts a structured input. DN strings such as `CN=dev-root,O=Example` are not accepted.
@@ -194,13 +246,14 @@ Dotted OID strings are also accepted. The ASN.1 string type for values is fixed
 
 In scope:
 
-- ECDSA P-256 + SHA-256.
+- ECDSA on NIST P-256 / P-384 / P-521 (paired with SHA-256 / SHA-384 / SHA-512 respectively).
 - Key generation, signing, digest, and key import/export via WebCrypto.
 - Root CA creation.
 - Intermediate CA issuance.
-- mTLS client certificate issuance.
+- mTLS client certificate issuance (with internal key generation, or from a caller-provided public key).
+- CSR (PKCS#10) parsing and proof-of-possession signature verification.
 - Identity check that a cert was issued by your own CA (`verifyClientCertificateIssuedBy`, with optional time-validity check).
-- PEM/DER helpers.
+- PEM/DER helpers (certificates only — keys are exchanged as `CryptoKey`).
 - Basic Constraints, Key Usage, Extended Key Usage, Subject Alternative Name, SKI, AKI.
 
 Intentionally out of scope:
@@ -210,36 +263,64 @@ Intentionally out of scope:
 - Extracting time fields from a cert. `verifyClientCertificateIssuedBy`'s `validity` option performs the time check, but the `notBefore` / `notAfter` values are passed in by the caller from `cf.tlsClientAuth`.
 - CRL, OCSP, revocation databases, revocation checks.
 - Key storage, encryption-at-rest, rotation-state persistence, and integration with KV/D1/R2/Secrets.
-- RSA, EdDSA, other elliptic curves.
+- RSA, EdDSA, other elliptic curves (CSRs signed with these algorithms are rejected at parse time).
+- A general certificate parsing API (Cloudflare hands you parsed values via `cf.tlsClientAuth.cert*`; the library does not duplicate that).
+- Issuance policy decisions (whether to honor a CSR's claimed subject/SAN, deduplicate, etc.) — caller's responsibility.
 - DN string parsing.
 - Multi-valued RDNs.
 
 ## Key Handling
 
-This library returns private keys as PEM, so generated keys are extractable.
+EdgCA exchanges keys as `CryptoKey` only. The library never returns or accepts string forms (PEM, JWK, base64, ...) of private keys, so secret material does not live on the JS string heap at the library boundary. Internally generated keys are extractable so the caller can persist them by calling `crypto.subtle.exportKey` directly, but the choice of persistence format is the caller's.
 
-EdgCA only handles key generation and import/export. Where keys are stored, how they are encrypted at rest, how rotation state is persisted, and how they integrate with Cloudflare storage products are all the application's responsibility.
+EdgCA only handles key generation, signing, and SPKI export of public keys. Where keys are stored, how they are encrypted at rest, how rotation state is persisted, and how they integrate with Cloudflare storage products are all the application's responsibility.
 
 ### Bringing your own CA key (recommended)
 
-Root and intermediate CAs are long-lived. To keep key management on the caller's side, `createRootCA` and `issueIntermediateCA` accept an existing `privateKeyPem`. This lets the caller's key-management infrastructure handle the full key lifecycle (generation, storage, rotation) consistently, which is the recommended path.
+Root and intermediate CAs are long-lived. To keep key management on the caller's side, `createRootCA` and `issueIntermediateCA` accept an existing `keyPair: CryptoKeyPair`. This lets the caller's key-management infrastructure handle the full key lifecycle (generation, storage, rotation) consistently — including the choice of persistence format — which is the recommended path.
 
 ```ts
+// Restore a CryptoKeyPair from whatever persistence format you use.
+// Below is one example that converts PKCS#8 PEM stored in a vault.
+async function loadKeyPair(label: string): Promise<CryptoKeyPair> {
+  const pkcs8 = pemToDer(loadFromVault(`${label}-private-pem`));
+  const privateKey = await crypto.subtle.importKey(
+    "pkcs8",
+    pkcs8,
+    { name: "ECDSA", namedCurve: "P-256" },
+    /* extractable */ false,
+    ["sign"]
+  );
+  // Derive the matching public key. If you also persist the public key as
+  // SPKI, import that directly instead of round-tripping through JWK.
+  const jwk = await crypto.subtle.exportKey("jwk", privateKey);
+  delete jwk.d;
+  jwk.key_ops = ["verify"];
+  const publicKey = await crypto.subtle.importKey(
+    "jwk",
+    jwk,
+    { name: "ECDSA", namedCurve: "P-256" },
+    true,
+    ["verify"]
+  );
+  return { privateKey, publicKey };
+}
+
 const root = await createRootCA({
   subject: [{ type: "CN", value: "dev-root" }],
   days: 3650,
-  privateKeyPem: loadFromVault("root")    // PKCS#8 PEM already in your vault
+  keyPair: await loadKeyPair("root")
 });
 
 const intermediate = await issueIntermediateCA({
   ca: root,
   subject: [{ type: "CN", value: "dev-intermediate" }],
   days: 365,
-  privateKeyPem: loadFromVault("intermediate")
+  keyPair: await loadKeyPair("intermediate")
 });
 ```
 
-Omitting `privateKeyPem` causes the library to generate a key internally — convenient for tests and PoCs. Client-certificate keys are intended to be ephemeral, so `issueClientCert` always generates internally.
+Omitting `keyPair` causes the library to generate a key pair internally — convenient for tests and PoCs. Client-certificate keys are intended to be ephemeral, so `issueClientCert` always generates internally.
 
 ## Development
 
@@ -259,7 +340,7 @@ Round-trip invariants in the lower layers are expressed as `fast-check` property
 - [test/der.property.test.ts](https://github.com/noz-ele/EdgCA/blob/main/test/der.property.test.ts) — TLV round-trip for INTEGER / OID / OCTET STRING / BIT STRING / SEQUENCE
 - [test/bytes.property.test.ts](https://github.com/noz-ele/EdgCA/blob/main/test/bytes.property.test.ts) — `concatBytes`, `binaryToBytes`/`bytesToBinary`, `bytesEqual`, `cloneBytes`
 - [test/ip.property.test.ts](https://github.com/noz-ele/EdgCA/blob/main/test/ip.property.test.ts) — IPv4 dotted-quad and IPv6 (full form / `::` compression) encoding
-- [test/pem.property.test.ts](https://github.com/noz-ele/EdgCA/blob/main/test/pem.property.test.ts) — round-trip between `certificateToPem` / `privateKeyDerToPem` / `publicKeyDerToPem` and `pemToDer` / `pemToDerWithLabel` / `splitPemBlocks`
+- [test/pem.property.test.ts](https://github.com/noz-ele/EdgCA/blob/main/test/pem.property.test.ts) — round-trip between `certificateToPem` and `pemToDer` / `pemToDerWithLabel` / `splitPemBlocks`
 
 `vitest.config.ts` includes `test/**/*.test.ts`, so `npm run test` runs them all together. The certificate-assembly layer (`ca.ts` / `x509.ts`) is intentionally outside the PBT scope and stays example-based in [test/edgca.test.ts](https://github.com/noz-ele/EdgCA/blob/main/test/edgca.test.ts).
 

package/dist/ca.d.ts

@@ -1,6 +1,7 @@
-import type { CertificateAuthority, CreateRootCAOptions, ImportCertificateAuthorityOptions, IssueClientCertOptions, IssueIntermediateCAOptions, IssuedClientCertificate } from "./types.js";
+import type { CertificateAuthority, CreateRootCAOptions, ImportCertificateAuthorityOptions, IssueClientCertForPublicKeyOptions, IssueClientCertOptions, IssueIntermediateCAOptions, IssuedClientCertificate, IssuedClientCertificateForPublicKey } from "./types.js";
 export declare function createRootCA(options: CreateRootCAOptions): Promise<CertificateAuthority>;
 export declare function issueIntermediateCA(options: IssueIntermediateCAOptions): Promise<CertificateAuthority>;
 export declare function issueClientCert(options: IssueClientCertOptions): Promise<IssuedClientCertificate>;
+export declare function issueClientCertForPublicKey(options: IssueClientCertForPublicKeyOptions): Promise<IssuedClientCertificateForPublicKey>;
 export declare function importCertificateAuthority(options: ImportCertificateAuthorityOptions): Promise<CertificateAuthority>;
 //# sourceMappingURL=ca.d.ts.map

package/dist/ca.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ca.d.ts","sourceRoot":"","sources":["../src/ca.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,iCAAiC,EACjC,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAapB,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAwB9F;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA8B5G;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAyCvG;AAED,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,iCAAiC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAkB1H"}
+{"version":3,"file":"ca.d.ts","sourceRoot":"","sources":["../src/ca.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,iCAAiC,EACjC,kCAAkC,EAClC,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACvB,mCAAmC,EAEpC,MAAM,YAAY,CAAC;AAapB,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA0B9F;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAgC5G;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAqBvG;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,kCAAkC,GAC1C,OAAO,CAAC,mCAAmC,CAAC,CAkB9C;AAuDD,wBAAsB,0BAA0B,CAAC,OAAO,EAAE,iCAAiC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAe1H"}

package/dist/ca.js

@@ -1,11 +1,12 @@
 import { bytesEqual, cloneBytes } from "./bytes.js";
-import { assertKeyPairMatches, exportSpki, generateKeyPair, importPrivateKeyPem, keyIdentifierFromSpki, keyPairFromPrivateKeyPem, privateKeyToPem, publicKeyToPem, signDer } from "./crypto.js";
+import { assertKeyPairMatches, curveOf, exportSpki, generateKeyPair, keyIdentifierFromSpki, signDer } from "./crypto.js";
 import { encodeName } from "./name.js";
 import { certificateToPem, pemToDer, pemToDerWithLabel, splitPemBlocks } from "./pem.js";
 import { parseCertificateDer } from "./parser.js";
 import { authorityKeyIdentifierExtension, basicConstraintsCaExtension, basicConstraintsLeafExtension, buildCertificate, buildTbsCertificate, extendedKeyUsageClientAuthExtension, keyUsageExtension, subjectAltNameExtension, subjectKeyIdentifierExtension } from "./x509.js";
 export async function createRootCA(options) {
-    const keyPair = await resolveKeyPair(options.privateKeyPem);
+    const keyPair = await resolveKeyPair(options.keyPair);
+    const issuerCurve = curveOf(keyPair.privateKey);
     const subjectNameDer = encodeName(options.subject);
     const spki = await exportSpki(keyPair.publicKey);
     const keyIdentifier = await keyIdentifierFromSpki(spki);
@@ -23,10 +24,11 @@ export async function createRootCA(options) {
         issuerNameDer: subjectNameDer,
         subjectNameDer,
         subjectPublicKeyInfoDer: spki,
-        extensions
+        extensions,
+        issuerCurve
     });
     const signatureDer = await signDer(keyPair.privateKey, tbsCertificateDer);
-    const certDer = buildCertificate(tbsCertificateDer, signatureDer);
+    const certDer = buildCertificate(tbsCertificateDer, signatureDer, issuerCurve);
     return assembleCertificateAuthority(certDer, keyPair, "");
 }
 export async function issueIntermediateCA(options) {
@@ -34,7 +36,8 @@ export async function issueIntermediateCA(options) {
     const issuerChainPem = options.ca.issuerChainPem;
     assertCanIssueCertificate(issuer);
     assertCanIssueIntermediate(issuer, issuerChainPem, options.pathLenConstraint);
-    const keyPair = await resolveKeyPair(options.privateKeyPem);
+    const issuerCurve = curveOf(options.ca.privateKey);
+    const keyPair = await resolveKeyPair(options.keyPair);
     const subjectNameDer = encodeName(options.subject);
     const spki = await exportSpki(keyPair.publicKey);
     const subjectKeyIdentifier = await keyIdentifierFromSpki(spki);
@@ -52,23 +55,57 @@ export async function issueIntermediateCA(options) {
         issuerNameDer: issuer.subjectNameDer,
         subjectNameDer,
         subjectPublicKeyInfoDer: spki,
-        extensions
+        extensions,
+        issuerCurve
     });
     const signatureDer = await signDer(options.ca.privateKey, tbsCertificateDer);
-    const certDer = buildCertificate(tbsCertificateDer, signatureDer);
+    const certDer = buildCertificate(tbsCertificateDer, signatureDer, issuerCurve);
     const childChainPem = joinPemChain([options.ca.certPem, issuerChainPem]);
     return assembleCertificateAuthority(certDer, keyPair, childChainPem);
 }
 export async function issueClientCert(options) {
-    const issuer = await parseIssuer(options.ca);
-    const issuerChainPem = options.ca.issuerChainPem;
-    assertCanIssueCertificate(issuer);
     const keyPair = await generateKeyPair();
-    const subjectNameDer = encodeName(options.subject);
-    const spki = await exportSpki(keyPair.publicKey);
+    const built = await buildClientCertificate(options.ca, keyPair.publicKey, {
+        subject: options.subject,
+        days: options.days,
+        notBefore: options.notBefore,
+        serialNumber: options.serialNumber,
+        dnsNames: options.dnsNames,
+        ipAddresses: options.ipAddresses
+    });
+    return {
+        certPem: built.certPem,
+        certDer: built.certDer,
+        privateKey: keyPair.privateKey,
+        publicKey: keyPair.publicKey,
+        certChainPem: built.certChainPem
+    };
+}
+export async function issueClientCertForPublicKey(options) {
+    const built = await buildClientCertificate(options.ca, options.publicKey, {
+        subject: options.subject,
+        days: options.days,
+        notBefore: options.notBefore,
+        serialNumber: options.serialNumber,
+        dnsNames: options.dnsNames,
+        ipAddresses: options.ipAddresses
+    });
+    return {
+        certPem: built.certPem,
+        certDer: built.certDer,
+        certChainPem: built.certChainPem
+    };
+}
+async function buildClientCertificate(ca, subjectPublicKey, content) {
+    const issuer = await parseIssuer(ca);
+    const issuerChainPem = ca.issuerChainPem;
+    assertCanIssueCertificate(issuer);
+    const issuerCurve = curveOf(ca.privateKey);
+    const subjectNameDer = encodeName(content.subject);
+    const spki = await exportSpki(subjectPublicKey);
     const subjectKeyIdentifier = await keyIdentifierFromSpki(spki);
     const authorityKeyIdentifier = issuer.subjectKeyIdentifier ?? await keyIdentifierFromSpki(issuer.subjectPublicKeyInfoDer);
-    const san = subjectAltNameExtension(options.dnsNames, options.ipAddresses);
+    const san = subjectAltNameExtension(content.dnsNames, content.ipAddresses);
     const extensions = [
         basicConstraintsLeafExtension(),
         keyUsageExtension(["digitalSignature"]),
@@ -78,25 +115,22 @@ export async function issueClientCert(options) {
         ...(san ? [san] : [])
     ];
     const { tbsCertificateDer } = buildTbsCertificate({
-        serialNumber: options.serialNumber,
-        notBefore: options.notBefore,
-        days: options.days,
+        serialNumber: content.serialNumber,
+        notBefore: content.notBefore,
+        days: content.days,
         issuerNameDer: issuer.subjectNameDer,
         subjectNameDer,
         subjectPublicKeyInfoDer: spki,
-        extensions
+        extensions,
+        issuerCurve
     });
-    const signatureDer = await signDer(options.ca.privateKey, tbsCertificateDer);
-    const certDer = buildCertificate(tbsCertificateDer, signatureDer);
+    const signatureDer = await signDer(ca.privateKey, tbsCertificateDer);
+    const certDer = buildCertificate(tbsCertificateDer, signatureDer, issuerCurve);
     const certPem = certificateToPem(certDer);
     return {
         certPem,
-        privateKeyPem: await privateKeyToPem(keyPair.privateKey),
-        publicKeyPem: await publicKeyToPem(keyPair.publicKey),
         certDer: cloneBytes(certDer),
-        privateKey: keyPair.privateKey,
-        publicKey: keyPair.publicKey,
-        certChainPem: joinPemChain([certPem, options.ca.certPem, issuerChainPem])
+        certChainPem: joinPemChain([certPem, ca.certPem, issuerChainPem])
     };
 }
 export async function importCertificateAuthority(options) {
@@ -104,14 +138,11 @@ export async function importCertificateAuthority(options) {
     assertIssuerChainPem(issuerChainPem);
     const certDer = pemToDerWithLabel(options.certPem, "CERTIFICATE");
     const parsed = await parseCertificateDer(certDer);
-    const privateKey = await importPrivateKeyPem(options.privateKeyPem);
-    await assertKeyPairMatches(privateKey, parsed.publicKey);
+    await assertKeyPairMatches(options.privateKey, parsed.publicKey);
     return {
         certPem: options.certPem,
-        privateKeyPem: options.privateKeyPem,
-        publicKeyPem: await publicKeyToPem(parsed.publicKey),
         certDer: cloneBytes(certDer),
-        privateKey,
+        privateKey: options.privateKey,
         publicKey: parsed.publicKey,
         issuerChainPem
     };
@@ -128,17 +159,15 @@ function assertIssuerChainPem(chainPem) {
         pemToDerWithLabel(block, "CERTIFICATE");
     }
 }
-async function resolveKeyPair(privateKeyPem) {
-    if (privateKeyPem !== undefined) {
-        return keyPairFromPrivateKeyPem(privateKeyPem);
+async function resolveKeyPair(provided) {
+    if (provided !== undefined) {
+        return provided;
     }
     return generateKeyPair();
 }
 async function assembleCertificateAuthority(certDer, keyPair, issuerChainPem) {
     return {
         certPem: certificateToPem(certDer),
-        privateKeyPem: await privateKeyToPem(keyPair.privateKey),
-        publicKeyPem: await publicKeyToPem(keyPair.publicKey),
         certDer: cloneBytes(certDer),
         privateKey: keyPair.privateKey,
         publicKey: keyPair.publicKey,

package/dist/crypto.d.ts

@@ -1,16 +1,16 @@
-export declare function generateKeyPair(): Promise<CryptoKeyPair>;
+export type SupportedCurve = "P-256" | "P-384" | "P-521";
+export declare function curveOf(key: CryptoKey): SupportedCurve;
+export declare function componentSizeForCurve(curve: SupportedCurve): number;
+export declare function signatureAlgorithmOidForCurve(curve: SupportedCurve): string;
+export declare function generateKeyPair(curve?: SupportedCurve): Promise<CryptoKeyPair>;
 export declare function signDer(privateKey: CryptoKey, data: Uint8Array): Promise<Uint8Array>;
 export declare function verifyDer(publicKey: CryptoKey, signatureDer: Uint8Array, data: Uint8Array): Promise<boolean>;
 export declare function digestSha256(data: Uint8Array): Promise<Uint8Array>;
 export declare function digestSha1(data: Uint8Array): Promise<Uint8Array>;
 export declare function keyIdentifierFromSpki(spki: Uint8Array): Promise<Uint8Array>;
-export declare function privateKeyToPem(key: CryptoKey): Promise<string>;
-export declare function publicKeyToPem(key: CryptoKey): Promise<string>;
 export declare function exportSpki(key: CryptoKey): Promise<Uint8Array>;
-export declare function importPrivateKeyPem(pem: string): Promise<CryptoKey>;
-export declare function keyPairFromPrivateKeyPem(pem: string): Promise<CryptoKeyPair>;
 export declare function importPublicKeySpki(spki: Uint8Array): Promise<CryptoKey>;
 export declare function assertKeyPairMatches(privateKey: CryptoKey, publicKey: CryptoKey): Promise<void>;
-export declare function ecdsaRawToDer(raw: Uint8Array): Uint8Array;
-export declare function ecdsaDerToRaw(signature: Uint8Array): Uint8Array;
+export declare function ecdsaRawToDer(raw: Uint8Array, componentSize: number): Uint8Array;
+export declare function ecdsaDerToRaw(signature: Uint8Array, componentSize: number): Uint8Array;
 //# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAcA,wBAAsB,eAAe,IAAI,OAAO,CAAC,aAAa,CAAC,CAE9D;AAED,wBAAsB,OAAO,CAAC,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAG1F;AAED,wBAAsB,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAOlH;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAExE;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAEtE;AAID,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAWjF;AAED,wBAAsB,eAAe,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAGrE;AAED,wBAAsB,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAGpE;AAED,wBAAsB,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAEpE;AAED,wBAAsB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAEzE;AAED,wBAAsB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAOlF;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAE9E;AAED,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAQrG;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,UAAU,CAMzD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU,CAY/D"}
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAkCzD,wBAAgB,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,cAAc,CAUtD;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAEnE;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAE3E;AAED,wBAAsB,eAAe,CAAC,KAAK,GAAE,cAAwB,GAAG,OAAO,CAAC,aAAa,CAAC,CAE7F;AAED,wBAAsB,OAAO,CAAC,UAAU,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAO1F;AAED,wBAAsB,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CASlH;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAExE;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAEtE;AAID,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAWjF;AAED,wBAAsB,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAEpE;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAS9E;AAkCD,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAQrG;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,GAAG,UAAU,CAMhF;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,GAAG,UAAU,CAetF"}

package/dist/crypto.js

@@ -1,23 +1,61 @@
 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"
+import { decodeOid, integer, readChildren, readElement, readSequenceChildren, sequence, TAG } from "./der.js";
+import { OID } from "./oids.js";
+const CURVE_PROFILE = {
+    "P-256": {
+        componentSize: 32,
+        hash: "SHA-256",
+        signatureAlgorithmOid: OID.ecdsaWithSha256,
+        curveOid: OID.secp256r1
+    },
+    "P-384": {
+        componentSize: 48,
+        hash: "SHA-384",
+        signatureAlgorithmOid: OID.ecdsaWithSha384,
+        curveOid: OID.secp384r1
+    },
+    "P-521": {
+        componentSize: 66,
+        hash: "SHA-512",
+        signatureAlgorithmOid: OID.ecdsaWithSha512,
+        curveOid: OID.secp521r1
+    }
 };
-const ECDSA_SIGN_ALGORITHM = {
-    name: "ECDSA",
-    hash: "SHA-256"
+const CURVE_OID_TO_NAME = {
+    [OID.secp256r1]: "P-256",
+    [OID.secp384r1]: "P-384",
+    [OID.secp521r1]: "P-521"
 };
-export async function generateKeyPair() {
-    return crypto.subtle.generateKey(EC_ALGORITHM, true, ["sign", "verify"]);
+export function curveOf(key) {
+    const algorithm = key.algorithm;
+    if (algorithm.name !== "ECDSA") {
+        throw new Error(`Expected ECDSA key, got ${algorithm.name}`);
+    }
+    const curve = algorithm.namedCurve;
+    if (curve !== "P-256" && curve !== "P-384" && curve !== "P-521") {
+        throw new Error(`Unsupported ECDSA curve: ${curve}`);
+    }
+    return curve;
+}
+export function componentSizeForCurve(curve) {
+    return CURVE_PROFILE[curve].componentSize;
+}
+export function signatureAlgorithmOidForCurve(curve) {
+    return CURVE_PROFILE[curve].signatureAlgorithmOid;
+}
+export async function generateKeyPair(curve = "P-256") {
+    return crypto.subtle.generateKey({ name: "ECDSA", namedCurve: curve }, 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);
+    const curve = curveOf(privateKey);
+    const profile = CURVE_PROFILE[curve];
+    const raw = new Uint8Array(await crypto.subtle.sign({ name: "ECDSA", hash: profile.hash }, privateKey, arrayBufferFromBytes(data)));
+    return ecdsaRawToDer(raw, profile.componentSize);
 }
 export async function verifyDer(publicKey, signatureDer, data) {
-    return crypto.subtle.verify(ECDSA_SIGN_ALGORITHM, publicKey, arrayBufferFromBytes(ecdsaDerToRaw(signatureDer)), arrayBufferFromBytes(data));
+    const curve = curveOf(publicKey);
+    const profile = CURVE_PROFILE[curve];
+    return crypto.subtle.verify({ name: "ECDSA", hash: profile.hash }, publicKey, arrayBufferFromBytes(ecdsaDerToRaw(signatureDer, profile.componentSize)), arrayBufferFromBytes(data));
 }
 export async function digestSha256(data) {
     return new Uint8Array(await crypto.subtle.digest("SHA-256", arrayBufferFromBytes(data)));
@@ -39,30 +77,43 @@ export async function keyIdentifierFromSpki(spki) {
     }
     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"]);
+    const curve = curveFromSpki(spki);
+    return crypto.subtle.importKey("spki", arrayBufferFromBytes(spki), { name: "ECDSA", namedCurve: curve }, true, ["verify"]);
+}
+// SubjectPublicKeyInfo ::= SEQUENCE { algorithm AlgorithmIdentifier, subjectPublicKey BIT STRING }
+// AlgorithmIdentifier ::= SEQUENCE { algorithm OBJECT IDENTIFIER, parameters ANY }
+// For EC keys, parameters is the named-curve OID.
+function curveFromSpki(spki) {
+    const root = readElement(spki);
+    if (root.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid SubjectPublicKeyInfo");
+    }
+    const algorithm = readSequenceChildren(root)[0];
+    if (!algorithm || algorithm.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid SubjectPublicKeyInfo algorithm");
+    }
+    const algorithmChildren = readSequenceChildren(algorithm);
+    const algorithmOidElement = algorithmChildren[0];
+    const parametersElement = algorithmChildren[1];
+    if (!algorithmOidElement || algorithmOidElement.tag !== TAG.OBJECT_IDENTIFIER) {
+        throw new Error("Invalid SubjectPublicKeyInfo algorithm OID");
+    }
+    if (decodeOid(algorithmOidElement.value) !== OID.ecPublicKey) {
+        throw new Error("SubjectPublicKeyInfo is not an EC public key");
+    }
+    if (!parametersElement || parametersElement.tag !== TAG.OBJECT_IDENTIFIER) {
+        throw new Error("EC SubjectPublicKeyInfo parameters must be a named-curve OID");
+    }
+    const curveOid = decodeOid(parametersElement.value);
+    const curve = CURVE_OID_TO_NAME[curveOid];
+    if (!curve) {
+        throw new Error(`Unsupported EC named curve OID: ${curveOid}`);
+    }
+    return curve;
 }
 export async function assertKeyPairMatches(privateKey, publicKey) {
     const data = new TextEncoder().encode("edgca-key-pair-check");
@@ -72,13 +123,13 @@ export async function assertKeyPairMatches(privateKey, publicKey) {
         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");
+export function ecdsaRawToDer(raw, componentSize) {
+    if (raw.length !== componentSize * 2) {
+        throw new Error(`ECDSA raw signature must be ${componentSize * 2} bytes`);
     }
-    return sequence(integer(raw.subarray(0, 32)), integer(raw.subarray(32)));
+    return sequence(integer(raw.subarray(0, componentSize)), integer(raw.subarray(componentSize)));
 }
-export function ecdsaDerToRaw(signature) {
+export function ecdsaDerToRaw(signature, componentSize) {
     const root = readElement(signature);
     if (root.tag !== TAG.SEQUENCE || root.end !== signature.length) {
         throw new Error("Invalid DER ECDSA signature");
@@ -87,18 +138,21 @@ export function ecdsaDerToRaw(signature) {
     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)]);
+    return concatBytes([
+        integerToFixedWidth(r.value, componentSize),
+        integerToFixedWidth(s.value, componentSize)
+    ]);
 }
-function integerToFixedWidth(value) {
+function integerToFixedWidth(value, size) {
     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");
+    if (trimmed.length > size) {
+        throw new Error(`ECDSA integer is wider than ${size} bytes`);
     }
-    const out = new Uint8Array(32);
-    out.set(trimmed, 32 - trimmed.length);
+    const out = new Uint8Array(size);
+    out.set(trimmed, size - trimmed.length);
     return out;
 }

package/dist/csr.d.ts

@@ -0,0 +1,25 @@
+import type { Subject } from "./types.js";
+export interface CertificateSigningRequestExtension {
+    oid: string;
+    critical: boolean;
+    valueDer: Uint8Array;
+}
+export interface CertificateSigningRequestAttribute {
+    oid: string;
+    valuesDer: ReadonlyArray<Uint8Array>;
+}
+export interface ParsedCertificateSigningRequest {
+    subject: Subject;
+    publicKey: CryptoKey;
+    subjectPublicKeyInfoDer: Uint8Array;
+    requestedDnsNames: readonly string[];
+    requestedIpAddresses: readonly string[];
+    requestedExtensions: readonly CertificateSigningRequestExtension[];
+    otherAttributes: readonly CertificateSigningRequestAttribute[];
+    signatureAlgorithmOid: string;
+    signatureDer: Uint8Array;
+    certificationRequestInfoDer: Uint8Array;
+}
+export declare function parseCertificateSigningRequest(input: string | Uint8Array): Promise<ParsedCertificateSigningRequest>;
+export declare function verifyCertificateSigningRequestSignature(csr: ParsedCertificateSigningRequest): Promise<boolean>;
+//# sourceMappingURL=csr.d.ts.map

package/dist/csr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csr.d.ts","sourceRoot":"","sources":["../src/csr.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAwB,MAAM,YAAY,CAAC;AAkBhE,MAAM,WAAW,kCAAkC;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC;CACtB;AAED,MAAM,WAAW,kCAAkC;IACjD,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,+BAA+B;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,SAAS,CAAC;IACrB,uBAAuB,EAAE,UAAU,CAAC;IACpC,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,oBAAoB,EAAE,SAAS,MAAM,EAAE,CAAC;IACxC,mBAAmB,EAAE,SAAS,kCAAkC,EAAE,CAAC;IACnE,eAAe,EAAE,SAAS,kCAAkC,EAAE,CAAC;IAC/D,qBAAqB,EAAE,MAAM,CAAC;IAC9B,YAAY,EAAE,UAAU,CAAC;IACzB,2BAA2B,EAAE,UAAU,CAAC;CACzC;AAED,wBAAsB,8BAA8B,CAClD,KAAK,EAAE,MAAM,GAAG,UAAU,GACzB,OAAO,CAAC,+BAA+B,CAAC,CAwE1C;AAED,wBAAsB,wCAAwC,CAC5D,GAAG,EAAE,+BAA+B,GACnC,OAAO,CAAC,OAAO,CAAC,CAElB"}

package/dist/csr.js

@@ -0,0 +1,266 @@
+import { cloneBytes } from "./bytes.js";
+import { importPublicKeySpki, verifyDer } from "./crypto.js";
+import { decodeInteger, decodeOid, readChildren, readElement, readSequenceChildren, TAG } from "./der.js";
+import { OID, SUBJECT_ATTRIBUTE_OIDS } from "./oids.js";
+import { pemToDerWithLabel, splitPemBlocks } from "./pem.js";
+const SHORT_NAME_BY_OID = Object.fromEntries(Object.entries(SUBJECT_ATTRIBUTE_OIDS).map(([shortName, oid]) => [oid, shortName]));
+const VALUE_DECODERS = new Map([
+    [TAG.UTF8_STRING, (b) => new TextDecoder("utf-8", { fatal: true }).decode(b)],
+    [TAG.PRINTABLE_STRING, (b) => decodeAscii(b, "PrintableString")],
+    [TAG.IA5_STRING, (b) => decodeAscii(b, "IA5String")]
+]);
+const SUPPORTED_SIGNATURE_OIDS = new Set([
+    OID.ecdsaWithSha256,
+    OID.ecdsaWithSha384,
+    OID.ecdsaWithSha512
+]);
+export async function parseCertificateSigningRequest(input) {
+    const der = typeof input === "string" ? csrPemToDer(input) : input;
+    const root = readElement(der);
+    if (root.tag !== TAG.SEQUENCE || root.end !== der.length) {
+        throw new Error("Invalid CSR DER");
+    }
+    const [requestInfo, signatureAlgorithm, signatureValue] = readSequenceChildren(root);
+    if (!requestInfo || !signatureAlgorithm || !signatureValue) {
+        throw new Error("Invalid CSR structure");
+    }
+    if (requestInfo.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid CSR certificationRequestInfo");
+    }
+    if (signatureAlgorithm.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid CSR signatureAlgorithm");
+    }
+    if (signatureValue.tag !== TAG.BIT_STRING || signatureValue.value[0] !== 0) {
+        throw new Error("Invalid CSR signature value");
+    }
+    const signatureAlgorithmOid = readAlgorithmOid(signatureAlgorithm);
+    if (!SUPPORTED_SIGNATURE_OIDS.has(signatureAlgorithmOid)) {
+        throw new Error(`Unsupported CSR signatureAlgorithm: ${signatureAlgorithmOid}`);
+    }
+    const infoChildren = readSequenceChildren(requestInfo);
+    const versionElement = infoChildren[0];
+    const subjectElement = infoChildren[1];
+    const spkiElement = infoChildren[2];
+    const attributesElement = infoChildren[3];
+    if (!versionElement || !subjectElement || !spkiElement) {
+        throw new Error("Invalid CSR certificationRequestInfo structure");
+    }
+    if (versionElement.tag !== TAG.INTEGER || decodeInteger(versionElement.value) !== 0n) {
+        throw new Error("Unsupported CSR version (only v1 / INTEGER 0 is supported)");
+    }
+    if (spkiElement.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid CSR subjectPublicKeyInfo");
+    }
+    if (attributesElement && attributesElement.tag !== 0xa0) {
+        throw new Error("Invalid CSR attributes tag (must be IMPLICIT [0])");
+    }
+    const subject = decodeName(subjectElement);
+    const publicKey = await importPublicKeySpki(spkiElement.raw);
+    const allAttributes = attributesElement ? decodeAttributes(attributesElement.value) : [];
+    const extensionRequest = allAttributes.find((attribute) => attribute.oid === OID.extensionRequest);
+    const otherAttributes = allAttributes.filter((attribute) => attribute.oid !== OID.extensionRequest);
+    const requestedExtensions = extensionRequest
+        ? decodeRequestedExtensions(extensionRequest.valuesDer)
+        : [];
+    const sanExtension = requestedExtensions.find((extension) => extension.oid === OID.subjectAltName);
+    const { dnsNames, ipAddresses } = sanExtension
+        ? decodeSubjectAltName(sanExtension.valueDer)
+        : { dnsNames: [], ipAddresses: [] };
+    return {
+        subject,
+        publicKey,
+        subjectPublicKeyInfoDer: cloneBytes(spkiElement.raw),
+        requestedDnsNames: dnsNames,
+        requestedIpAddresses: ipAddresses,
+        requestedExtensions,
+        otherAttributes,
+        signatureAlgorithmOid,
+        signatureDer: cloneBytes(signatureValue.value.subarray(1)),
+        certificationRequestInfoDer: cloneBytes(requestInfo.raw)
+    };
+}
+export async function verifyCertificateSigningRequestSignature(csr) {
+    return verifyDer(csr.publicKey, csr.signatureDer, csr.certificationRequestInfoDer);
+}
+function csrPemToDer(pem) {
+    // RFC 7468 §7 uses "CERTIFICATE REQUEST"; some legacy tools emit "NEW CERTIFICATE REQUEST".
+    const blocks = splitPemBlocks(pem);
+    for (const block of blocks) {
+        const labelMatch = /-----BEGIN (.+?)-----/.exec(block);
+        const label = labelMatch?.[1];
+        if (label === "CERTIFICATE REQUEST" || label === "NEW CERTIFICATE REQUEST") {
+            return pemToDerWithLabel(block, label);
+        }
+    }
+    throw new Error("Invalid CSR PEM: expected CERTIFICATE REQUEST or NEW CERTIFICATE REQUEST block");
+}
+function readAlgorithmOid(algorithm) {
+    const children = readSequenceChildren(algorithm);
+    const oidElement = children[0];
+    if (!oidElement || oidElement.tag !== TAG.OBJECT_IDENTIFIER) {
+        throw new Error("Invalid AlgorithmIdentifier OID");
+    }
+    return decodeOid(oidElement.value);
+}
+function decodeName(nameElement) {
+    if (nameElement.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid Name structure");
+    }
+    const subject = [];
+    for (const rdn of readSequenceChildren(nameElement)) {
+        if (rdn.tag !== TAG.SET) {
+            throw new Error("Invalid RDN (expected SET)");
+        }
+        const attributes = readChildren(rdn.value);
+        if (attributes.length !== 1) {
+            throw new Error("Multi-valued RDNs are not supported");
+        }
+        const attribute = attributes[0];
+        if (attribute.tag !== TAG.SEQUENCE) {
+            throw new Error("Invalid AttributeTypeAndValue");
+        }
+        const [oidElement, valueElement] = readSequenceChildren(attribute);
+        if (!oidElement || !valueElement || oidElement.tag !== TAG.OBJECT_IDENTIFIER) {
+            throw new Error("Invalid AttributeTypeAndValue contents");
+        }
+        const attributeOid = decodeOid(oidElement.value);
+        const decoder = VALUE_DECODERS.get(valueElement.tag);
+        if (!decoder) {
+            throw new Error(`Unsupported AttributeValue string type: tag 0x${valueElement.tag.toString(16)}`);
+        }
+        const value = decoder(valueElement.value);
+        const shortName = SHORT_NAME_BY_OID[attributeOid];
+        subject.push({
+            type: shortName ?? attributeOid,
+            value
+        });
+    }
+    return subject;
+}
+function decodeAttributes(value) {
+    const attributes = [];
+    for (const attribute of readChildren(value)) {
+        if (attribute.tag !== TAG.SEQUENCE) {
+            throw new Error("Invalid CSR attribute");
+        }
+        const children = readSequenceChildren(attribute);
+        const oidElement = children[0];
+        const valuesElement = children[1];
+        if (!oidElement || oidElement.tag !== TAG.OBJECT_IDENTIFIER) {
+            throw new Error("Invalid CSR attribute OID");
+        }
+        if (!valuesElement || valuesElement.tag !== TAG.SET) {
+            throw new Error("Invalid CSR attribute values (expected SET)");
+        }
+        const valuesDer = readChildren(valuesElement.value).map((value) => cloneBytes(value.raw));
+        attributes.push({
+            oid: decodeOid(oidElement.value),
+            valuesDer
+        });
+    }
+    return attributes;
+}
+function decodeRequestedExtensions(valuesDer) {
+    if (valuesDer.length !== 1) {
+        throw new Error("extensionRequest attribute must contain exactly one SEQUENCE OF Extension");
+    }
+    const outer = readElement(valuesDer[0]);
+    if (outer.tag !== TAG.SEQUENCE) {
+        throw new Error("extensionRequest value must be a SEQUENCE OF Extension");
+    }
+    const extensions = [];
+    for (const extension of readSequenceChildren(outer)) {
+        if (extension.tag !== TAG.SEQUENCE) {
+            throw new Error("Invalid Extension");
+        }
+        const children = readSequenceChildren(extension);
+        const oidElement = children[0];
+        if (!oidElement || oidElement.tag !== TAG.OBJECT_IDENTIFIER) {
+            throw new Error("Invalid Extension OID");
+        }
+        let cursor = 1;
+        let critical = false;
+        if (children[cursor]?.tag === TAG.BOOLEAN) {
+            critical = children[cursor].value[0] !== 0;
+            cursor += 1;
+        }
+        const valueElement = children[cursor];
+        if (!valueElement || valueElement.tag !== TAG.OCTET_STRING) {
+            throw new Error("Invalid Extension value");
+        }
+        extensions.push({
+            oid: decodeOid(oidElement.value),
+            critical,
+            valueDer: cloneBytes(valueElement.value)
+        });
+    }
+    return extensions;
+}
+function decodeSubjectAltName(value) {
+    const root = readElement(value);
+    if (root.tag !== TAG.SEQUENCE) {
+        throw new Error("Invalid SubjectAltName extension");
+    }
+    const dnsNames = [];
+    const ipAddresses = [];
+    for (const generalName of readChildren(root.value)) {
+        if (generalName.tag === 0x82) {
+            dnsNames.push(decodeAscii(generalName.value, "SAN dNSName"));
+        }
+        else if (generalName.tag === 0x87) {
+            ipAddresses.push(formatIpAddress(generalName.value));
+        }
+    }
+    return { dnsNames, ipAddresses };
+}
+function decodeAscii(bytes, label) {
+    for (const byte of bytes) {
+        if (byte > 0x7f) {
+            throw new Error(`${label} contains a non-ASCII byte`);
+        }
+    }
+    return new TextDecoder("ascii").decode(bytes);
+}
+function formatIpAddress(bytes) {
+    if (bytes.length === 4) {
+        return Array.from(bytes).join(".");
+    }
+    if (bytes.length === 16) {
+        const groups = [];
+        for (let i = 0; i < 16; i += 2) {
+            groups.push(((bytes[i] << 8) | bytes[i + 1]).toString(16));
+        }
+        return compressIpv6(groups);
+    }
+    throw new Error(`Invalid SAN iPAddress length: ${bytes.length}`);
+}
+// RFC 5952: collapse the longest run of consecutive "0" groups (length ≥ 2) into "::".
+function compressIpv6(groups) {
+    let bestStart = -1;
+    let bestLength = 0;
+    let currentStart = -1;
+    let currentLength = 0;
+    for (let i = 0; i < groups.length; i += 1) {
+        if (groups[i] === "0") {
+            if (currentStart === -1) {
+                currentStart = i;
+                currentLength = 0;
+            }
+            currentLength += 1;
+            if (currentLength > bestLength) {
+                bestStart = currentStart;
+                bestLength = currentLength;
+            }
+        }
+        else {
+            currentStart = -1;
+            currentLength = 0;
+        }
+    }
+    if (bestLength < 2) {
+        return groups.join(":");
+    }
+    const head = groups.slice(0, bestStart).join(":");
+    const tail = groups.slice(bestStart + bestLength).join(":");
+    return `${head}::${tail}`;
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { createRootCA, importCertificateAuthority, issueClientCert, issueIntermediateCA } from "./ca.js";
+export { createRootCA, importCertificateAuthority, issueClientCert, issueClientCertForPublicKey, issueIntermediateCA } from "./ca.js";
+export { parseCertificateSigningRequest, verifyCertificateSigningRequestSignature, type ParsedCertificateSigningRequest, type CertificateSigningRequestExtension, type CertificateSigningRequestAttribute } from "./csr.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";
+export type { CertificateAuthority, CreateRootCAOptions, ImportCertificateAuthorityOptions, IssueClientCertForPublicKeyOptions, IssueClientCertOptions, IssueIntermediateCAOptions, IssuedClientCertificate, IssuedClientCertificateForPublicKey, SerialNumber, ShortSubjectAttributeType, Subject, SubjectAttribute, SubjectAttributeType } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,0BAA0B,EAC1B,eAAe,EACf,2BAA2B,EAC3B,mBAAmB,EACpB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,8BAA8B,EAC9B,wCAAwC,EACxC,KAAK,+BAA+B,EACpC,KAAK,kCAAkC,EACvC,KAAK,kCAAkC,EACxC,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AACtD,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,kCAAkC,EAClC,sBAAsB,EACtB,0BAA0B,EAC1B,uBAAuB,EACvB,mCAAmC,EACnC,YAAY,EACZ,yBAAyB,EACzB,OAAO,EACP,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,YAAY,CAAC"}

package/dist/index.js

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

package/dist/oids.d.ts

@@ -1,6 +1,12 @@
 import type { ShortSubjectAttributeType } from "./types.js";
 export declare const OID: {
+    readonly ecPublicKey: "1.2.840.10045.2.1";
+    readonly secp256r1: "1.2.840.10045.3.1.7";
+    readonly secp384r1: "1.3.132.0.34";
+    readonly secp521r1: "1.3.132.0.35";
     readonly ecdsaWithSha256: "1.2.840.10045.4.3.2";
+    readonly ecdsaWithSha384: "1.2.840.10045.4.3.3";
+    readonly ecdsaWithSha512: "1.2.840.10045.4.3.4";
     readonly basicConstraints: "2.5.29.19";
     readonly keyUsage: "2.5.29.15";
     readonly extendedKeyUsage: "2.5.29.37";
@@ -8,6 +14,7 @@ export declare const OID: {
     readonly subjectKeyIdentifier: "2.5.29.14";
     readonly authorityKeyIdentifier: "2.5.29.35";
     readonly clientAuth: "1.3.6.1.5.5.7.3.2";
+    readonly extensionRequest: "1.2.840.113549.1.9.14";
 };
 export declare const SUBJECT_ATTRIBUTE_OIDS: Record<ShortSubjectAttributeType, string>;
 export declare const SUBJECT_VALUE_LENGTH_LIMITS: Record<ShortSubjectAttributeType, number>;

package/dist/oids.d.ts.map

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;CAgBN,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

@@ -1,12 +1,19 @@
 export const OID = {
+    ecPublicKey: "1.2.840.10045.2.1",
+    secp256r1: "1.2.840.10045.3.1.7",
+    secp384r1: "1.3.132.0.34",
+    secp521r1: "1.3.132.0.35",
     ecdsaWithSha256: "1.2.840.10045.4.3.2",
+    ecdsaWithSha384: "1.2.840.10045.4.3.3",
+    ecdsaWithSha512: "1.2.840.10045.4.3.4",
     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"
+    clientAuth: "1.3.6.1.5.5.7.3.2",
+    extensionRequest: "1.2.840.113549.1.9.14"
 };
 export const SUBJECT_ATTRIBUTE_OIDS = {
     CN: "2.5.4.3",

package/dist/pem.d.ts

@@ -1,6 +1,4 @@
 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[];

package/dist/pem.d.ts.map

@@ -1 +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"}
+{"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,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

@@ -3,12 +3,6 @@ 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]) {

package/dist/types.d.ts

@@ -9,8 +9,6 @@ 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;
@@ -18,8 +16,6 @@ export interface CertificateAuthority {
 }
 export interface IssuedClientCertificate {
     certPem: string;
-    privateKeyPem: string;
-    publicKeyPem: string;
     certDer: Uint8Array;
     privateKey: CryptoKey;
     publicKey: CryptoKey;
@@ -31,7 +27,7 @@ export interface CreateRootCAOptions {
     notBefore?: Date;
     serialNumber?: SerialNumber;
     pathLenConstraint?: number;
-    privateKeyPem?: string;
+    keyPair?: CryptoKeyPair;
 }
 export interface IssueIntermediateCAOptions {
     ca: CertificateAuthority;
@@ -40,7 +36,7 @@ export interface IssueIntermediateCAOptions {
     notBefore?: Date;
     serialNumber?: SerialNumber;
     pathLenConstraint?: number;
-    privateKeyPem?: string;
+    keyPair?: CryptoKeyPair;
 }
 export interface IssueClientCertOptions {
     ca: CertificateAuthority;
@@ -51,9 +47,24 @@ export interface IssueClientCertOptions {
     dnsNames?: string[];
     ipAddresses?: string[];
 }
+export interface IssueClientCertForPublicKeyOptions {
+    ca: CertificateAuthority;
+    publicKey: CryptoKey;
+    subject: Subject;
+    days: number;
+    notBefore?: Date;
+    serialNumber?: SerialNumber;
+    dnsNames?: string[];
+    ipAddresses?: string[];
+}
+export interface IssuedClientCertificateForPublicKey {
+    certPem: string;
+    certDer: Uint8Array;
+    certChainPem: string;
+}
 export interface ImportCertificateAuthorityOptions {
     certPem: string;
-    privateKeyPem: string;
+    privateKey: CryptoKey;
     issuerChainPem?: string;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +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"}
+{"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,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,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,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;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,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;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,kCAAkC;IACjD,EAAE,EAAE,oBAAoB,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,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,mCAAmC;IAClD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,UAAU,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,iCAAiC;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,SAAS,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/x509.d.ts

@@ -1,3 +1,4 @@
+import { type SupportedCurve } from "./crypto.js";
 import type { SerialNumber } from "./types.js";
 export interface CertificateBuildInput {
     serialNumber?: SerialNumber | undefined;
@@ -7,6 +8,7 @@ export interface CertificateBuildInput {
     subjectNameDer: Uint8Array;
     subjectPublicKeyInfoDer: Uint8Array;
     extensions: Uint8Array[];
+    issuerCurve: SupportedCurve;
 }
 export interface TbsCertificateResult {
     tbsCertificateDer: Uint8Array;
@@ -15,8 +17,8 @@ export interface TbsCertificateResult {
     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 buildCertificate(tbsCertificateDer: Uint8Array, signatureDer: Uint8Array, issuerCurve: SupportedCurve): Uint8Array;
+export declare function ecdsaSignatureAlgorithmIdentifier(curve: SupportedCurve): Uint8Array;
 export declare function basicConstraintsCaExtension(pathLenConstraint: number): Uint8Array;
 export declare function basicConstraintsLeafExtension(): Uint8Array;
 export declare function keyUsageExtension(usages: readonly KeyUsageBit[]): Uint8Array;

package/dist/x509.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"x509.d.ts","sourceRoot":"","sources":["../src/x509.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAkBjF,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;IACzB,WAAW,EAAE,cAAc,CAAC;CAC7B;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,CAC9B,iBAAiB,EAAE,UAAU,EAC7B,YAAY,EAAE,UAAU,EACxB,WAAW,EAAE,cAAc,GAC1B,UAAU,CAEZ;AAED,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CAEnF;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

@@ -1,11 +1,12 @@
 import { asciiBytes, concatBytes } from "./bytes.js";
+import { signatureAlgorithmOidForCurve } from "./crypto.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)));
+    const tbsCertificateDer = sequence(explicit(0, integer(2)), serialNumberDer, ecdsaSignatureAlgorithmIdentifier(input.issuerCurve), input.issuerNameDer, sequence(encodeTime(notBefore), encodeTime(notAfter)), input.subjectNameDer, input.subjectPublicKeyInfoDer, explicit(3, sequence(...input.extensions)));
     return {
         tbsCertificateDer,
         serialNumberDer,
@@ -13,11 +14,11 @@ export function buildTbsCertificate(input) {
         notAfter
     };
 }
-export function buildCertificate(tbsCertificateDer, signatureDer) {
-    return sequence(tbsCertificateDer, ecdsaWithSha256AlgorithmIdentifier(), bitString(signatureDer));
+export function buildCertificate(tbsCertificateDer, signatureDer, issuerCurve) {
+    return sequence(tbsCertificateDer, ecdsaSignatureAlgorithmIdentifier(issuerCurve), bitString(signatureDer));
 }
-export function ecdsaWithSha256AlgorithmIdentifier() {
-    return sequence(oid(OID.ecdsaWithSha256));
+export function ecdsaSignatureAlgorithmIdentifier(curve) {
+    return sequence(oid(signatureAlgorithmOidForCurve(curve)));
 }
 export function basicConstraintsCaExtension(pathLenConstraint) {
     return extension(OID.basicConstraints, true, sequence(boolean(true), integer(pathLenConstraint)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noz-ele/edgca",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A small Cloudflare Workers-friendly toolkit for issuing self-managed CA and mTLS client certificates.",
   "type": "module",
   "license": "MIT",