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:
Aere Network committed 2026-10-19 05:19:21 +03:00
1 parent 3ff21f7758
commit 0c8f1de3fd
122 files changed
+1205 -262

No files matched your search

+25 -9
View File
@@ -31,17 +31,33 @@ const arata = (sd, reveal, o = {}) => V.presentSdJwtVc({ sdJwt: sd, reveal, hold
const judeca = (p, o = {}) => V.verifySdJwtVc(p, { issuerKey: iss, audience: AUD, nonce: NONCE, now: LA, expectedVct: VCT, ...o });
const lista = (statuses, bits = 1, o = {}) => V.issueStatusListJwt({ issuer: iss, uri: URI, statuses, bits, iat: NOW, exp: NOW + 3600, ...o });
const TOATE0 = new Array(16).fill(0), REVOCAT = TOATE0.map((_, i) => (i === IDX ? 1 : 0)), SUSPENDAT = TOATE0.map((_, i) => (i === IDX ? 2 : 0));
// 2026-10-19 (AIP-25 C1): cu chei AERE, jetonul si lista de stare se semneaza si se judeca implicit cu jumatatea ML-DSA-65; cele facute de
// mana mai jos sunt semnate cu ea (cu jumatatea Ed25519 singura ar cadea pe hybrid-half inaintea regulii masurate)
const PQ = 'ML-DSA-65', EM = iss.privat.mldsa65;
const jwtDin = (antet, corp, cheie) => { const cap = b64u(JSON.stringify(antet)) + '.' + b64u(JSON.stringify(corp)); return cap + '.' + b64u(crypto.sign(null, Buffer.from(cap), cheie)); };
const E = emite(), P = arata(E.sdJwt, ['birthdate', 'age_over_18', { element: 'RO', in: 'nationalities' }]);
test('PROFIL: emitere SD-JWT VC (typ dc+sd-jwt, vct, iss, cnf, nbf/exp, status) si verificare cu lista de stare (toate 0): VALID, starea judecata 0, numai ce s-a aratat', () => {
const h = JSON.parse(Buffer.from(E.sdJwt.split('.')[0], 'base64url').toString('utf8')); cere(h.typ === 'dc+sd-jwt' && h.alg === 'EdDSA', JSON.stringify(h));
const h = JSON.parse(Buffer.from(E.sdJwt.split('.')[0], 'base64url').toString('utf8')); cere(h.typ === 'dc+sd-jwt' && h.alg === PQ, JSON.stringify(h));
const r = judeca(P, { statusListJwt: lista(TOATE0) });
cere(r.valid, r.reason);
cere(r.vct === VCT && r.payload.vct === VCT && r.payload.iss === 'https://issuer.example' && r.payload.cnf && r.payload.nbf === NOW && r.payload.exp === NOW + 365 * 86400, JSON.stringify(Object.keys(r.payload)));
cere(r.payload.birthdate === '1990-01-01' && r.payload.age_over_18 === true && !('given_name' in r.payload) && !('address' in r.payload) && egal(r.payload.nationalities, ['RO']) && r.payload.issuing_country === 'RO', JSON.stringify(r.payload));
cere(egal(r.status, { present: true, judged: true, mechanism: 'status_list', uri: URI, idx: IDX, value: 0, name: 'VALID' }), JSON.stringify(r.status));
cere(r.keyBinding && r.keyBinding.aud === AUD && r.keyBinding.nonce === NONCE, JSON.stringify(r.keyBinding));
// AIP-25 C1: credentialul, Key Binding-ul si lista de stare implicite ale unor chei AERE sunt toate ML-DSA-65
cere(r.postQuantum === true && r.alg === PQ && r.keyBinding.alg === PQ, 'postQuantum=' + r.postQuantum + ' ' + r.alg + '/' + r.keyBinding.alg);
});
test('AIP-25 C1: lista de stare a unui emitent AERE e semnata implicit ML-DSA-65; una semnata NUMAI cu jumatatea Ed25519 (cine a spart doar cheia clasica "dezrevoca" credentialul) -> refuzata implicit (Ed25519 half); cu classicalHalf -> primita, dar verdictul VC e postQuantum false; un credential doar-Ed25519 -> hybrid-half', () => {
const lp = lista(TOATE0); cere(JSON.parse(Buffer.from(lp.split('.')[0], 'base64url').toString('utf8')).alg === PQ, 'lista implicita nu e ML-DSA-65');
const corp = JSON.parse(Buffer.from(lp.split('.')[1], 'base64url').toString('utf8'));
const clasica = jwtDin({ alg: 'EdDSA', typ: 'statuslist+jwt' }, corp, iss.privat.ed25519);
const a = judeca(P, { statusListJwt: clasica }); cere(!a.valid && a.rule === 'status-list' && /Ed25519 half/.test(a.reason) && a.postQuantum === false, 'lista doar-Ed25519, implicit: ' + (a.valid ? 'VALID' : a.rule + ': ' + a.reason));
const b = judeca(P, { statusListJwt: clasica, classicalHalf: true }); cere(b.valid && b.status.judged && b.alg === PQ && b.postQuantum === false, 'lista doar-Ed25519 cu classicalHalf: ' + (b.valid ? 'pq=' + b.postQuantum : b.reason));
cere(/classicalHalf/.test((() => { try { V.issueStatusListJwt({ issuer: iss, alg: 'EdDSA', uri: URI, statuses: TOATE0, iat: NOW }); return ''; } catch (e) { return e.message; } })()), 'lista EdDSA emisa fara classicalHalf');
const corpC = JSON.parse(Buffer.from(E.sdJwt.split('~')[0].split('.')[1], 'base64url').toString('utf8'));
const c1 = jwtDin({ alg: 'EdDSA', typ: 'dc+sd-jwt' }, corpC, iss.privat.ed25519) + '~' + E.sdJwt.split('~').slice(1).join('~');
const c = judeca(arata(c1, ['birthdate']), { statusListJwt: lp }); cere(!c.valid && c.rule === 'hybrid-half', 'credentialul doar-Ed25519: ' + (c.valid ? 'VALID' : c.rule));
});
test('PROFIL vct: verificatorul fara expectedVct -> refuzat; alt vct asteptat -> refuzat; lista de vct-uri acceptate -> primit; jeton fara vct -> refuzat (s.2.2.2.3 REQUIRED)', () => {
cere(refuz(V.verifySdJwtVc(P, { issuerKey: iss, audience: AUD, nonce: NONCE, now: LA, statusListJwt: lista(TOATE0) }), /must name the vct/), 'fara expectedVct a trecut');
@@ -66,10 +82,10 @@ test('PROFIL s.2.2.2.3: emitentul refuza vct/status/iss/exp/cnf dezvaluibile, vc
cere(incearca({ disclosable: ['sub'] }) === null, 'sub dezvaluibil refuzat (s.2.2.2.3 il lasa)');
// verificatorul: o dezvaluire numita status / vct, facuta de mana si semnata de emitent
const fa = (nume, val) => { const d = b64u(JSON.stringify(['s1', nume, val])); const dg = crypto.createHash('sha256').update(d).digest('base64url');
return jwtDin({ alg: 'EdDSA', typ: 'dc+sd-jwt' }, { vct: VCT, iss: 'x', exp: NOW + 100, _sd_alg: 'sha-256', _sd: [dg] }, iss.privat.ed25519) + '~' + d + '~'; };
return jwtDin({ alg: PQ, typ: 'dc+sd-jwt' }, { vct: VCT, iss: 'x', exp: NOW + 100, _sd_alg: 'sha-256', _sd: [dg] }, EM) + '~' + d + '~'; };
cere(refuz(judeca(fa('status', { status_list: { idx: 1, uri: URI } }), { requireKeyBinding: false }), /status was selectively disclosed/), 'status dezvaluit a trecut');
const dv = b64u(JSON.stringify(['s1', 'nationalities', ['RO']])), dgv = crypto.createHash('sha256').update(dv).digest('base64url');
const bun = jwtDin({ alg: 'EdDSA', typ: 'dc+sd-jwt' }, { vct: VCT, iss: 'x', exp: NOW + 100, _sd_alg: 'sha-256', _sd: [dgv] }, iss.privat.ed25519) + '~' + dv + '~';
const bun = jwtDin({ alg: PQ, typ: 'dc+sd-jwt' }, { vct: VCT, iss: 'x', exp: NOW + 100, _sd_alg: 'sha-256', _sd: [dgv] }, EM) + '~' + dv + '~';
cere(judeca(bun, { requireKeyBinding: false }).valid, 'martorul (o dezvaluire obisnuita) refuzat');
});
test('STARE: lista lipsa -> refuzat implicit (requireStatus, cu uri-ul de adus in motiv); requireStatus:false -> VALID cu starea prezenta si nejudecata; credential fara status -> VALID fara lista', () => {
@@ -77,7 +93,7 @@ test('STARE: lista lipsa -> refuzat implicit (requireStatus, cu uri-ul de adus i
const r2 = judeca(P, { requireStatus: false }); cere(r2.valid && egal(r2.status, { present: true, judged: false, mechanism: 'status_list', uri: URI, idx: IDX }), r2.reason + ' ' + JSON.stringify(r2.status));
const F = emite({ status: undefined }); const r3 = judeca(arata(F.sdJwt, ['birthdate'])); cere(r3.valid && egal(r3.status, { present: false, judged: false }), r3.reason + ' ' + JSON.stringify(r3.status));
// un mecanism de stare pe care nu il stim: prezent, nejudecat
const alt = jwtDin({ alg: 'EdDSA', typ: 'dc+sd-jwt' }, { vct: VCT, iss: 'x', exp: NOW + 100, status: { identifier_list: { id: '1', uri: URI } } }, iss.privat.ed25519) + '~';
const alt = jwtDin({ alg: PQ, typ: 'dc+sd-jwt' }, { vct: VCT, iss: 'x', exp: NOW + 100, status: { identifier_list: { id: '1', uri: URI } } }, EM) + '~';
const r4 = judeca(alt, { requireKeyBinding: false }); cere(refuz(r4, /was not judged/) && r4.status.mechanism === 'identifier_list', r4.reason);
cere(judeca(alt, { requireKeyBinding: false, requireStatus: false }).valid, 'mecanismul necunoscut cu requireStatus:false refuzat');
});
@@ -102,11 +118,11 @@ test('STARE: lista pentru alt uri (sub), expirata, semnata de alta cheie, cu typ
cere(refuz(judeca(P, { statusListJwt: V.issueStatusListJwt({ issuer: strain, uri: URI, statuses: TOATE0, iat: NOW }) }), /status list: the signature does not verify/), 'alta cheie a trecut');
cere(judeca(P, { statusListJwt: V.issueStatusListJwt({ issuer: strain, uri: URI, statuses: TOATE0, iat: NOW }), statusListKey: strain }).valid, 'cheia listei data separat refuzata');
const corp = JSON.parse(Buffer.from(lista(TOATE0).split('.')[1], 'base64url').toString('utf8'));
cere(refuz(judeca(P, { statusListJwt: jwtDin({ alg: 'EdDSA', typ: 'JWT' }, corp, iss.privat.ed25519) }), /status list: typ/), 'typ JWT a trecut');
cere(refuz(judeca(P, { statusListJwt: jwtDin({ alg: PQ, typ: 'JWT' }, corp, EM) }), /status list: typ/), 'typ JWT a trecut');
const { iat: _i, ...faraIat } = corp;
cere(refuz(judeca(P, { statusListJwt: jwtDin({ alg: 'EdDSA', typ: 'statuslist+jwt' }, faraIat, iss.privat.ed25519) }), /status list: iat is required/), 'fara iat a trecut');
cere(refuz(judeca(P, { statusListJwt: jwtDin({ alg: 'EdDSA', typ: 'statuslist+jwt' }, { ...corp, status_list: { ...corp.status_list, bits: 3 } }, iss.privat.ed25519) }), /status list: status_list must be/), 'bits 3 a trecut');
cere(refuz(judeca(P, { statusListJwt: jwtDin({ alg: 'EdDSA', typ: 'statuslist+jwt' }, { ...corp, iat: NOW + 600 }, iss.privat.ed25519) }), /status list: issued in the future/), 'iat in viitor a trecut');
cere(refuz(judeca(P, { statusListJwt: jwtDin({ alg: PQ, typ: 'statuslist+jwt' }, faraIat, EM) }), /status list: iat is required/), 'fara iat a trecut');
cere(refuz(judeca(P, { statusListJwt: jwtDin({ alg: PQ, typ: 'statuslist+jwt' }, { ...corp, status_list: { ...corp.status_list, bits: 3 } }, EM) }), /status list: status_list must be/), 'bits 3 a trecut');
cere(refuz(judeca(P, { statusListJwt: jwtDin({ alg: PQ, typ: 'statuslist+jwt' }, { ...corp, iat: NOW + 600 }, EM) }), /status list: issued in the future/), 'iat in viitor a trecut');
const scurta = V.issueStatusListJwt({ issuer: iss, uri: URI, statuses: [0, 0, 0, 0], bits: 8, iat: NOW });
cere(refuz(judeca(P, { statusListJwt: scurta }), /index 5 is beyond the list \(4 entries\)/), 'index dincolo a trecut');
let m = null; try { V.issueStatusListJwt({ issuer: iss, uri: URI, statuses: [0, 2], bits: 1, iat: NOW }); } catch (e) { m = e.message; } cere(/below 2\^1/.test(m || ''), 'starea 2 pe 1 bit emisa');
@@ -116,7 +132,7 @@ test('POST-CUANTIC: credential ML-DSA-65 cu lista de stare semnata ML-DSA-65 ->
const p = arata(M.sdJwt, ['birthdate'], { holderAlg: 'ML-DSA-65' });
const l = V.issueStatusListJwt({ issuer: iss, alg: 'ML-DSA-65', uri: URI, statuses: TOATE0, iat: NOW });
const r = judeca(p, { issuerAlg: 'ML-DSA-65', statusListJwt: l }); cere(r.valid && r.alg === 'ML-DSA-65' && r.status.judged, r.reason);
cere(refuz(judeca(p, { issuerAlg: 'ML-DSA-65', statusListJwt: l, statusListAlg: 'EdDSA' }), /status list: .*does not match|status list: signed with/), 'lista ML-DSA-65 judecata cu Ed25519 a trecut');
cere(refuz(judeca(p, { issuerAlg: 'ML-DSA-65', statusListJwt: l, statusListAlg: 'EdDSA' }), /status list: .*does not match|status list: signed with|status list: .*Ed25519 half/), 'lista ML-DSA-65 judecata cu Ed25519 a trecut');
});
const FX = path.join(AICI, 'interop', 'fixturi-interop-sdjwt-vc.json');
const F = fs.existsSync(FX) ? JSON.parse(fs.readFileSync(FX, 'utf8')) : null;