@kya-brasil/core 0.14.0 → 0.17.0

package/README.md

@@ -46,6 +46,25 @@ const verdict = checkAction(credential.mandate, {
 // verdict.allowed, verdict.checks (every rule evaluated, with its reason), verdict.not_evaluated (extensions)
 ```
 
+## Without trusting the issuer
+
+Since D-33 the e-CNPJ / e-CPF signs the agent and the mandate's hash, and the principal keeps the signed text and the
+`.p7s`. When the principal hands them to its agent, you can check the authorization against ICP-Brasil alone (SPEC
+section 19), and the issuer's key vouches only for the credential's status:
+
+```ts
+import { decodePrincipalProofHeader, verifyPrincipalProof, checkRevocation } from "@kya-brasil/core";
+
+const proof = decodePrincipalProofHeader(request.headers.get("KYA-Principal-Proof")!);
+const r = await verifyPrincipalProof({ credential, proof, anchors: icpBrasilAnchors, now: trustedClock() });
+// r.ok; r.checks: signature, certificate, agent, principal, issuer, mandate (each with its reason)
+// then the certificate's revocation, with a CRL you fetched from r.revocation.crl_urls:
+// await checkRevocation({ crlDer, serial: r.revocation!.serial_number, issuerCertificate: r.revocation!.issuer_certificate!, pastNextUpdate: "refuse" })
+```
+
+The CMS carries the signer's certificate (personal data): the principal decides when to share it, and you use it for
+this check only. The result carries nothing personal.
+
 ## Delegation chains (sub-agents)
 
 A mandate with `delegation: { max_depth, max_ttl_seconds }` lets the agent hand a narrower mandate to another key
@@ -167,25 +186,28 @@ const ecnpj_signature = await signer.sign(challengeText);
 ```ts
 import {
   newChallenge, verifyAgentSignature, verifyIcpSignature, checkRevocation,
-  validateMandate, buildCredential, signCredential, importPrivateKey, generateAttestationKey
+  validateMandate, mandateSha256, buildCredential, signCredential, importPrivateKey, generateAttestationKey
 } from "@kya-brasil/core";
 
 const key = await generateAttestationKey();               // once; keep privateKeyPkcs8 secret, publish publicJwk
-const ch = newChallenge({ issuer: "https://kya.acquirer.example", agent, cnpj });
+const m = validateMandate(mandate);
+const mandate_sha256 = await mandateSha256(m);            // the e-CNPJ signs this hash with the challenge (D-33)
+const ch = newChallenge({ issuer: "https://kya.acquirer.example", agent, cnpj, mandate_sha256 });
 // The agent signs ch.text with its key; the company signs ch.text with its e-CNPJ (detached CMS).
 if (!(await verifyAgentSignature(agent, ch.text, agentSignature))) throw new Error("agent signature");
 const icp = await verifyIcpSignature({ cmsBase64: ecnpjSignature, challenge: ch.text, expectedCnpj: cnpj, anchors });
 // anchors: the ICP-Brasil roots as PEM strings (bundle in the repository: anchors/icp-brasil.pem).
 const crlDer = await fetchCrl(icp.crl_urls);             // yours: HTTP + cache
-const rev = await checkRevocation({ crlDer, serial: icp.serial_number, issuerCertificate: icp.issuer_certificate! });
+const rev = await checkRevocation({ crlDer, serial: icp.serial_number, issuerCertificate: icp.issuer_certificate!, pastNextUpdate: "refuse" });
 if (rev.revoked) throw new Error("certificate revoked");
 
 const credential = await signCredential(
   buildCredential({
     credential_id: crypto.randomUUID(), agent, cnpj,
     legal_name, registration_status,                      // from your registration source; "UNVERIFIED" if none answered
-    certificate: { sha256: icp.certificate_sha256, subject: icp.certificate_subject, issuer: icp.issuer, signed_at: icp.signed_at },
-    mandate: validateMandate(mandate),
+    certificate: { sha256: icp.certificate_sha256, subject: icp.certificate_subject, issuer: icp.issuer, signed_at: icp.signed_at, not_after: icp.not_after },
+    mandate: m, mandate_sha256,
+    ttl_seconds: 30 * 86400,                              // your risk decision; capped by the certificate and the mandate (D-35)
     issuer: "https://kya.acquirer.example"
   }),
   await importPrivateKey(key.privateKeyPkcs8), key.keyId

package/dist/credential.d.ts

@@ -1,18 +1,32 @@
-import type { Credential, CredentialStatus, KybSnapshot, Mandate, AgentKey } from "./types.js";
-export declare const CREDENTIAL_TTL_DAYS = 90;
+import { type Credential, type CredentialStatus, type KybSnapshot, type Mandate, type AgentKey } from "./types.js";
+/**
+ * D-35: when a credential expires. The lifetime is the caller's (`ttl_seconds`, no default: it is a risk decision),
+ * and the credential never outlives the mandate nor the certificate that signed it, so a proof checked against
+ * ICP-Brasil (D-34) never fails while the credential still reads as active.
+ */
+export declare function credentialExpiry(p: {
+    now: Date;
+    ttl_seconds: number;
+    mandate: Pick<Mandate, "valid_until">;
+    certificate_not_after: string;
+}): Date;
 export declare function buildCredential(p: {
     credential_id: string;
     agent: AgentKey;
     cnpj: string;
     legal_name: string;
     registration_status: string;
+    /** not_after: the signing certificate's end of validity (IcpProof.not_after); the credential never outlives it. */
     certificate: {
         sha256: string;
         subject: string;
         issuer: string;
         signed_at: string;
+        not_after: string;
     };
     mandate: Mandate;
+    /** D-35: the credential lifetime in seconds. Required, no default: how long a credential lives is the caller's risk. */
+    ttl_seconds: number;
     /** D-33: the mandate SHA-256 the signed challenge carried (mandateSha256OfChallenge). */
     mandate_sha256?: string;
     /** /v1 compatibility only; leave out (null). */
@@ -26,12 +40,16 @@ export declare function buildCredential(p: {
 export declare function buildPersonCredential(p: {
     credential_id: string;
     agent: AgentKey;
+    /** not_after: the signing certificate's end of validity (IcpPersonProof.not_after); the credential never outlives it. */
     certificate: {
         sha256: string;
         issuer: string;
         signed_at: string;
+        not_after: string;
     };
     mandate: Mandate;
+    /** D-35: the credential lifetime in seconds. Required, no default. */
+    ttl_seconds: number;
     /** D-33: the mandate SHA-256 the signed challenge carried (mandateSha256OfChallenge). */
     mandate_sha256?: string;
     issuer: string;

package/dist/credential.js

@@ -5,13 +5,29 @@
  */
 import { attestedPayload, canonicalize, signAttestation, verifyAttestation } from "./attestation.js";
 import { formatCnpj, normalizeCnpj } from "./cnpj.js";
-export const CREDENTIAL_TTL_DAYS = 90;
+import { KyaError } from "./types.js";
+/**
+ * D-35: when a credential expires. The lifetime is the caller's (`ttl_seconds`, no default: it is a risk decision),
+ * and the credential never outlives the mandate nor the certificate that signed it, so a proof checked against
+ * ICP-Brasil (D-34) never fails while the credential still reads as active.
+ */
+export function credentialExpiry(p) {
+    if (typeof p.ttl_seconds !== "number" || !Number.isFinite(p.ttl_seconds) || p.ttl_seconds <= 0)
+        throw new KyaError("INVALID_INPUT", "ttl_seconds must be a positive number of seconds (the credential lifetime is the caller's decision)");
+    const notAfter = new Date(p.certificate_not_after);
+    if (Number.isNaN(notAfter.getTime()))
+        throw new KyaError("INVALID_INPUT", "certificate.not_after must be an ISO 8601 date");
+    if (notAfter <= p.now)
+        throw new KyaError("CERTIFICATE_INVALID", `certificate expired on ${notAfter.toISOString()}`);
+    const candidates = [new Date(p.now.getTime() + p.ttl_seconds * 1000), notAfter];
+    if (p.mandate.valid_until)
+        candidates.push(new Date(p.mandate.valid_until));
+    return new Date(Math.min(...candidates.map((d) => d.getTime())));
+}
 export function buildCredential(p) {
     const now = p.now ?? new Date();
     const cnpj = normalizeCnpj(p.cnpj);
-    const ttl = new Date(now.getTime() + CREDENTIAL_TTL_DAYS * 86400000);
-    const mandateEnd = p.mandate.valid_until ? new Date(p.mandate.valid_until) : null;
-    const expires = mandateEnd && mandateEnd < ttl ? mandateEnd : ttl;
+    const expires = credentialExpiry({ now, ttl_seconds: p.ttl_seconds, mandate: p.mandate, certificate_not_after: p.certificate.not_after });
     return {
         credential_id: p.credential_id,
         version: 1,
@@ -32,9 +48,7 @@ export function buildCredential(p) {
 /** D-29: credential of a natural person. Nothing personal: no name, no CPF, no certificate subject. */
 export function buildPersonCredential(p) {
     const now = p.now ?? new Date();
-    const ttl = new Date(now.getTime() + CREDENTIAL_TTL_DAYS * 86400000);
-    const mandateEnd = p.mandate.valid_until ? new Date(p.mandate.valid_until) : null;
-    const expires = mandateEnd && mandateEnd < ttl ? mandateEnd : ttl;
+    const expires = credentialExpiry({ now, ttl_seconds: p.ttl_seconds, mandate: p.mandate, certificate_not_after: p.certificate.not_after });
     return {
         credential_id: p.credential_id,
         version: 1,

package/dist/index.d.ts

@@ -12,3 +12,4 @@ export * from "./cloud-sign.js";
 export * from "./person.js";
 export * from "./delegation.js";
 export * from "./freshness.js";
+export * from "./principal-proof.js";

package/dist/index.js

@@ -12,3 +12,4 @@ export * from "./cloud-sign.js";
 export * from "./person.js";
 export * from "./delegation.js";
 export * from "./freshness.js";
+export * from "./principal-proof.js";

package/dist/principal-proof.d.ts

@@ -0,0 +1,38 @@
+import { type Credential } from "./types.js";
+/** What the agent presents: the exact challenge text the principal signed, and the detached CMS (base64 DER). */
+export interface PrincipalProof {
+    text: string;
+    cms: string;
+}
+export interface PrincipalProofCheck {
+    rule: "signature" | "certificate" | "agent" | "principal" | "issuer" | "mandate";
+    ok: boolean;
+    detail: string;
+}
+export interface PrincipalProofResult {
+    ok: boolean;
+    checks: PrincipalProofCheck[];
+    /** For the caller's revocation check of the signing certificate; null when the signature did not verify. */
+    revocation: {
+        serial_number: string;
+        issuer_certificate: string | null;
+        crl_urls: string[];
+    } | null;
+}
+/**
+ * Checks, against the credential and without the issuer, that the principal's own signature authorizes this
+ * agent with this mandate: the CMS verifies over the text up to the ICP-Brasil anchors; the certificate is the
+ * one the credential records; the text names the credential's agent, principal and issuer; and the mandate hash
+ * in the text equals the hash of the credential's mandate. `anchors`, `now` and the revocation check are the
+ * caller's. Never throws on a bad proof: every check is reported.
+ */
+export declare function verifyPrincipalProof(p: {
+    credential: Pick<Credential, "agent" | "principal" | "authorized_by" | "mandate" | "issuer">;
+    proof: PrincipalProof;
+    anchors: string[];
+    now: Date;
+}): Promise<PrincipalProofResult>;
+/** Header value for a request: base64url of the JSON { text, cms }. */
+export declare function encodePrincipalProofHeader(proof: PrincipalProof): string;
+/** Parses the header value; throws INVALID_INPUT when it is not a proof. */
+export declare function decodePrincipalProofHeader(value: string): PrincipalProof;

package/dist/principal-proof.js

@@ -0,0 +1,97 @@
+/**
+ * Verification without trusting the issuer (D-34, SPEC section 19).
+ *
+ * Since D-33 the principal signs, with the e-CNPJ or e-CPF, a challenge that names the agent and carries the
+ * mandate's SHA-256, and keeps the signed text and the detached CMS (.p7s). When the principal chooses to hand
+ * them to its agent, the agent can present them with a request, and any verifier can check by itself, with the
+ * ICP-Brasil trust anchors, that this principal authorized this agent with these powers: the issuer's key is
+ * then needed for nothing but the credential's status.
+ *
+ * Pure functions, no network. The certificate's revocation is the caller's: this module returns what is needed
+ * to fetch and check the CRL (checkRevocation, evidenceFromRevocation), never personal data. The CMS carries the
+ * signer's certificate, so the principal decides when to share it, and the verifier treats it as personal data.
+ */
+import { base64url, mandateSha256OfChallenge } from "./challenge.js";
+import { mandateSha256 } from "./credential.js";
+import { verifyIcpPersonSignature, verifyIcpSignature } from "./icp-brasil.js";
+import { KyaError, isPersonPrincipal } from "./types.js";
+const lineOf = (text, key) => {
+    const lines = text.split("\n").filter((l) => l.startsWith(`${key}: `));
+    return lines.length === 1 ? lines[0].slice(key.length + 2) : null;
+};
+/**
+ * Checks, against the credential and without the issuer, that the principal's own signature authorizes this
+ * agent with this mandate: the CMS verifies over the text up to the ICP-Brasil anchors; the certificate is the
+ * one the credential records; the text names the credential's agent, principal and issuer; and the mandate hash
+ * in the text equals the hash of the credential's mandate. `anchors`, `now` and the revocation check are the
+ * caller's. Never throws on a bad proof: every check is reported.
+ */
+export async function verifyPrincipalProof(p) {
+    const { credential: c, proof } = p;
+    const checks = [];
+    const push = (rule, ok, detail) => checks.push({ rule, ok, detail });
+    if (!proof || typeof proof.text !== "string" || typeof proof.cms !== "string") {
+        push("signature", false, "proof must carry the signed text and the CMS");
+        return { ok: false, checks, revocation: null };
+    }
+    if (!(p.now instanceof Date) || Number.isNaN(p.now.getTime())) {
+        push("signature", false, "the verifier's clock is not a valid date");
+        return { ok: false, checks, revocation: null };
+    }
+    const person = isPersonPrincipal(c.principal);
+    let certificateSha256 = null;
+    let revocation = null;
+    try {
+        const icp = person
+            ? await verifyIcpPersonSignature({ cmsBase64: proof.cms, challenge: proof.text, anchors: p.anchors, now: p.now })
+            : await verifyIcpSignature({ cmsBase64: proof.cms, challenge: proof.text, expectedCnpj: c.principal.cnpj, anchors: p.anchors, now: p.now });
+        certificateSha256 = icp.certificate_sha256;
+        revocation = { serial_number: icp.serial_number, issuer_certificate: icp.issuer_certificate, crl_urls: icp.crl_urls };
+        push("signature", true, `${person ? "e-CPF" : "e-CNPJ"} signature over the text verifies up to the ICP-Brasil anchors`);
+    }
+    catch (e) {
+        push("signature", false, e instanceof KyaError ? e.message : `signature does not verify: ${e.message}`);
+    }
+    if (certificateSha256 !== null) {
+        const same = certificateSha256 === c.authorized_by.certificate_sha256;
+        push("certificate", same, same ? "signed with the certificate the credential records" : "signed with another certificate than the one the credential records");
+    }
+    const agent = lineOf(proof.text, "agent");
+    const expectedAgent = `${c.agent.kind}:${c.agent.id}`;
+    push("agent", agent === expectedAgent, agent === expectedAgent ? `text names the credential's agent ${expectedAgent}` : `text names agent ${agent ?? "(none)"}, the credential ${expectedAgent}`);
+    if (person) {
+        const ok = lineOf(proof.text, "principal") === "person (e-CPF)";
+        push("principal", ok, ok ? "text is a natural person's authorization" : "text is not a natural person's authorization");
+    }
+    else {
+        const cnpj = lineOf(proof.text, "cnpj");
+        const expected = c.principal.cnpj;
+        push("principal", cnpj === expected, cnpj === expected ? `text names CNPJ ${expected}` : `text names CNPJ ${cnpj ?? "(none)"}, the credential ${expected}`);
+    }
+    const issuer = lineOf(proof.text, "issuer");
+    push("issuer", issuer === c.issuer, issuer === c.issuer ? `text names issuer ${c.issuer}` : `text names issuer ${issuer ?? "(none)"}, the credential ${c.issuer}`);
+    const signed = mandateSha256OfChallenge(proof.text);
+    const actual = await mandateSha256(c.mandate);
+    const recorded = c.authorized_by.mandate_sha256;
+    const mandateOk = signed !== null && signed === actual && (!recorded || recorded === signed);
+    push("mandate", mandateOk, signed === null ? "text carries no mandate hash (signed before D-33)" : mandateOk ? "text commits to the credential's mandate" : "text commits to another mandate than the credential's");
+    return { ok: checks.every((x) => x.ok), checks, revocation };
+}
+/** Header value for a request: base64url of the JSON { text, cms }. */
+export function encodePrincipalProofHeader(proof) {
+    return base64url.encode(new TextEncoder().encode(JSON.stringify({ text: proof.text, cms: proof.cms })));
+}
+/** Parses the header value; throws INVALID_INPUT when it is not a proof. */
+export function decodePrincipalProofHeader(value) {
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(base64url.decode(value.trim())));
+    }
+    catch {
+        throw new KyaError("INVALID_INPUT", "KYA-Principal-Proof is not base64url JSON");
+    }
+    const o = parsed;
+    if (!o || typeof o.text !== "string" || typeof o.cms !== "string")
+        throw new KyaError("INVALID_INPUT", "KYA-Principal-Proof must carry text and cms");
+    return { text: o.text, cms: o.cms };
+}

package/dist/revocation.d.ts

@@ -15,6 +15,8 @@ export interface RevocationStatus {
     revoked: boolean;
     revoked_at: string | null;
     reason: string | null;
+    /** RFC 5280 invalidityDate: when the key is known or suspected to have been compromised, if the AC says so. */
+    invalidity_date?: string | null;
     crl_this_update: string;
     crl_next_update: string | null;
 }
@@ -46,12 +48,33 @@ export declare function checkRevocation(p: {
     pastNextUpdate: "refuse" | "accept";
     now?: Date;
 }): Promise<RevocationStatus>;
+/** RFC 5280 CRL reason codes (section 5.3.1), by name. */
+export declare const CRL_REASONS: readonly ["unspecified", "keyCompromise", "cACompromise", "affiliationChanged", "superseded", "cessationOfOperation", "certificateHold", "removeFromCRL", "privilegeWithdrawn", "aACompromise"];
+export type CrlReason = (typeof CRL_REASONS)[number];
 /**
- * What a CRL entry does to a credential the certificate already authorized (D-16):
- *   - certificateHold: suspend (the AC may lift it; the review reinstates when the entry disappears);
- *   - superseded / cessationOfOperation dated after the authorization: nothing, the company replaced or
- *     retired the certificate without compromise and its signature stands (registration is checked apart);
- *   - anything else (unspecified, keyCompromise, privilegeWithdrawn, ...): revoke.
+ * D-36: what a revoked certificate does to what it already authorized, decided by whoever relies on it.
+ *   - `by_reason`: the effect of each CRL reason the caller has an opinion on: "revoke" (the authorization ends),
+ *     "suspend" (it stops while the entry stays, e.g. certificateHold) or "keep" (it stands: the certificate was
+ *     replaced or retired without compromise);
+ *   - `other`: the effect of any reason not listed, including an entry without a reason. Never "keep": an
+ *     unexplained revocation is not ignored.
+ * No default: which reasons end a mandate is a legal and risk decision (Código Civil art. 682; SPEC section 11).
+ */
+export interface CertificateRevocationPolicy {
+    by_reason: Partial<Record<CrlReason, "revoke" | "suspend" | "keep">>;
+    other: "revoke" | "suspend";
+}
+/** Throws INVALID_INPUT unless `p` is a complete CertificateRevocationPolicy. */
+export declare function certificateRevocationPolicy(p: CertificateRevocationPolicy): CertificateRevocationPolicy;
+/**
+ * What a CRL entry does to an authorization the certificate already signed (D-16, D-36), under the caller's policy.
+ * Two rules hold whatever the policy says, because they are about the signature, not about the mandate:
+ *   - "keep" applies only when the revocation, and the suspected compromise (invalidityDate) when the AC gives
+ *     one, come after the authorization; otherwise the authorization was signed with a certificate already
+ *     revoked or already compromised, and it is revoked (MP 2.200-2 art. 10 presumes only a valid certificate);
+ *   - without the authorization's date there is nothing to compare: "keep" becomes "revoke".
  * At issuance any entry refuses: a new authorization must be signed with a certificate in force.
  */
-export declare function revocationEffect(r: Pick<RevocationStatus, "revoked" | "revoked_at" | "reason">, authorizedAt: string | null): "none" | "suspend" | "revoke";
+export declare function revocationEffect(r: Pick<RevocationStatus, "revoked" | "revoked_at" | "reason"> & {
+    invalidity_date?: string | null;
+}, authorizedAt: string | null, policy: CertificateRevocationPolicy): "none" | "suspend" | "revoke";

package/dist/revocation.js

@@ -64,6 +64,7 @@ export async function verifyCrl(p) {
                 revoked: entry !== null,
                 revoked_at: entry ? entry.revocationDate.toISOString() : null,
                 reason: entry && entry.reason !== undefined ? (X509CrlReason[entry.reason] ?? String(entry.reason)) : null,
+                invalidity_date: entry?.invalidity ? entry.invalidity.toISOString() : null,
                 crl_this_update: this_update,
                 crl_next_update: next_update
             };
@@ -74,21 +75,45 @@ export async function verifyCrl(p) {
 export async function checkRevocation(p) {
     return (await verifyCrl(p)).lookup(p.serial);
 }
+/** RFC 5280 CRL reason codes (section 5.3.1), by name. */
+export const CRL_REASONS = ["unspecified", "keyCompromise", "cACompromise", "affiliationChanged", "superseded", "cessationOfOperation", "certificateHold", "removeFromCRL", "privilegeWithdrawn", "aACompromise"];
+/** Throws INVALID_INPUT unless `p` is a complete CertificateRevocationPolicy. */
+export function certificateRevocationPolicy(p) {
+    if (!p || typeof p !== "object")
+        throw new KyaError("INVALID_INPUT", "a certificate revocation policy is required: { by_reason, other }");
+    if (p.other !== "revoke" && p.other !== "suspend")
+        throw new KyaError("INVALID_INPUT", 'policy.other is required: "revoke" or "suspend" (an unexplained revocation is never ignored)');
+    if (!p.by_reason || typeof p.by_reason !== "object")
+        throw new KyaError("INVALID_INPUT", "policy.by_reason is required (it may be empty)");
+    for (const [k, v] of Object.entries(p.by_reason)) {
+        if (!CRL_REASONS.includes(k))
+            throw new KyaError("INVALID_INPUT", `policy.by_reason.${k} is not an RFC 5280 reason`);
+        if (v !== "revoke" && v !== "suspend" && v !== "keep")
+            throw new KyaError("INVALID_INPUT", `policy.by_reason.${k} must be "revoke", "suspend" or "keep"`);
+    }
+    return { by_reason: { ...p.by_reason }, other: p.other };
+}
+const isAfter = (a, b) => a !== null && Date.parse(a) > Date.parse(b);
 /**
- * What a CRL entry does to a credential the certificate already authorized (D-16):
- *   - certificateHold: suspend (the AC may lift it; the review reinstates when the entry disappears);
- *   - superseded / cessationOfOperation dated after the authorization: nothing, the company replaced or
- *     retired the certificate without compromise and its signature stands (registration is checked apart);
- *   - anything else (unspecified, keyCompromise, privilegeWithdrawn, ...): revoke.
+ * What a CRL entry does to an authorization the certificate already signed (D-16, D-36), under the caller's policy.
+ * Two rules hold whatever the policy says, because they are about the signature, not about the mandate:
+ *   - "keep" applies only when the revocation, and the suspected compromise (invalidityDate) when the AC gives
+ *     one, come after the authorization; otherwise the authorization was signed with a certificate already
+ *     revoked or already compromised, and it is revoked (MP 2.200-2 art. 10 presumes only a valid certificate);
+ *   - without the authorization's date there is nothing to compare: "keep" becomes "revoke".
  * At issuance any entry refuses: a new authorization must be signed with a certificate in force.
  */
-export function revocationEffect(r, authorizedAt) {
+export function revocationEffect(r, authorizedAt, policy) {
+    const pol = certificateRevocationPolicy(policy);
     if (!r.revoked)
         return "none";
-    if (r.reason === "certificateHold")
-        return "suspend";
-    const benign = r.reason === "superseded" || r.reason === "cessationOfOperation";
-    if (benign && authorizedAt && r.revoked_at && Date.parse(r.revoked_at) > Date.parse(authorizedAt))
-        return "none";
-    return "revoke";
+    const reason = r.reason && CRL_REASONS.includes(r.reason) ? r.reason : null;
+    const effect = (reason && pol.by_reason[reason]) ?? pol.other;
+    if (effect !== "keep")
+        return effect;
+    if (!authorizedAt || Number.isNaN(Date.parse(authorizedAt)))
+        return "revoke";
+    const revokedAfter = isAfter(r.revoked_at, authorizedAt);
+    const compromiseAfter = r.invalidity_date ? isAfter(r.invalidity_date, authorizedAt) : true;
+    return revokedAfter && compromiseAfter ? "none" : "revoke";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kya-brasil/core",
-  "version": "0.14.0",
+  "version": "0.17.0",
   "description": "KYA Brasil as a library: verify and issue know-your-agent credentials for Brazilian companies without any hosted service. e-CNPJ (ICP-Brasil) CMS signature and chain validation, CRL revocation, CNPJ, agent key challenges (EVM, Ed25519 / Web Bot Auth, ERC-8004), mandate schema and evaluation (including payment instruments for card networks and acquirers), credential build, Ed25519 signing and verification, and e-CNPJ signing for the holder (A1 .pfx, or any token/HSM/cloud signer through a raw-sign callback). Pure functions: storage and network are yours.",
   "license": "MIT",
   "type": "module",