Aere Quantum: a post-quantum TLS 1.3 gateway (X25519MLKEM768, optional ML-DSA client authentication), a hybrid KMS (X25519 + ML-KEM-768, Ed25519 + ML-DSA-65; root key from the environment or sealed by an HSM through PKCS#11) and an ML-DSA private CA (X.509 v3, RFC 9881). Zero dependencies, Node.js 24 with OpenSSL 3.5. Each with its test suite and a negative control.
This commit is contained in:
commit
7d814d1bb8
24 files changed
+7004
No files matched your search
@@ -0,0 +1,58 @@
|
||||
// test/control-negativ-hsm-incredere.mjs (2026-09-29): controlul negativ al probei H1 (proba-hsm-incredere.mjs). Trei stari pe caz:
|
||||
// PRINS (proba a rulat pana la capat si a iesit rosie pe verificarea numita), SCAPAT, STRICAT (copia nu s-a incarcat / proba nu a rulat).
|
||||
// V0 modulul de DINAINTE de reparatie (HEAD-ul lui git la momentul scrierii: `git show <rev>:.../hsm-radacina.mjs`) -> rosu pe H1
|
||||
// P1 verificarea bibliotecii scoasa cu o conditie falsa la rulare -> rosu pe biblioteca straina
|
||||
// P2 verificarea variabilei PIN-ului scoasa cu o conditie falsa la rulare -> rosu pe jetonul API ca PIN
|
||||
// Copiile stau LANGA original (./kms.mjs trebuie sa se rezolve) si se sterg la sfarsit; originalul trebuie sa ramana octet cu octet.
|
||||
// node test/control-negativ-hsm-incredere.mjs -> 0 toate prinse, 1 unul scapa, 2 STRICAT
|
||||
import crypto from 'node:crypto';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { spawnSync } from 'node:child_process';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const AICI = path.dirname(fileURLToPath(import.meta.url));
|
||||
const SRC = path.join(AICI, '..', 'hsm-radacina.mjs');
|
||||
const PROBA = path.join(AICI, 'proba-hsm-incredere.mjs');
|
||||
const sha = (f) => crypto.createHash('sha256').update(fs.readFileSync(f)).digest('hex');
|
||||
const inainte = sha(SRC);
|
||||
const REV_VECHE = process.env.AERE_HSM_REV_VECHE || '7f2e7182';
|
||||
let prinse = 0, stricate = 0, total = 0;
|
||||
|
||||
function caz(id, text, tinta) {
|
||||
total++;
|
||||
const copie = path.join(AICI, '..', `.plantat-hsm-${id}.mjs`);
|
||||
try {
|
||||
fs.writeFileSync(copie, text);
|
||||
const r = spawnSync(process.execPath, [PROBA], { encoding: 'utf8', env: { ...process.env, AERE_HSM_MODUL_SUB_PROBA: copie } });
|
||||
const out = (r.stdout || '') + (r.stderr || '');
|
||||
if (!/increderea in fisierul sigilat \(H1\): \d+\/\d+/.test(out)) { stricate++; console.log(` STRICAT ${id}: proba nu a ajuns la capat (${out.trim().split('\n').pop().slice(0, 120)})`); return; }
|
||||
if (!/\[OK \] CONTROL POZITIV/.test(out)) { stricate++; console.log(` STRICAT ${id}: controlul pozitiv al probei nu a trecut pe copie`); return; }
|
||||
const rosii = out.split('\n').filter((l) => l.includes('[RAU ]'));
|
||||
if (r.status === 1 && rosii.some((l) => l.includes(tinta))) { prinse++; console.log(` PRINS ${id}: ${rosii.length} verificari rosii, intre ele "${tinta}"`); }
|
||||
else console.log(` SCAPAT ${id}: cod ${r.status}, "${tinta}" nu e rosie`);
|
||||
} finally { fs.rmSync(copie, { force: true }); }
|
||||
}
|
||||
const inlocuieste = (t, a, b) => { if (t.split(a).length !== 2) return null; return t.replace(a, b); };
|
||||
|
||||
// V0: codul vechi, din git (octetii comisi, fara conversia autocrlf)
|
||||
// In depozitul public (alt istoric) codul de dinainte nu exista: V0 se sare, spus, si nu se numara; in depozitul de lucru trebuie sa ruleze.
|
||||
const CALE_VECHE = `${REV_VECHE}:cloud-gateway/pq-kms/hsm-radacina.mjs`;
|
||||
const exista = spawnSync('git', ['cat-file', '-e', CALE_VECHE], { cwd: path.join(AICI, '..'), encoding: 'utf8' }).status === 0;
|
||||
if (!exista) console.log(` SARIT V0: codul de dinainte de reparatie (${REV_VECHE}) nu e in istoricul acestui depozit; NEMASURAT aici`);
|
||||
else {
|
||||
const g = spawnSync('git', ['-c', 'core.autocrlf=false', 'show', CALE_VECHE], { cwd: path.join(AICI, '..'), encoding: 'utf8' });
|
||||
if (g.status !== 0 || !g.stdout.includes('export function deschideRadacina')) { stricate++; total++; console.log(' STRICAT V0: nu citesc modulul vechi din git (' + REV_VECHE + ')'); }
|
||||
else caz('V0', g.stdout, 'biblioteca din fisier, alta decat AERE_HSM_MODULE');
|
||||
}
|
||||
|
||||
const nou = fs.readFileSync(SRC, 'utf8');
|
||||
const p1 = inlocuieste(nou, "if (sig.modul !== permis) throw", "if (sig.modul !== permis && process.env.AERE_PLANTA_NICIODATA === 'da') throw");
|
||||
if (!p1) { stricate++; total++; console.log(' STRICAT P1: ancora nu apare exact o data'); } else caz('P1', p1, 'biblioteca din fisier, alta decat AERE_HSM_MODULE');
|
||||
const p2 = inlocuieste(nou, "if (sig.pinEnv !== undefined && sig.pinEnv !== PIN_ENV) throw", "if (sig.pinEnv !== undefined && sig.pinEnv !== PIN_ENV && process.env.AERE_PLANTA_NICIODATA === 'da') throw");
|
||||
if (!p2) { stricate++; total++; console.log(' STRICAT P2: ancora nu apare exact o data'); } else caz('P2', p2, 'alta variabila drept PIN');
|
||||
|
||||
const ramase = fs.readdirSync(path.join(AICI, '..')).filter((f) => f.startsWith('.plantat-hsm-'));
|
||||
if (sha(SRC) !== inainte || ramase.length) { stricate++; console.log(' STRICAT originalul s-a schimbat sau au ramas copii: ' + ramase.join(',')); }
|
||||
console.log(`\ncontrolul negativ H1: prinse ${prinse}/${total}, stricate ${stricate}`);
|
||||
process.exitCode = stricate ? 2 : prinse === total ? 0 : 1;
|
||||
@@ -0,0 +1,423 @@
|
||||
// test/control-negativ.mjs - controlul negativ al probei Aere PQ KMS.
|
||||
//
|
||||
// O proba care nu poate iesi rosie nu masoara nimic. Aici se planteaza, intr-o COPIE a codului,
|
||||
// cate un defect real, si se cere ca proba sa iasa ROSIE pe exact probele numite, pentru
|
||||
// MOTIVUL numit (un fragment din mesajul afirmatiei care a cazut), nu doar "ceva a picat".
|
||||
//
|
||||
// Reguli, platite in alte parti ale casei:
|
||||
// - verdictul se citeste din JSON-ul probei (AERE_KMS_PROBA_JSON), nu din codul de iesire;
|
||||
// o proba care nu a ajuns la capat sau a rulat alt numar de probe e STRICAT, nu ROSU;
|
||||
// - copia se reface pentru FIECARE plantare si se compara sha256 cu originalul inainte de a
|
||||
// planta (altfel s-ar masura plantarea de dinainte);
|
||||
// - ancora unei plantari trebuie sa apara EXACT o data; o plantare care nu se poate pune e un
|
||||
// ESEC al controlului, nu o trecere;
|
||||
// - plantarile se fac cu o conditie falsa la RULARE sau cu o inlocuire care ramane cod valid,
|
||||
// ca rosul sa vina din proba, nu din incarcarea modulului;
|
||||
// - la sfarsit originalul trebuie sa fie identic octet cu octet (sha256).
|
||||
//
|
||||
// Iesire: 0 numai daca proba e VERDE pe copia neatinsa, fiecare plantare e ROSIE pe probele
|
||||
// numite si originalul e neatins; altfel 1.
|
||||
//
|
||||
// --autoproba: controlul controlului. Ruleaza momeli (ancora inexistenta, plantare fara efect,
|
||||
// motiv gresit, proba inexistenta, modul care nu se incarca) si cere ca fiecare sa primeasca
|
||||
// verdictul ei de ESEC. Un control care nu a fost vazut esuand nu se poate crede.
|
||||
|
||||
import crypto from 'node:crypto';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { spawnSync } from 'node:child_process';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const HERE = path.dirname(fileURLToPath(import.meta.url));
|
||||
const RADACINA = path.resolve(HERE, '..');
|
||||
// 2026-09-28: server.mjs importa si hsm-radacina.mjs (radacina sigilata de HSM); fara el copia nu mai pornea si linia de baza iesea STRICATA
|
||||
const FISIERE = ['kms.mjs', 'server.mjs', 'hsm-radacina.mjs', 'test/proba.mjs'];
|
||||
const NICIODATA = "process.env.AERE_KMS_PLANTA_NICIODATA === 'da'";
|
||||
|
||||
// Fiecare plantare: fisierul, ancora (exact o aparitie), inlocuirea, si probele care TREBUIE sa
|
||||
// iasa rosii, fiecare cu un fragment din motivul pe care trebuie sa cada.
|
||||
const PLANTARI = [
|
||||
{
|
||||
id: 'P16',
|
||||
defect: 'A4: mutatia ramane pe disc cand randul de audit nu se poate scrie (rollback-ul nu se mai face)',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: ' if (!changed) return;',
|
||||
inlocuire: " if (!changed || !(process.env.AERE_KMS_PLANTA_NICIODATA === 'da')) return;",
|
||||
rosii: [
|
||||
['audit: o mutatie al carei rand de audit nu se poate scrie NU ramane pe disc (rotire, minim, creare), iar lantul ramane valid', 'rotirea a ramas pe disc fara rand de audit'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P01',
|
||||
defect: 'KDF fara secretul ML-KEM (IKM = numai X25519)',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'const ikm = Buffer.concat([ssK, ssX]);',
|
||||
inlocuire: 'const ikm = Buffer.concat([ssX]);',
|
||||
rosii: [
|
||||
['criptare: atacatorul cu doar secretul X25519 nu poate deriva cheia plicului', 'plicul s-a deschis numai cu secretul X25519'],
|
||||
['interop: plicul serviciului decapsulat si decriptat manual cu node:crypto', 'commit'],
|
||||
['interop: plic construit fara unul din secrete e refuzat de serviciu cu HEADER_AUTH_FAILED', 'KDF doar-x: trebuia refuzat'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P02',
|
||||
defect: 'KDF fara secretul X25519 (IKM = numai ML-KEM)',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'const ikm = Buffer.concat([ssK, ssX]);',
|
||||
inlocuire: 'const ikm = Buffer.concat([ssK]);',
|
||||
rosii: [
|
||||
['criptare: atacatorul cu doar secretul ML-KEM nu poate deriva cheia plicului', 'plicul s-a deschis numai cu secretul ML-KEM'],
|
||||
['interop: plic construit fara unul din secrete e refuzat de serviciu cu HEADER_AUTH_FAILED', 'KDF doar-k: trebuia refuzat'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P03',
|
||||
defect: 'verificarea accepta o singura semnatura (SAU in loc de SI)',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'const valid = edOk && pqOk;',
|
||||
inlocuire: 'const valid = edOk || pqOk;',
|
||||
rosii: [
|
||||
['semnare: jumatatea Ed25519 stricata e refuzata cu CLASSICAL_SIGNATURE_INVALID', 'valid: asteptat false'],
|
||||
['semnare: jumatatea ML-DSA-65 stricata e refuzata cu PQ_SIGNATURE_INVALID', 'valid: asteptat false'],
|
||||
['semnare: jumatati amestecate din doua semnaturi valide sunt refuzate', 'amestec peste "unu": asteptat false'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P04',
|
||||
defect: 'AAD ignorat (inlocuit cu sirul gol)',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: "return toBytes(aad, 'aad', MAX_AAD);",
|
||||
inlocuire: 'return Buffer.alloc(0);',
|
||||
rosii: [
|
||||
['criptare: alt aad refuzat cu AAD_MISMATCH', 'alt aad: trebuia refuzat cu AAD_MISMATCH'],
|
||||
['datakey: cheia clara si cea invelita corespund; forma doar-invelita nu intoarce cheia clara', 'cheia de date legata de aad'],
|
||||
['rewrap: reincapsuleaza la ultima versiune, acelasi text clar, raspunsul nu contine text clar', 'rewrap cu alt aad'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P05',
|
||||
defect: 'min_decryption_version ignorat',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'if (ver < key.min_decryption_version) throw',
|
||||
inlocuire: `if (ver < key.min_decryption_version && ${NICIODATA}) throw`,
|
||||
rosii: [
|
||||
['rotire: sub min_decryption_version decriptarea e refuzata cu VERSION_BELOW_MINIMUM', 'v1 sub minim: trebuia refuzat'],
|
||||
['rotire: sub min_decryption_version verificarea semnaturii e refuzata cu VERSION_BELOW_MINIMUM', 'v1 sub minim: asteptat false'],
|
||||
['server: flux complet prin HTTP (creare, criptare, decriptare, rotire, rewrap, datakey, semnare, verificare, audit)', 'sub minim prin HTTP'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P06',
|
||||
defect: 'jurnalul scris fara legatura cu randul anterior (prev constant)',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'prev: this.#head.mac,',
|
||||
inlocuire: 'prev: ZERO_MAC,',
|
||||
rosii: [
|
||||
['audit: jurnalul neatins se verifica OK, un rand pe operatie, si refuzurile au motivul lor', 'jurnal neatins'],
|
||||
['audit: rand sters detectat cu AUDIT_CHAIN_BROKEN pe randul lui', 'randul: asteptat 4'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P07',
|
||||
defect: 'verificatorul jurnalului nu verifica legatura (seq/prev)',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'if (row.seq !== seq + 1 || row.prev !== prev)',
|
||||
inlocuire: `if ((row.seq !== seq + 1 || row.prev !== prev) && ${NICIODATA})`,
|
||||
rosii: [
|
||||
['audit: rand sters detectat cu AUDIT_CHAIN_BROKEN pe randul lui', 'rand sters: asteptat false'],
|
||||
['audit: randuri reordonate detectate cu AUDIT_CHAIN_BROKEN', 'reordonare: asteptat false'],
|
||||
['audit: pornirea refuza un jurnal stricat cu AUDIT_CHAIN_INVALID', 'trebuia refuzat cu AUDIT_CHAIN_INVALID'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P08',
|
||||
defect: 'verificatorul jurnalului nu verifica mac-ul randului',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: "if (!macOk) return fail('AUDIT_ROW_MODIFIED', i + 1);",
|
||||
inlocuire: `if (!macOk && ${NICIODATA}) return fail('AUDIT_ROW_MODIFIED', i + 1);`,
|
||||
rosii: [['audit: rand schimbat detectat cu AUDIT_ROW_MODIFIED', 'rand schimbat: asteptat false']],
|
||||
},
|
||||
{
|
||||
id: 'P09',
|
||||
defect: 'cheia privata scrisa si necifrata langa sigiliu',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'private_sealed: sealed,',
|
||||
inlocuire: "private_sealed: sealed, private_debug: Buffer.from(privJson).toString('base64'),",
|
||||
rosii: [['stocare: materialul privat nu apare in clar pe disc (cu controlul pozitiv al scanerului)', 'material privat gasit in clar']],
|
||||
},
|
||||
{
|
||||
id: 'P10',
|
||||
defect: 'integritatea fisierului de cheie neverificata',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: "if (!macOk) throw new KmsError('KEY_FILE_TAMPERED'",
|
||||
inlocuire: `if (!macOk && ${NICIODATA}) throw new KmsError('KEY_FILE_TAMPERED'`,
|
||||
rosii: [
|
||||
['stocare: min_decryption_version coborat pe disc refuzat cu KEY_FILE_TAMPERED', 'trebuia refuzat cu KEY_FILE_TAMPERED'],
|
||||
['stocare: cheie publica inlocuita pe disc refuzata cu KEY_FILE_TAMPERED', 'trebuia refuzat cu KEY_FILE_TAMPERED'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P11',
|
||||
defect: 'fara cheie radacina se genereaza una in tacere',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: "if (s === '') throw new KmsError('ROOT_KEY_MISSING',",
|
||||
inlocuire: "if (s === '') return crypto.randomBytes(32); if (s === '') throw new KmsError('ROOT_KEY_MISSING',",
|
||||
rosii: [
|
||||
['radacina: lipsa cheii refuza pornirea cu ROOT_KEY_MISSING si nu creeaza nimic pe disc', 'trebuia refuzat cu ROOT_KEY_MISSING'],
|
||||
['server: configurarea implicita asculta pe 127.0.0.1 si cere token si cheie radacina', 'fara cheie radacina: trebuia refuzat'],
|
||||
['server: pornit din linia de comanda refuza fara AERE_KMS_ROOT_KEY si nu tipareste tokenul', 'codul de iesire'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P12',
|
||||
defect: 'amprenta cheii/versiunii din plic neverificata',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'if (!fp.equals(fpExpected)) {',
|
||||
inlocuire: `if (!fp.equals(fpExpected) && ${NICIODATA}) {`,
|
||||
rosii: [
|
||||
['criptare: alta cheie refuzata cu KEY_MISMATCH', 'motiv asteptat KEY_MISMATCH'],
|
||||
['semnare: alta cheie refuzata cu KEY_MISMATCH, semnatura malformata cu MALFORMED_SIGNATURE', 'motivul: asteptat "KEY_MISMATCH"'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P13',
|
||||
defect: 'rewrap intoarce si textul clar',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'return { value: { ciphertext: r.ciphertext, version: r.version }, version: r.version };',
|
||||
inlocuire: "return { value: { ciphertext: r.ciphertext, version: r.version, plaintext: plaintext.toString('base64') }, version: r.version };",
|
||||
rosii: [
|
||||
['rewrap: reincapsuleaza la ultima versiune, acelasi text clar, raspunsul nu contine text clar', 'campurile raspunsului'],
|
||||
['server: flux complet prin HTTP (creare, criptare, decriptare, rotire, rewrap, datakey, semnare, verificare, audit)', 'rewrap nu intoarce text clar'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P14',
|
||||
defect: 'serverul lasa sa treaca o cerere fara Authorization',
|
||||
fisier: 'server.mjs',
|
||||
ancora: "if (typeof header !== 'string' || header === '') return 'UNAUTHENTICATED';",
|
||||
inlocuire: "if (typeof header !== 'string' || header === '') return null;",
|
||||
rosii: [
|
||||
['server: fara Authorization raspunde 401 UNAUTHENTICATED', 'fara token: asteptat 401'],
|
||||
['server: pornit din linia de comanda asculta pe 127.0.0.1 si raspunde', 'cerere neautentificata'],
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'P15',
|
||||
defect: 'serverul ignora limita de marime a cererii',
|
||||
fisier: 'server.mjs',
|
||||
ancora: 'return n > maxBody;',
|
||||
inlocuire: 'return false;',
|
||||
rosii: [
|
||||
['server: cerere peste limita cu Content-Length raspunde 413 BODY_TOO_LARGE', 'peste limita: asteptat 413'],
|
||||
['server: cerere peste limita fara Content-Length (chunked) raspunde 413 BODY_TOO_LARGE', 'peste limita, chunked: asteptat 413'],
|
||||
],
|
||||
},
|
||||
];
|
||||
|
||||
// Momelile pentru --autoproba: controlul insusi trebuie sa poata iesi rosu. Fiecare momeala e o
|
||||
// plantare stricata dinadins si are verdictul pe care controlul TREBUIE sa i-l dea.
|
||||
const MOMELI = [
|
||||
{
|
||||
id: 'M1',
|
||||
defect: 'ancora care nu exista in cod',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'ACEASTA ANCORA NU EXISTA IN COD',
|
||||
inlocuire: 'x',
|
||||
rosii: [['semnare: semnatura hibrida se verifica, cu ambele jumatati raportate', 'x']],
|
||||
asteptat: 'ESEC CONTROL',
|
||||
},
|
||||
{
|
||||
id: 'M2',
|
||||
defect: 'plantare fara efect (un comentariu)',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: "export const PREFIX = 'aerekms';",
|
||||
inlocuire: "export const PREFIX = 'aerekms'; // momeala fara efect",
|
||||
rosii: [['semnare: semnatura hibrida se verifica, cu ambele jumatati raportate', 'x']],
|
||||
asteptat: 'VERDE (NEPRINS)',
|
||||
},
|
||||
{
|
||||
id: 'M3',
|
||||
defect: 'defect real, dar motivul cerut nu e cel pe care cade proba',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'const valid = edOk && pqOk;',
|
||||
inlocuire: 'const valid = edOk || pqOk;',
|
||||
rosii: [['semnare: jumatatea Ed25519 stricata e refuzata cu CLASSICAL_SIGNATURE_INVALID', 'un motiv care nu apare niciodata']],
|
||||
asteptat: 'ROSU GRESIT',
|
||||
},
|
||||
{
|
||||
id: 'M4',
|
||||
defect: 'proba numita nu exista',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'const valid = edOk && pqOk;',
|
||||
inlocuire: 'const valid = edOk || pqOk;',
|
||||
rosii: [['o proba care nu exista', 'x']],
|
||||
asteptat: 'ESEC CONTROL',
|
||||
},
|
||||
{
|
||||
id: 'M5',
|
||||
defect: 'plantare care rupe incarcarea modulului',
|
||||
fisier: 'kms.mjs',
|
||||
ancora: 'const valid = edOk && pqOk;',
|
||||
inlocuire: 'const valid = edOk && ;',
|
||||
rosii: [['semnare: jumatatea Ed25519 stricata e refuzata cu CLASSICAL_SIGNATURE_INVALID', 'valid: asteptat false']],
|
||||
asteptat: 'STRICAT',
|
||||
},
|
||||
];
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
|
||||
const sha = (p) => crypto.createHash('sha256').update(fs.readFileSync(p)).digest('hex');
|
||||
const amprente = () => Object.fromEntries(FISIERE.map((f) => [f, sha(path.join(RADACINA, f))]));
|
||||
|
||||
function pregatesteCopie(dest) {
|
||||
fs.rmSync(dest, { recursive: true, force: true });
|
||||
for (const f of FISIERE) {
|
||||
const d = path.join(dest, f);
|
||||
fs.mkdirSync(path.dirname(d), { recursive: true });
|
||||
fs.copyFileSync(path.join(RADACINA, f), d);
|
||||
}
|
||||
for (const f of FISIERE) {
|
||||
if (sha(path.join(dest, f)) !== sha(path.join(RADACINA, f))) throw new Error(`copia lui ${f} difera de original inainte de plantare`);
|
||||
}
|
||||
}
|
||||
|
||||
function planteaza(dest, p) {
|
||||
const fp = path.join(dest, p.fisier);
|
||||
const text = fs.readFileSync(fp, 'utf8');
|
||||
const bucati = text.split(p.ancora);
|
||||
if (bucati.length !== 2) return { ok: false, motiv: `ancora apare de ${bucati.length - 1} ori in ${p.fisier} (trebuie exact o data)` };
|
||||
const nou = bucati.join(p.inlocuire);
|
||||
fs.writeFileSync(fp, nou);
|
||||
if (sha(fp) === sha(path.join(RADACINA, p.fisier))) return { ok: false, motiv: 'fisierul plantat e identic cu originalul' };
|
||||
return { ok: true };
|
||||
}
|
||||
|
||||
function envCurat() {
|
||||
return Object.fromEntries(Object.entries(process.env).filter(([k]) => !k.startsWith('AERE_KMS_')));
|
||||
}
|
||||
|
||||
function ruleaza(dest) {
|
||||
const out = path.join(dest, 'rezultat-proba.json');
|
||||
fs.rmSync(out, { force: true });
|
||||
const t0 = Date.now();
|
||||
const r = spawnSync(process.execPath, [path.join(dest, 'test', 'proba.mjs')], {
|
||||
cwd: dest,
|
||||
env: { ...envCurat(), AERE_KMS_PROBA_JSON: out },
|
||||
encoding: 'utf8',
|
||||
timeout: 300000,
|
||||
maxBuffer: 16 * 1024 * 1024,
|
||||
});
|
||||
let json = null;
|
||||
try {
|
||||
json = JSON.parse(fs.readFileSync(out, 'utf8'));
|
||||
} catch {
|
||||
json = null;
|
||||
}
|
||||
return { json, status: r.status, signal: r.signal, ms: Date.now() - t0, stderr: String(r.stderr || '').slice(-600) };
|
||||
}
|
||||
|
||||
function main() {
|
||||
const autoproba = process.argv.includes('--autoproba');
|
||||
const PL = autoproba ? MOMELI : PLANTARI;
|
||||
if (autoproba) console.log('AUTOPROBA: momelile de mai jos TREBUIE sa primeasca verdictul lor de esec\n');
|
||||
const inainte = amprente();
|
||||
const lucru = fs.mkdtempSync(path.join(os.tmpdir(), 'aerekms-control-'));
|
||||
const dest = path.join(lucru, 'copie');
|
||||
const linii = [];
|
||||
let esecuri = 0;
|
||||
try {
|
||||
// 1. linia de baza: copia neatinsa trebuie sa fie VERDE
|
||||
pregatesteCopie(dest);
|
||||
const baza = ruleaza(dest);
|
||||
if (!baza.json || baza.json.completed !== true) {
|
||||
console.log(`LINIA DE BAZA STRICATA: proba nu a ajuns la capat (cod ${baza.status}, semnal ${baza.signal})\n${baza.stderr}`);
|
||||
return 1;
|
||||
}
|
||||
const numeBaza = new Set(baza.json.results.map((r) => r.nume));
|
||||
if (baza.json.failed.length !== 0) {
|
||||
console.log(`LINIA DE BAZA ROSIE: ${baza.json.failed.length} probe pica pe codul neatins:\n ${baza.json.failed.join('\n ')}`);
|
||||
return 1;
|
||||
}
|
||||
console.log(`linia de baza: VERDE, ${baza.json.passed}/${baza.json.total} probe, ${baza.ms} ms (node ${baza.json.node}, openssl ${baza.json.openssl})\n`);
|
||||
|
||||
// 2. fiecare plantare pe o copie proaspata
|
||||
for (const p of PL) {
|
||||
pregatesteCopie(dest);
|
||||
const numite = p.rosii.map(([n]) => n);
|
||||
const lipsa = numite.filter((n) => !numeBaza.has(n));
|
||||
if (lipsa.length) {
|
||||
esecuri++;
|
||||
linii.push({ p, verdict: 'ESEC CONTROL', detaliu: `proba numita nu exista in proba: ${lipsa.join(' | ')}` });
|
||||
continue;
|
||||
}
|
||||
const pl = planteaza(dest, p);
|
||||
if (!pl.ok) {
|
||||
esecuri++;
|
||||
linii.push({ p, verdict: 'ESEC CONTROL', detaliu: `plantarea nu s-a putut pune: ${pl.motiv}` });
|
||||
continue;
|
||||
}
|
||||
const r = ruleaza(dest);
|
||||
if (!r.json || r.json.completed !== true || r.json.total !== baza.json.total) {
|
||||
esecuri++;
|
||||
linii.push({ p, verdict: 'STRICAT', detaliu: `proba nu a rulat intreaga (cod ${r.status}, probe ${r.json ? r.json.total : '-'}/${baza.json.total}); ${r.stderr.split('\n').slice(-3).join(' ')}` });
|
||||
continue;
|
||||
}
|
||||
const dupaNume = new Map(r.json.results.map((x) => [x.nume, x]));
|
||||
const probleme = [];
|
||||
let rosiiNumite = 0;
|
||||
for (const [nume, motiv] of p.rosii) {
|
||||
const x = dupaNume.get(nume);
|
||||
if (x.ok) probleme.push(`VERDE: ${nume}`);
|
||||
else if (!String(x.motiv).includes(motiv)) probleme.push(`ROSU DIN ALT MOTIV: ${nume} -> "${x.motiv.slice(0, 160)}" (cerut: "${motiv}")`);
|
||||
else rosiiNumite++;
|
||||
}
|
||||
const inPlus = r.json.failed.filter((n) => !numite.includes(n));
|
||||
if (probleme.length === 0) {
|
||||
linii.push({ p, verdict: 'ROSU', detaliu: `${rosiiNumite}/${numite.length} numite rosii pe motivul cerut; alte ${inPlus.length} rosii in plus`, inPlus, ms: r.ms });
|
||||
} else {
|
||||
esecuri++;
|
||||
linii.push({ p, verdict: r.json.failed.length === 0 ? 'VERDE (NEPRINS)' : 'ROSU GRESIT', detaliu: probleme.join('\n '), inPlus, ms: r.ms });
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
fs.rmSync(lucru, { recursive: true, force: true });
|
||||
}
|
||||
|
||||
for (const l of linii) {
|
||||
console.log(`${l.verdict.padEnd(15)} ${l.p.id} ${l.p.defect}${l.ms ? ` (${l.ms} ms)` : ''}\n ${l.detaliu}`);
|
||||
if (l.inPlus && l.inPlus.length) console.log(` in plus: ${l.inPlus.join(' | ')}`);
|
||||
}
|
||||
|
||||
// 3. originalul neatins
|
||||
const dupa = amprente();
|
||||
const schimbate = FISIERE.filter((f) => inainte[f] !== dupa[f]);
|
||||
if (schimbate.length) {
|
||||
esecuri++;
|
||||
console.log(`\nORIGINALUL S-A SCHIMBAT: ${schimbate.join(', ')}`);
|
||||
} else {
|
||||
console.log(`\noriginal neatins (sha256): ${FISIERE.map((f) => `${f}=${dupa[f].slice(0, 12)}`).join(' ')}`);
|
||||
}
|
||||
if (autoproba) {
|
||||
// Aici esecurile sunt ceruse: fiecare momeala trebuie sa primeasca exact verdictul ei.
|
||||
let potrivite = 0;
|
||||
for (const l of linii) {
|
||||
const ok = l.verdict === l.p.asteptat;
|
||||
if (ok) potrivite++;
|
||||
console.log(`${ok ? 'CORECT ' : 'GRESIT '} ${l.p.id}: controlul a spus "${l.verdict}", trebuia "${l.p.asteptat}"`);
|
||||
}
|
||||
const originalOk = schimbate.length === 0;
|
||||
console.log(`\nautoproba controlului: ${potrivite}/${MOMELI.length} momeli cu verdictul cerut; original ${originalOk ? 'neatins' : 'SCHIMBAT'}`);
|
||||
return potrivite === MOMELI.length && linii.length === MOMELI.length && originalOk ? 0 : 1;
|
||||
}
|
||||
const rosii = linii.filter((l) => l.verdict === 'ROSU').length;
|
||||
console.log(`\ncontrol negativ: ${rosii}/${PLANTARI.length} plantari prinse pe probele numite; ${esecuri} esecuri ale controlului`);
|
||||
return esecuri === 0 && rosii === PLANTARI.length ? 0 : 1;
|
||||
}
|
||||
|
||||
try {
|
||||
process.exitCode = main();
|
||||
} catch (e) {
|
||||
console.log(`controlul negativ a cazut: ${(e && e.stack) || e}`);
|
||||
process.exitCode = 2;
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
// test/proba-hsm-incredere.mjs (2026-09-29, revizuirea adversariala a feliei HSM, H1): fisierul sigilat NU alege biblioteca PKCS#11 si
|
||||
// nici variabila de mediu trimisa drept PIN. Nu cere un HSM: unealta primita e o cale care NU exista, deci orice verificare care lasa
|
||||
// cererea sa ajunga la unealta se vede ca HSM_TOOL_MISSING, iar un refuz dat INAINTE de unealta are codul lui. Controlul pozitiv al
|
||||
// metodei: o sigilare corecta ajunge chiar la unealta (HSM_TOOL_MISSING), deci refuzurile de mai jos nu vin din altceva.
|
||||
// node test/proba-hsm-incredere.mjs -> 0 toate cum trebuia, 1 altfel
|
||||
// AERE_HSM_MODUL_SUB_PROBA=<cale> numai pentru controlul negativ (o copie plantata a modulului)
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath, pathToFileURL } from 'node:url';
|
||||
|
||||
const AICI = path.dirname(fileURLToPath(import.meta.url));
|
||||
const MOD = process.env.AERE_HSM_MODUL_SUB_PROBA || path.join(AICI, '..', 'hsm-radacina.mjs');
|
||||
const { deschideRadacina, radacinaDinHsm, FORMAT_HSM } = await import(pathToFileURL(MOD).href);
|
||||
let rele = 0, n = 0;
|
||||
const cer = (nume, ok, extra = '') => { n++; console.log(` [${ok ? 'OK ' : 'RAU '}] ${nume}${extra ? ' (' + extra + ')' : ''}`); if (!ok) rele++; };
|
||||
const codul = (fn) => { try { fn(); return 'FARA REFUZ'; } catch (e) { return e.code || String(e.message).slice(0, 60); } };
|
||||
|
||||
const LIB = path.resolve('/usr/lib/softhsm/libsofthsm2.so');
|
||||
const RAU = path.resolve('/tmp/biblioteca-straina.so');
|
||||
const UNEALTA = path.join(os.tmpdir(), 'nu-exista-' + process.pid, 'pkcs11-tool');
|
||||
const sig = { format: FORMAT_HSM, mecanism: 'AES-CBC-PAD', modul: LIB, token: 'aere-kms', idCheie: '0a', pinEnv: 'AERE_HSM_PIN', iv: '00'.repeat(16), ct: '11'.repeat(64) };
|
||||
const env = { AERE_HSM_PIN: '483920', AERE_HSM_MODULE: LIB, AERE_KMS_TOKEN: 'AERE-SINTETIC-jeton-api-care-nu-trebuie-trimis-ca-pin' };
|
||||
const deschide = (s, e = env) => codul(() => deschideRadacina(s, { env: e, unealta: UNEALTA }));
|
||||
|
||||
cer('CONTROL POZITIV: o sigilare corecta ajunge la unealta (HSM_TOOL_MISSING aici), deci refuzurile de mai jos vin din verificari', deschide(sig) === 'HSM_TOOL_MISSING', deschide(sig));
|
||||
cer('H1: o biblioteca din fisier, alta decat AERE_HSM_MODULE -> HSM_MODULE_NOT_ALLOWED, fara sa ruleze unealta', deschide({ ...sig, modul: RAU }) === 'HSM_MODULE_NOT_ALLOWED', deschide({ ...sig, modul: RAU }));
|
||||
cer('H1: fara AERE_HSM_MODULE -> HSM_CONFIG_INVALID (fisierul singur nu alege biblioteca)', deschide(sig, { ...env, AERE_HSM_MODULE: '' }) === 'HSM_CONFIG_INVALID');
|
||||
cer('H1: AERE_HSM_MODULE relativ -> HSM_CONFIG_INVALID', deschide(sig, { ...env, AERE_HSM_MODULE: 'libsofthsm2.so' }) === 'HSM_CONFIG_INVALID');
|
||||
cer('H1: fisierul cere alta variabila drept PIN (jetonul API) -> HSM_SEAL_INVALID, fara sa ruleze unealta', deschide({ ...sig, pinEnv: 'AERE_KMS_TOKEN' }) === 'HSM_SEAL_INVALID', deschide({ ...sig, pinEnv: 'AERE_KMS_TOKEN' }));
|
||||
const { pinEnv, ...faraPinEnv } = sig;
|
||||
cer('o sigilare fara camp pinEnv (PIN-ul din AERE_HSM_PIN) ajunge la unealta', deschide(faraPinEnv) === 'HSM_TOOL_MISSING');
|
||||
// drumul serverului: AERE_KMS_ROOT_HSM spre un fisier cu biblioteca straina
|
||||
const T = fs.mkdtempSync(path.join(os.tmpdir(), 'hsm-incredere-'));
|
||||
try {
|
||||
const f = path.join(T, 'root-hsm.json'); fs.writeFileSync(f, JSON.stringify({ ...sig, modul: RAU }));
|
||||
cer('H1 pe drumul serverului: AERE_KMS_ROOT_HSM cu biblioteca straina -> HSM_MODULE_NOT_ALLOWED', codul(() => radacinaDinHsm({ ...env, AERE_KMS_ROOT_HSM: f }, { unealta: UNEALTA })) === 'HSM_MODULE_NOT_ALLOWED');
|
||||
} finally { fs.rmSync(T, { recursive: true, force: true }); }
|
||||
|
||||
console.log(`\nincrederea in fisierul sigilat (H1): ${n - rele}/${n} cum trebuia`);
|
||||
process.exitCode = rele ? 1 : 0;
|
||||
@@ -0,0 +1,88 @@
|
||||
// test/proba-hsm.mjs - proba radacinii KMS sigilate de un HSM (hsm-radacina.mjs), pe un HSM PKCS#11 REAL (SoftHSM2), nu pe o imitatie
|
||||
// a uneltei: token nou intr-un dosar temporar, cheie AES-256 generata IN token (sensitive, never extractable), apoi sigilare,
|
||||
// deschidere, KMS-ul pornit din radacina deschisa si o runda hibrida (ML-KEM-768 + X25519) prin el. Fiecare refuz se judeca dupa
|
||||
// MOTIV (codul), nu dupa faptul ca a aruncat ceva.
|
||||
// Cere: Node 24 (kms.mjs), softhsm2-util si pkcs11-tool (OpenSC) in PATH; libsofthsm2.so. Ruleaza in WSL / Linux:
|
||||
// /root/node24/bin/node test/proba-hsm.mjs -> 0 toate cum trebuia, 1 altfel, 2 NEMASURAT (HSM-ul de proba nu porneste)
|
||||
import crypto from 'node:crypto';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { spawnSync } from 'node:child_process';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { sigileazaRadacina, deschideRadacina, radacinaDinHsm, FORMAT_HSM } from '../hsm-radacina.mjs';
|
||||
import { configFromEnv } from '../server.mjs';
|
||||
import { openKms } from '../kms.mjs';
|
||||
|
||||
const MODUL = process.env.AERE_PKCS11_MODUL || '/usr/lib/softhsm/libsofthsm2.so';
|
||||
let rele = 0, n = 0;
|
||||
const cer = (nume, ok, extra = '') => { n++; console.log(` [${ok ? 'OK ' : 'RAU '}] ${nume}${extra ? ' (' + extra + ')' : ''}`); if (!ok) rele++; };
|
||||
const codul = (fn) => { try { fn(); return 'FARA REFUZ'; } catch (e) { return e.code || String(e.message).slice(0, 60); } };
|
||||
const nemasurat = (m) => { console.log('NEMASURAT: ' + m); process.exit(2); };
|
||||
if (!fs.existsSync(MODUL)) nemasurat('lipseste modulul PKCS#11 ' + MODUL);
|
||||
|
||||
const T = fs.mkdtempSync(path.join(os.tmpdir(), 'proba-hsm-'));
|
||||
// 2026-09-29 (H1): deschiderea cere biblioteca din configuratia procesului, nu din fisierul sigilat
|
||||
const env = { ...process.env, SOFTHSM2_CONF: path.join(T, 'softhsm2.conf'), AERE_HSM_PIN: '483920', AERE_HSM_MODULE: MODUL };
|
||||
fs.mkdirSync(path.join(T, 'tokens'));
|
||||
fs.writeFileSync(env.SOFTHSM2_CONF, `directories.tokendir = ${path.join(T, 'tokens')}\nobjectstore.backend = file\nlog.level = ERROR\n`);
|
||||
const ruleaza = (c, a) => spawnSync(c, a, { env, encoding: 'utf8' });
|
||||
try {
|
||||
let r = ruleaza('softhsm2-util', ['--init-token', '--free', '--label', 'aere-kms', '--pin', env.AERE_HSM_PIN, '--so-pin', '771122']);
|
||||
if (r.status !== 0) nemasurat('softhsm2-util nu initializeaza tokenul: ' + (r.stderr || r.error));
|
||||
r = ruleaza('pkcs11-tool', ['--module', MODUL, '--token-label', 'aere-kms', '--login', '--pin', 'env:AERE_HSM_PIN', '--keygen', '--key-type', 'AES:32', '--label', 'kms-root', '--id', '0a', '--sensitive']);
|
||||
if (r.status !== 0) nemasurat('cheia AES nu se genereaza in token: ' + (r.stderr || r.error));
|
||||
cer('cheia AES e generata IN token: sensitive, never extractable', /never extractable/.test(r.stdout) && /sensitive/.test(r.stdout));
|
||||
r = ruleaza('pkcs11-tool', ['--module', MODUL, '--token-label', 'aere-kms', '--login', '--pin', 'env:AERE_HSM_PIN', '--read-object', '--type', 'secrkey', '--id', '0a', '--output-file', path.join(T, 'k')]);
|
||||
cer('cheia NU poate fi citita afara din HSM', r.status !== 0 && (!fs.existsSync(path.join(T, 'k')) || fs.statSync(path.join(T, 'k')).size === 0));
|
||||
|
||||
const radacina = crypto.randomBytes(32);
|
||||
const sig = sigileazaRadacina({ modul: MODUL, token: 'aere-kms', idCheie: '0a', radacina: Buffer.from(radacina), env });
|
||||
cer('sigilarea: formatul, 64 de octeti, si radacina NU apare in ea', sig.format === FORMAT_HSM && sig.ct.length === 128 && !JSON.stringify(sig).includes(radacina.toString('hex')));
|
||||
const d = deschideRadacina(sig, { env });
|
||||
cer('deschiderea cu HSM-ul si PIN-ul da exact radacina sigilata', d.equals(radacina));
|
||||
const s2 = sigileazaRadacina({ modul: MODUL, token: 'aere-kms', idCheie: '0a', radacina: Buffer.from(radacina), env });
|
||||
cer('doua sigilari ale aceleiasi radacini difera (iv aleator), amandoua se deschid', s2.ct !== sig.ct && deschideRadacina(s2, { env }).equals(radacina));
|
||||
|
||||
// refuzuri, fiecare cu motivul lui
|
||||
cer('PIN gresit -> HSM_LOGIN_REFUSED', codul(() => deschideRadacina(sig, { env: { ...env, AERE_HSM_PIN: '000000' } })) === 'HSM_LOGIN_REFUSED');
|
||||
cer('PIN lipsa -> HSM_PIN_MISSING (nu se incearca fara)', codul(() => deschideRadacina(sig, { env: { ...env, AERE_HSM_PIN: '' } })) === 'HSM_PIN_MISSING');
|
||||
cer('alt token -> HSM_TOKEN_NOT_FOUND', codul(() => deschideRadacina({ ...sig, token: 'alt-token' }, { env })) === 'HSM_TOKEN_NOT_FOUND');
|
||||
const cti = Buffer.from(sig.ct, 'hex'); cti[3] ^= 0x01; // primul bloc: CBC descifreaza, dar in altceva
|
||||
cer('sigilare atinsa in primul bloc -> HSM_ROOT_TAMPERED (amprenta), nu o radacina gresita', codul(() => deschideRadacina({ ...sig, ct: cti.toString('hex') }, { env })) === 'HSM_ROOT_TAMPERED');
|
||||
const ctu = Buffer.from(sig.ct, 'hex'); ctu[63] ^= 0x80; // ultimul bloc: umplutura strica
|
||||
cer('sigilare atinsa in ultimul bloc -> HSM_ROOT_TAMPERED', codul(() => deschideRadacina({ ...sig, ct: ctu.toString('hex') }, { env })) === 'HSM_ROOT_TAMPERED');
|
||||
// H2 (2026-09-29): umplutura stricata (ultimul bloc) si amprenta gresita (primul bloc) dau ACELASI mesaj: altfel jurnalul pornirii e un oracol de umplutura
|
||||
const mesaj = (s) => { try { deschideRadacina(s, { env }); return 'FARA REFUZ'; } catch (e) { return e.code + ': ' + e.message; } };
|
||||
const m1 = mesaj({ ...sig, ct: cti.toString('hex') }), m2 = mesaj({ ...sig, ct: ctu.toString('hex') });
|
||||
cer('H2: umplutura stricata si amprenta gresita nu se deosebesc prin mesaj', m1 === m2 && m1.startsWith('HSM_ROOT_TAMPERED'), m1 === m2 ? 'identice' : m1 + ' | ' + m2);
|
||||
// CONTROLUL NECESITATII amprentei: fara ea, CBC ar fi dat 48 de octeti de gunoi, deci amprenta e cea care prinde atingerea
|
||||
const ctf = path.join(T, 'c'), ptf = path.join(T, 'p'); fs.writeFileSync(ctf, cti);
|
||||
r = ruleaza('pkcs11-tool', ['--module', MODUL, '--token-label', 'aere-kms', '--login', '--pin', 'env:AERE_HSM_PIN', '--id', '0a', '--mechanism', 'AES-CBC-PAD', '--decrypt', '--iv', sig.iv, '--input-file', ctf, '--output-file', ptf]);
|
||||
cer('CONTROL: HSM-ul singur descifreaza sigilarea atinsa fara sa se planga (48 de octeti) - de aceea amprenta', r.status === 0 && fs.statSync(ptf).size === 48);
|
||||
r = ruleaza('pkcs11-tool', ['--module', MODUL, '--token-label', 'aere-kms', '--login', '--pin', 'env:AERE_HSM_PIN', '--keygen', '--key-type', 'AES:32', '--label', 'alta', '--id', '0b', '--sensitive']);
|
||||
cer('alta cheie din acelasi token -> HSM_ROOT_TAMPERED (nu se deschide cu cheia gresita)', r.status === 0 && codul(() => deschideRadacina({ ...sig, idCheie: '0b' }, { env })) === 'HSM_ROOT_TAMPERED');
|
||||
|
||||
// KMS-ul pornit din radacina deschisa de HSM, capat la capat
|
||||
const fsig = path.join(T, 'root-hsm.json'); fs.writeFileSync(fsig, JSON.stringify(sig));
|
||||
const tok = crypto.randomBytes(24).toString('hex');
|
||||
const cfg = configFromEnv({ ...env, AERE_KMS_ROOT_HSM: fsig, AERE_KMS_TOKEN: tok, AERE_KMS_DATA_DIR: path.join(T, 'date') });
|
||||
cer('serverul ia radacina din HSM (rootSource=hsm) si e chiar cea sigilata', cfg.rootSource === 'hsm' && cfg.rootKey === radacina.toString('hex'));
|
||||
const kms = openKms({ dataDir: cfg.dataDir, rootKey: cfg.rootKey });
|
||||
kms.createKey('client', { type: 'encrypt' });
|
||||
const c = kms.encrypt('client', 'date de pastrat', 'ctx').ciphertext;
|
||||
cer('KMS pornit din radacina HSM: runda hibrida X25519 + ML-KEM-768', kms.decrypt('client', c, 'ctx').plaintext.toString() === 'date de pastrat');
|
||||
kms.close();
|
||||
const cfg2 = configFromEnv({ ...env, AERE_KMS_ROOT_HSM: fsig, AERE_KMS_TOKEN: tok, AERE_KMS_DATA_DIR: path.join(T, 'date') });
|
||||
const kms2 = openKms({ dataDir: cfg2.dataDir, rootKey: cfg2.rootKey });
|
||||
cer('redeschis din HSM, KMS-ul descifreaza ce a cifrat inainte (aceeasi radacina)', kms2.decrypt('client', c, 'ctx').plaintext.toString() === 'date de pastrat');
|
||||
kms2.close();
|
||||
cer('amandoua sursele de radacina deodata -> ROOT_KEY_AMBIGUOUS', codul(() => configFromEnv({ ...env, AERE_KMS_ROOT_HSM: fsig, AERE_KMS_ROOT_KEY: radacina.toString('hex'), AERE_KMS_TOKEN: tok })) === 'ROOT_KEY_AMBIGUOUS');
|
||||
cer('sigilarea lipsa -> HSM_SEAL_INVALID', codul(() => radacinaDinHsm({ ...env, AERE_KMS_ROOT_HSM: path.join(T, 'nu-exista.json') })) === 'HSM_SEAL_INVALID');
|
||||
cer('cu PIN gresit serverul REFUZA sa porneasca (nu cade pe alta radacina)', codul(() => configFromEnv({ ...env, AERE_HSM_PIN: '999999', AERE_KMS_ROOT_HSM: fsig, AERE_KMS_TOKEN: tok })) === 'HSM_LOGIN_REFUSED');
|
||||
// /dev/shm curat dupa operatii: fisierele temporare cu radacina nu raman
|
||||
const ramase = fs.existsSync('/dev/shm') ? fs.readdirSync('/dev/shm').filter((x) => x.startsWith('aerekms-hsm-')) : [];
|
||||
cer('nicio urma a radacinii in /dev/shm dupa operatii', ramase.length === 0, ramase.join(','));
|
||||
} finally { fs.rmSync(T, { recursive: true, force: true }); }
|
||||
console.log(`\nradacina KMS sigilata de HSM (SoftHSM2 + OpenSC): ${n - rele}/${n} cum trebuia`);
|
||||
process.exitCode = rele ? 1 : 0;
|
||||
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user