identity: the SD-JWT form of an AERE hybrid identity is judged on its ML-DSA-65 half by default, the Ed25519 half only on explicit request, and every verdict says postQuantum (rule sdjwt.hybrid-half); pq-pki: the signature algorithm a certificate or a revocation list declares must be its issuer key's (ALG_KEY, CRL_ALG_KEY); agents: an equivocation proof requires the agent's ML-DSA-65 key; pq-gateway: the status names the path to the backend and hybrid-only refuses a plain-HTTP backend; conformance 241 rules, 631 vectors
This commit is contained in:
1 parent
3ff21f7758
commit
0c8f1de3fd
122 files changed
+1205
-262
No files matched your search
@@ -45,6 +45,11 @@ const PLANTARI = [
|
||||
['[A7] numai primul intermediar candidat', 'pki.mjs', 'certs.inter.filter((c) => c !== cur && !stiva.includes(c) && emite(c, cur)) : [];', 'certs.inter.filter((c) => c !== cur && !stiva.includes(c) && emite(c, cur)).slice(0, 1) : [];', 'reinnoirea radacinii'],
|
||||
['[A10] primul subidentificator OID scris pe un singur octet', 'der.mjs', ' const out = base128(p[0] * 40n + p[1]);', ' const out = [Number((p[0] * 40n + p[1]) & 0x7fn)];', 'OID'],
|
||||
['[A10] arcul OID dedus fara regula de 80', 'der.mjs', ' const arc = first < 80n ? first / 40n : 2n;', ' const arc = first / 40n;', 'OID'],
|
||||
// 2026-10-19 (AIP-25 C3, D-537): algoritmul declarat e al cheii emitentului; fiecare paznic nou scos pe rand
|
||||
['[AIP-25 C3] algoritmul declarat de un certificat nu mai e legat de cheia emitentului', 'pki.mjs', "if (!(c.alg === p.pkAlg)) return fail('ALG_KEY'", "if (!(c.alg === p.pkAlg) && Boolean(Number('0'))) return fail('ALG_KEY'", 'algoritmul declarat e al cheii emitentului'],
|
||||
['[AIP-25 C3] radacina declara alt algoritm decat propria cheie', 'pki.mjs', "if (!(top.alg === top.pkAlg)) return fail('ALG_KEY'", "if (!(top.alg === top.pkAlg) && Boolean(Number('0'))) return fail('ALG_KEY'", 'algoritmul declarat e al cheii emitentului'],
|
||||
['[AIP-25 C3] lista de revocare declara alt algoritm decat cheia emitentului', 'pki.mjs', 'const altAlg = verificate.find((l) => !(l.alg === p.pkAlg));', "const altAlg = verificate.find((l) => !(l.alg === p.pkAlg) && Boolean(Number('0')));", 'algoritmul declarat e al cheii emitentului'],
|
||||
['[AIP-25 C3] selfSignatureValid nu mai cere algoritmul cheii', 'pki.mjs', 'return c.alg === c.pkAlg && c.subjectRaw.equals(c.issuerRaw)', 'return c.subjectRaw.equals(c.issuerRaw)', 'algoritmul declarat e al cheii emitentului'],
|
||||
];
|
||||
|
||||
// 1. martorul: originalul trebuie sa fie verde, si din el se ia numarul de probe
|
||||
|
||||
@@ -268,6 +268,47 @@ await test('forma: algoritm exterior diferit de cel interior (ALG_MISMATCH), par
|
||||
e = null; try { P.parseCert(Buffer.concat([leaf, Buffer.from([0])])); } catch (x) { e = x; } has(e && e.message, 'bytes after the structure', 'coada');
|
||||
const nc = Buffer.from([0x30, 0x81, 0x03, 0x02, 0x01, 0x05]); e = null; try { P.parseCert(nc); } catch (x) { e = x; } has(e && e.message, 'non-canonical', 'lungime lunga pentru una scurta');
|
||||
});
|
||||
// AIP-25 C3 (D-537, 2026-10-19): algoritmul de semnatura pe care il declara un certificat (si o lista de revocare) e cel al CHEII emitentului
|
||||
// (RFC 5280 s.4.1.2.3 si 5.1.2.2: algoritmul cu care a semnat CA-ul; RFC 9881: ML-DSA-44/65/87 sunt trei algoritmi). Pana atunci semnatura se
|
||||
// verifica cu cheia emitentului oricare ar fi algoritmul declarat, deci o politica ce citeste algoritmul declarat era mintita. Cazurile sunt
|
||||
// facute aici: TBS-ul cu OID-ul de semnatura schimbat, RESEMNAT cu cheia adevarata a emitentului (semnatura e buna, numai declaratia minte).
|
||||
const OIDS = { 'ml-dsa-44': '0609608648016503040311', 'ml-dsa-65': '0609608648016503040312', 'ml-dsa-87': '0609608648016503040313' };
|
||||
function declara(der, din, cu, cheie) {
|
||||
const [tbsEl] = Dm.children(Dm.parse(der)); const tbs = Buffer.from(tbsEl.raw);
|
||||
const a = Buffer.from(OIDS[din], 'hex'), p = tbs.indexOf(a); if (p < 0) throw new Error('fixtura: OID-ul ' + din + ' nu e in TBS');
|
||||
const t2 = Buffer.from(tbs); Buffer.from(OIDS[cu], 'hex').copy(t2, p);
|
||||
return Dm.seq(t2, Dm.seq(Dm.oid(P.ALG[cu])), Dm.bits(crypto.sign(null, t2, cheie)));
|
||||
}
|
||||
await test('algoritmul declarat e al cheii emitentului [AIP-25 C3]: o frunza care declara ml-dsa-87, semnata de o radacina ml-dsa-44: ALG_KEY la noi, "unable to get local issuer" la OpenSSL; o radacina care declara alt algoritm decat cheia ei: ALG_KEY, si la OpenSSL nu e auto-semnata; o lista de revocare care declara alt algoritm: CRL_ALG_KEY la noi, "CRL signature failure" la OpenSSL; martorul aceleiasi forme, cu algoritmul adevarat: OK la amandoi', () => {
|
||||
const k44 = P.generateKey('ml-dsa-44'), k65 = P.generateKey('ml-dsa-65');
|
||||
const r44 = P.issue({ issuer: null, signingKey: k44.privateKey, subject: { cn: 'C3 Root 44' }, publicKey: k44.publicKey, ca: true, pathLen: 0, days: 2 });
|
||||
const fr = P.issue({ issuer: r44, signingKey: k44.privateKey, subject: { cn: 'localhost' }, publicKey: k65.publicKey, days: 1, dns: ['localhost'], eku: ['serverAuth'] });
|
||||
const fr87 = declara(fr, 'ml-dsa-44', 'ml-dsa-87', k44.privateKey);
|
||||
eq(P.parseCert(fr87).alg, 'ml-dsa-87', 'fixtura: frunza declara ml-dsa-87');
|
||||
const martor = declara(fr, 'ml-dsa-44', 'ml-dsa-44', k44.privateKey); // aceeasi constructie, algoritmul adevarat: trebuie sa treaca
|
||||
eq(P.verifyChain({ leaf: martor, roots: [r44], host: 'localhost' }).ok, true, 'martorul resemnat cu algoritmul adevarat');
|
||||
const v = P.verifyChain({ leaf: fr87, roots: [r44], host: 'localhost' }); eq(v.code, 'ALG_KEY', 'noi, frunza ' + v.reason); has(v.reason, 'ml-dsa-87', 'motivul numeste algoritmul declarat'); has(v.reason, 'ml-dsa-44', 'motivul numeste cheia emitentului');
|
||||
const fR = w('c3-r44.pem', r44), fM = w('c3-martor.pem', martor), fF = w('c3-fr87.pem', fr87);
|
||||
eq(ossl(['verify', '-x509_strict', '-purpose', 'sslserver', '-CAfile', fR, fM]).code, 0, 'openssl martorul');
|
||||
const of = ossl(['verify', '-x509_strict', '-purpose', 'sslserver', '-CAfile', fR, fF]); eq(of.code === 0, false, 'openssl frunza ' + of.out); has(of.out, 'unable to get local issuer', 'openssl frunza');
|
||||
// radacina auto-semnata cu cheia ml-dsa-44 care declara ml-dsa-87
|
||||
const r87 = declara(r44, 'ml-dsa-44', 'ml-dsa-87', k44.privateKey);
|
||||
const vr = P.verifyChain({ leaf: fr, roots: [r87], host: 'localhost' }); eq(vr.code, 'ALG_KEY', 'noi, radacina ' + vr.reason);
|
||||
eq(P.selfSignatureValid(r87), false, 'selfSignatureValid pe radacina care minte'); eq(P.selfSignatureValid(r44), true, 'selfSignatureValid pe radacina buna');
|
||||
has(ossl(['verify', '-x509_strict', '-CAfile', w('c3-r87.pem', r87), f('c3-r87.pem')]).out, 'unable to get local issuer', 'openssl radacina');
|
||||
// lista de revocare a radacinii, semnata cu cheia ml-dsa-44, care declara ml-dsa-87; martorul: aceeasi lista cu algoritmul adevarat
|
||||
const l = P.crl({ issuer: r44, signingKey: k44.privateKey, revoked: [], days: 7, number: 1 });
|
||||
const l87 = declara(l, 'ml-dsa-44', 'ml-dsa-87', k44.privateKey), lm = declara(l, 'ml-dsa-44', 'ml-dsa-44', k44.privateKey);
|
||||
eq(P.verifyChain({ leaf: fr, roots: [r44], host: 'localhost', crls: [lm], requireCrl: true }).ok, true, 'martorul listei');
|
||||
const vl = P.verifyChain({ leaf: fr, roots: [r44], host: 'localhost', crls: [l87], requireCrl: true }); eq(vl.code, 'CRL_ALG_KEY', 'noi, lista ' + vl.reason);
|
||||
const ol = ossl(['verify', '-x509_strict', '-purpose', 'sslserver', '-crl_check', '-CAfile', fR, '-CRLfile', w('c3-l87.pem', l87, 'X509 CRL'), w('c3-fr.pem', fr)]);
|
||||
eq(ol.code === 0, false, 'openssl lista ' + ol.out); has(ol.out, 'CRL signature failure', 'openssl lista');
|
||||
// o cheie ml-dsa-44 (1312 octeti) declarata ml-dsa-87 in SPKI e refuzata la citire (lungimea FIPS 204), inainte de orice semnatura
|
||||
const sp = Buffer.from(P.parseCert(fr).spki); const s87 = Buffer.from(sp); const po = s87.indexOf(Buffer.from(OIDS['ml-dsa-65'], 'hex')); Buffer.from(OIDS['ml-dsa-87'], 'hex').copy(s87, po);
|
||||
const tbsS = Dm.seq(...Dm.children(Dm.parse(P.parseCert(fr).tbs)).map((x) => (x.raw.equals(sp) ? s87 : x.raw)));
|
||||
let e = null; try { P.parseCert(Dm.seq(tbsS, Dm.seq(Dm.oid(P.ALG['ml-dsa-44'])), Dm.bits(crypto.sign(null, tbsS, k44.privateKey)))); } catch (x) { e = x; } eq(e && e.code, 'SPKI', 'cheia 65 declarata 87 in SPKI');
|
||||
return 'OpenSSL: frunza "' + (of.out.split('\n').find((x) => /error \d+/.test(x)) || '').trim() + '"; lista "' + (ol.out.split('\n').find((x) => /error \d+/.test(x)) || '').trim() + '"';
|
||||
});
|
||||
// [A5] SPKI
|
||||
const cuSpkiRau = (der) => { const c = P.parseCert(der); const [algEl] = Dm.children(Dm.parse(c.spki)); const s = Dm.seq(algEl.raw, Dm.bits(Buffer.alloc(10, 7))); return { c, tbs: Dm.seq(...Dm.children(Dm.parse(c.tbs)).map((k) => (k.raw.equals(c.spki) ? s : k.raw))) }; };
|
||||
await test('cheie publica malformata [A5]: SPKI de 10 octeti sub id-ml-dsa pe frunza, pe intermediar si pe radacina: verdict SPKI (cu lungimea) la noi, fara exceptie; "decode error" la OpenSSL; o cheie de 1312 octeti sub id-ml-dsa-65 e tot SPKI', () => {
|
||||
|
||||
Reference in new issue
Block a user