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,333 @@
|
||||
// server.mjs - serverul HTTP al Aere PQ KMS (node:http, fara dependinte).
|
||||
//
|
||||
// Mediu:
|
||||
// AERE_KMS_ROOT_KEY 64 de caractere hexa (32 de octeti), SAU:
|
||||
// AERE_KMS_ROOT_HSM calea radacinii SIGILATE de un HSM (hsm-radacina.mjs), deschisa la pornire cu PIN-ul din AERE_HSM_PIN;
|
||||
// exact una din cele doua; fara niciuna refuza pornirea, cu amandoua refuza (ROOT_KEY_AMBIGUOUS)
|
||||
// AERE_KMS_TOKEN obligatoriu, cel putin 32 de caractere; se cere ca "Authorization: Bearer <token>"
|
||||
// AERE_KMS_HOST implicit 127.0.0.1
|
||||
// AERE_KMS_PORT implicit 8420
|
||||
// AERE_KMS_MAX_BODY implicit 65536 (octeti)
|
||||
// AERE_KMS_DATA_DIR implicit ./data langa acest fisier
|
||||
//
|
||||
// Nicio valoare din mediu nu se tipareste. Raspunsurile de eroare sunt { error: COD, message }.
|
||||
|
||||
import http from 'node:http';
|
||||
import crypto from 'node:crypto';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath, pathToFileURL } from 'node:url';
|
||||
import { openKms, parseRootKey, KmsError } from './kms.mjs';
|
||||
import { radacinaDinHsm } from './hsm-radacina.mjs';
|
||||
|
||||
const HERE = path.dirname(fileURLToPath(import.meta.url));
|
||||
|
||||
const STATUS = {
|
||||
NOT_FOUND: 404,
|
||||
KEY_NOT_FOUND: 404,
|
||||
METHOD_NOT_ALLOWED: 405,
|
||||
KEY_EXISTS: 409,
|
||||
KEY_NOT_EXPORTABLE: 403,
|
||||
UNAUTHENTICATED: 401,
|
||||
INVALID_TOKEN: 401,
|
||||
BODY_TOO_LARGE: 413,
|
||||
UNSUPPORTED_MEDIA_TYPE: 415,
|
||||
INTERNAL: 500,
|
||||
AUDIT_WRITE_FAILED: 500,
|
||||
SEAL_AUTH_FAILED: 500,
|
||||
KEY_FILE_TAMPERED: 500,
|
||||
KMS_CLOSED: 503,
|
||||
};
|
||||
|
||||
class HttpError extends Error {
|
||||
constructor(status, code, message) {
|
||||
super(message);
|
||||
this.status = status;
|
||||
this.code = code;
|
||||
}
|
||||
}
|
||||
|
||||
export function configFromEnv(env, optiuniHsm = {}) {
|
||||
const token = String(env.AERE_KMS_TOKEN ?? '').trim();
|
||||
if (token === '') throw new KmsError('TOKEN_MISSING', 'AERE_KMS_TOKEN is not set; refusing to start');
|
||||
if (token.length < 32) throw new KmsError('TOKEN_TOO_SHORT', `AERE_KMS_TOKEN must be at least 32 characters; the value given has ${token.length}`);
|
||||
if (!/^[\x21-\x7e]+$/.test(token)) throw new KmsError('TOKEN_INVALID', 'AERE_KMS_TOKEN must be printable ASCII without spaces');
|
||||
// Validam cheia radacina aici, ca serverul sa nu porneasca deloc fara ea. Din 2026-09-28 poate veni si SIGILATA de un HSM.
|
||||
const inClar = String(env.AERE_KMS_ROOT_KEY ?? '').trim() !== '', dinHsm = String(env.AERE_KMS_ROOT_HSM ?? '').trim() !== '';
|
||||
if (inClar && dinHsm) throw new KmsError('ROOT_KEY_AMBIGUOUS', 'set AERE_KMS_ROOT_KEY or AERE_KMS_ROOT_HSM, not both');
|
||||
const rootHex = dinHsm ? radacinaDinHsm(env, optiuniHsm) : env.AERE_KMS_ROOT_KEY;
|
||||
const root = parseRootKey(rootHex);
|
||||
const sameAsRoot = token.toLowerCase() === root.toString('hex');
|
||||
root.fill(0);
|
||||
if (sameAsRoot) throw new KmsError('TOKEN_EQUALS_ROOT_KEY', 'AERE_KMS_TOKEN must not be the root key');
|
||||
const host = String(env.AERE_KMS_HOST ?? '').trim() || '127.0.0.1';
|
||||
const portRaw = String(env.AERE_KMS_PORT ?? '').trim() || '8420';
|
||||
const port = Number(portRaw);
|
||||
if (!Number.isInteger(port) || port < 0 || port > 65535) throw new KmsError('INVALID_PORT', 'AERE_KMS_PORT must be an integer between 0 and 65535');
|
||||
const maxRaw = String(env.AERE_KMS_MAX_BODY ?? '').trim() || '65536';
|
||||
const maxBody = Number(maxRaw);
|
||||
// Sub 8192 nu incape nici o cerere de verificare (semnatura hibrida are 4531 de caractere base64).
|
||||
if (!Number.isInteger(maxBody) || maxBody < 8192 || maxBody > 16 * 1024 * 1024) {
|
||||
throw new KmsError('INVALID_MAX_BODY', 'AERE_KMS_MAX_BODY must be an integer between 8192 and 16777216');
|
||||
}
|
||||
const dataDir = String(env.AERE_KMS_DATA_DIR ?? '').trim() || path.join(HERE, 'data');
|
||||
return { token, rootKey: rootHex, rootSource: dinHsm ? 'hsm' : 'env', host, port, maxBody, dataDir };
|
||||
}
|
||||
|
||||
function tooBig(n, maxBody) {
|
||||
return n > maxBody;
|
||||
}
|
||||
|
||||
function authCheck(req, tokenHash) {
|
||||
const header = req.headers['authorization'];
|
||||
if (typeof header !== 'string' || header === '') return 'UNAUTHENTICATED';
|
||||
const m = /^Bearer ([\x21-\x7e]+)$/.exec(header);
|
||||
if (!m) return 'INVALID_TOKEN';
|
||||
const got = crypto.createHash('sha256').update(m[1], 'utf8').digest();
|
||||
if (!crypto.timingSafeEqual(got, tokenHash)) return 'INVALID_TOKEN';
|
||||
return null;
|
||||
}
|
||||
|
||||
// Arunca restul corpului fara sa-l tina in memorie; peste plafon inchide conexiunea.
|
||||
function discard(req, cap) {
|
||||
let n = 0;
|
||||
req.on('data', (c) => {
|
||||
n += c.length;
|
||||
if (n > cap) req.destroy();
|
||||
});
|
||||
req.on('error', () => {});
|
||||
req.resume();
|
||||
}
|
||||
|
||||
function readBody(req, maxBody) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const declared = req.headers['content-length'];
|
||||
if (declared !== undefined) {
|
||||
const n = Number(declared);
|
||||
if (!Number.isSafeInteger(n) || n < 0) return reject(new HttpError(400, 'INVALID_CONTENT_LENGTH', 'invalid Content-Length'));
|
||||
if (tooBig(n, maxBody)) return reject(new HttpError(413, 'BODY_TOO_LARGE', `request body is larger than ${maxBody} bytes`));
|
||||
}
|
||||
const chunks = [];
|
||||
let size = 0;
|
||||
let done = false;
|
||||
req.on('data', (c) => {
|
||||
if (done) return;
|
||||
size += c.length;
|
||||
if (tooBig(size, maxBody)) {
|
||||
done = true;
|
||||
chunks.length = 0;
|
||||
reject(new HttpError(413, 'BODY_TOO_LARGE', `request body is larger than ${maxBody} bytes`));
|
||||
return;
|
||||
}
|
||||
chunks.push(c);
|
||||
});
|
||||
req.on('end', () => {
|
||||
if (!done) {
|
||||
done = true;
|
||||
resolve(Buffer.concat(chunks));
|
||||
}
|
||||
});
|
||||
req.on('error', () => {
|
||||
if (!done) {
|
||||
done = true;
|
||||
reject(new HttpError(400, 'BAD_REQUEST', 'the request body could not be read'));
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function send(res, status, obj, close = false) {
|
||||
const body = JSON.stringify(obj);
|
||||
const headers = {
|
||||
'content-type': 'application/json; charset=utf-8',
|
||||
'content-length': Buffer.byteLength(body),
|
||||
'cache-control': 'no-store',
|
||||
'x-content-type-options': 'nosniff',
|
||||
};
|
||||
if (close) headers.connection = 'close';
|
||||
res.writeHead(status, headers);
|
||||
res.end(body);
|
||||
}
|
||||
|
||||
function b64Field(obj, field, { optional = false } = {}) {
|
||||
const v = obj[field];
|
||||
if (v === undefined || v === null) {
|
||||
if (optional) return undefined;
|
||||
throw new HttpError(400, 'MISSING_FIELD', `field "${field}" is required`);
|
||||
}
|
||||
if (typeof v !== 'string' || !/^[A-Za-z0-9+/]*={0,2}$/.test(v) || v.length % 4 !== 0) {
|
||||
throw new HttpError(400, 'INVALID_BASE64', `field "${field}" must be standard base64`);
|
||||
}
|
||||
const b = Buffer.from(v, 'base64');
|
||||
if (b.toString('base64') !== v) throw new HttpError(400, 'INVALID_BASE64', `field "${field}" must be canonical base64`);
|
||||
return b;
|
||||
}
|
||||
|
||||
function strField(obj, field) {
|
||||
const v = obj[field];
|
||||
if (typeof v !== 'string') throw new HttpError(400, 'MISSING_FIELD', `field "${field}" is required and must be a string`);
|
||||
return v;
|
||||
}
|
||||
|
||||
export function createServer({ kms, token, maxBody = 65536 }) {
|
||||
if (typeof token !== 'string' || token.length < 32) throw new KmsError('TOKEN_TOO_SHORT', 'token must be at least 32 characters');
|
||||
const tokenHash = crypto.createHash('sha256').update(token, 'utf8').digest();
|
||||
const drainCap = maxBody * 4 + 1024 * 1024;
|
||||
|
||||
async function handle(req, res) {
|
||||
let url;
|
||||
try {
|
||||
url = new URL(req.url, 'http://localhost');
|
||||
} catch {
|
||||
discard(req, drainCap);
|
||||
return send(res, 400, { error: 'BAD_REQUEST', message: 'invalid request URL' }, true);
|
||||
}
|
||||
const method = req.method;
|
||||
const parts = url.pathname.split('/').filter((p) => p !== '');
|
||||
|
||||
if (method === 'GET' && url.pathname === '/v1/health') {
|
||||
discard(req, drainCap);
|
||||
return send(res, 200, { ok: true });
|
||||
}
|
||||
|
||||
// Autentificarea se face INAINTE de a citi corpul.
|
||||
const authErr = authCheck(req, tokenHash);
|
||||
if (authErr) {
|
||||
discard(req, drainCap);
|
||||
return send(res, 401, { error: authErr, message: authErr === 'UNAUTHENTICATED' ? 'missing bearer token' : 'invalid bearer token' }, true);
|
||||
}
|
||||
|
||||
let body = null;
|
||||
if (method === 'POST') {
|
||||
const ctype = String(req.headers['content-type'] ?? '');
|
||||
let raw;
|
||||
try {
|
||||
raw = await readBody(req, maxBody);
|
||||
} catch (e) {
|
||||
discard(req, drainCap);
|
||||
throw e;
|
||||
}
|
||||
if (raw.length > 0 && ctype !== '' && !/^application\/json\b/i.test(ctype)) {
|
||||
throw new HttpError(415, 'UNSUPPORTED_MEDIA_TYPE', 'request body must be application/json');
|
||||
}
|
||||
if (raw.length === 0) body = {};
|
||||
else {
|
||||
try {
|
||||
body = JSON.parse(raw.toString('utf8'));
|
||||
} catch {
|
||||
throw new HttpError(400, 'INVALID_JSON', 'request body is not valid JSON');
|
||||
}
|
||||
}
|
||||
if (!body || typeof body !== 'object' || Array.isArray(body)) throw new HttpError(400, 'INVALID_JSON', 'request body must be a JSON object');
|
||||
} else {
|
||||
discard(req, drainCap);
|
||||
}
|
||||
|
||||
const name = parts[2] !== undefined ? decodeURIComponent(parts[2]) : undefined;
|
||||
if (parts[0] !== 'v1') throw new HttpError(404, 'NOT_FOUND', 'no such route');
|
||||
|
||||
// /v1/keys
|
||||
if (parts[1] === 'keys') {
|
||||
if (parts.length === 2 && method === 'GET') return send(res, 200, { keys: kms.listKeys() });
|
||||
if (parts.length === 3 && method === 'POST') {
|
||||
const exportable = body.exportable === undefined ? false : body.exportable;
|
||||
return send(res, 200, kms.createKey(name, { type: body.type, exportable }));
|
||||
}
|
||||
if (parts.length === 3 && method === 'GET') return send(res, 200, kms.getKey(name));
|
||||
if (parts.length === 4 && parts[3] === 'rotate' && method === 'POST') return send(res, 200, kms.rotate(name));
|
||||
if (parts.length === 4 && parts[3] === 'config' && method === 'POST') {
|
||||
return send(res, 200, kms.setMinDecryptionVersion(name, body.min_decryption_version));
|
||||
}
|
||||
if ((parts.length === 4 || parts.length === 5) && parts[3] === 'export' && method === 'GET') {
|
||||
let ver;
|
||||
if (parts.length === 5) {
|
||||
if (!/^[1-9][0-9]{0,8}$/.test(parts[4])) throw new HttpError(400, 'INVALID_VERSION', 'version must be a positive integer');
|
||||
ver = Number(parts[4]);
|
||||
}
|
||||
return send(res, 200, kms.exportKey(name, ver));
|
||||
}
|
||||
}
|
||||
|
||||
if (parts.length === 3 && method === 'POST') {
|
||||
switch (parts[1]) {
|
||||
case 'encrypt': {
|
||||
const r = kms.encrypt(name, b64Field(body, 'plaintext'), b64Field(body, 'aad', { optional: true }));
|
||||
return send(res, 200, r);
|
||||
}
|
||||
case 'decrypt': {
|
||||
const r = kms.decrypt(name, strField(body, 'ciphertext'), b64Field(body, 'aad', { optional: true }));
|
||||
const out = { plaintext: r.plaintext.toString('base64'), version: r.version };
|
||||
r.plaintext.fill(0);
|
||||
return send(res, 200, out);
|
||||
}
|
||||
case 'rewrap':
|
||||
return send(res, 200, kms.rewrap(name, strField(body, 'ciphertext'), b64Field(body, 'aad', { optional: true })));
|
||||
case 'datakey': {
|
||||
const includePlaintext = body.include_plaintext === undefined ? true : body.include_plaintext;
|
||||
const bits = body.bits === undefined ? 256 : body.bits;
|
||||
return send(res, 200, kms.datakey(name, { aad: b64Field(body, 'aad', { optional: true }), bits, includePlaintext }));
|
||||
}
|
||||
case 'sign':
|
||||
return send(res, 200, kms.sign(name, b64Field(body, 'message')));
|
||||
case 'verify':
|
||||
return send(res, 200, kms.verify(name, b64Field(body, 'message'), strField(body, 'signature')));
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (parts.length === 3 && parts[1] === 'audit' && parts[2] === 'verify' && method === 'GET') {
|
||||
return send(res, 200, kms.verifyAudit());
|
||||
}
|
||||
|
||||
throw new HttpError(404, 'NOT_FOUND', 'no such route');
|
||||
}
|
||||
|
||||
const server = http.createServer((req, res) => {
|
||||
handle(req, res).catch((e) => {
|
||||
if (res.headersSent) {
|
||||
res.destroy();
|
||||
return;
|
||||
}
|
||||
if (e instanceof HttpError) return send(res, e.status, { error: e.code, message: e.message }, e.status === 413);
|
||||
if (e instanceof KmsError) return send(res, STATUS[e.code] ?? 400, { error: e.code, message: e.message });
|
||||
if (e instanceof URIError) return send(res, 400, { error: 'BAD_REQUEST', message: 'invalid percent-encoding in path' });
|
||||
return send(res, 500, { error: 'INTERNAL', message: 'internal error' });
|
||||
});
|
||||
});
|
||||
server.headersTimeout = 10_000;
|
||||
server.requestTimeout = 30_000;
|
||||
return server;
|
||||
}
|
||||
|
||||
async function main() {
|
||||
let cfg;
|
||||
let kms;
|
||||
try {
|
||||
cfg = configFromEnv(process.env);
|
||||
kms = openKms({ dataDir: cfg.dataDir, rootKey: cfg.rootKey });
|
||||
} catch (e) {
|
||||
const code = e instanceof KmsError ? e.code : 'INTERNAL';
|
||||
const msg = e instanceof KmsError ? e.message : 'internal error';
|
||||
process.stderr.write(`aere-pq-kms: refusing to start: ${code}: ${msg}\n`);
|
||||
process.exitCode = 1;
|
||||
return;
|
||||
}
|
||||
const server = createServer({ kms, token: cfg.token, maxBody: cfg.maxBody });
|
||||
server.on('error', (e) => {
|
||||
process.stderr.write(`aere-pq-kms: server error: ${e.code ?? 'ERROR'}\n`);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
server.listen(cfg.port, cfg.host, () => {
|
||||
const a = server.address();
|
||||
process.stdout.write(`aere-pq-kms: listening on ${a.address}:${a.port}\n`);
|
||||
});
|
||||
const stop = () => {
|
||||
server.close(() => kms.close());
|
||||
};
|
||||
process.on('SIGINT', stop);
|
||||
process.on('SIGTERM', stop);
|
||||
}
|
||||
|
||||
if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) {
|
||||
main();
|
||||
}
|
||||
Reference in new issue
Block a user