a2host/test/unit/crypto.test.js

141 lines
5.4 KiB
JavaScript

import { describe, it } from 'node:test';
import assert from 'node:assert/strict';
import {
hashPassword,
verifyPassword,
signSession,
verifySession,
parseCookies,
serializeCookie
} from '../../src/utils/crypto.util.js';
describe('Unit Tests: Cryptographic Utilities (crypto.util.js)', () => {
const secretKey = 'super_secret_testing_key_at_least_32_chars!';
describe('Password Hashing with scrypt & Constant-Time Verification', () => {
it('debe generar un hash scrypt conforme al formato canónico scrypt$N$r$p$salt$hash', async () => {
const password = 'PasswordSegura2026!';
const hash = await hashPassword(password);
assert.ok(hash.startsWith('scrypt$16384$8$1$'), `El hash generado no tiene el prefijo esperado: ${hash}`);
const parts = hash.split('$');
assert.equal(parts.length, 6);
assert.equal(parts[1], '16384');
assert.equal(parts[2], '8');
assert.equal(parts[3], '1');
assert.equal(parts[4].length, 32); // 16 bytes en hex
assert.equal(parts[5].length, 128); // 64 bytes en hex
});
it('debe verificar exitosamente la contraseña correcta', async () => {
const password = 'ClaveDeAccesoCorrecta#1';
const hash = await hashPassword(password);
const isValid = await verifyPassword(password, hash);
assert.equal(isValid, true);
});
it('debe rechazar contraseñas incorrectas de forma segura', async () => {
const password = 'ClaveOriginal123';
const hash = await hashPassword(password);
const isValid = await verifyPassword('ClaveEquivocada456', hash);
assert.equal(isValid, false);
});
it('debe manejar hashes corruptos o inválidos sin lanzar excepciones no controladas', async () => {
assert.equal(await verifyPassword('test', 'not-a-valid-hash'), false);
assert.equal(await verifyPassword('test', 'scrypt$invalid$format'), false);
assert.equal(await verifyPassword('test', null), false);
assert.equal(await verifyPassword(null, 'scrypt$16384$8$1$salt$hash'), false);
});
});
describe('HMAC-SHA256 Session Signing & Verification', () => {
it('debe firmar el payload de sesión con HMAC-SHA256 bajo el formato s:<data>.<sig>', () => {
const payload = { userId: 'u-1234', username: 'admin', role: 'admin' };
const token = signSession(payload, secretKey);
assert.ok(token.startsWith('s:'), 'Debe iniciar con prefijo s:');
assert.ok(token.includes('.'), 'Debe contener un separador punto para la firma');
});
it('debe verificar y recuperar el payload idéntico con la clave correcta', () => {
const originalPayload = { userId: 'u-5678', username: 'operator1', role: 'operator' };
const token = signSession(originalPayload, secretKey);
const verified = verifySession(token, secretKey);
assert.deepEqual(verified, originalPayload);
});
it('debe rechazar tokens firmados con un secret diferente', () => {
const payload = { userId: 'u-1234', username: 'admin' };
const token = signSession(payload, secretKey);
const verified = verifySession(token, 'another_different_secret_key_32_chars!');
assert.equal(verified, null);
});
it('debe detectar alteraciones en el payload (Tampering)', () => {
const payload = { userId: 'u-1234', role: 'operator' };
const token = signSession(payload, secretKey);
// Alterar un caracter del cuerpo base64
const parts = token.slice(2).split('.');
const tamperedData = (parts[0][0] === 'e' ? 'X' : 'e') + parts[0].slice(1);
const tamperedToken = `s:${tamperedData}.${parts[1]}`;
const verified = verifySession(tamperedToken, secretKey);
assert.equal(verified, null);
});
it('debe rechazar tokens con firmas manipuladas', () => {
const payload = { userId: 'u-1234' };
const token = signSession(payload, secretKey);
const parts = token.slice(2).split('.');
const tamperedSignature = parts[1].slice(0, -1) + 'X';
const tamperedToken = `s:${parts[0]}.${tamperedSignature}`;
const verified = verifySession(tamperedToken, secretKey);
assert.equal(verified, null);
});
it('debe retornar null ante entradas malformadas o nulas', () => {
assert.equal(verifySession(null, secretKey), null);
assert.equal(verifySession('invalid-token', secretKey), null);
assert.equal(verifySession('s:no-signature', secretKey), null);
});
});
describe('Cookie Serialization & Parsing', () => {
it('debe parsear cabeceras Cookie correctamente', () => {
const cookieHeader = 'a2host_session=s%3Axyz.123; theme=dark; other=val';
const parsed = parseCookies(cookieHeader);
assert.equal(parsed.a2host_session, 's:xyz.123');
assert.equal(parsed.theme, 'dark');
assert.equal(parsed.other, 'val');
});
it('debe serializar Set-Cookie con flags mandatorios de seguridad', () => {
const serialized = serializeCookie('a2host_session', 's:xyz.123', {
path: '/',
httpOnly: true,
sameSite: 'Strict',
priority: 'High',
maxAge: 3600,
secure: true
});
assert.ok(serialized.includes('a2host_session=s%3Axyz.123'));
assert.ok(serialized.includes('Path=/'));
assert.ok(serialized.includes('HttpOnly'));
assert.ok(serialized.includes('SameSite=Strict'));
assert.ok(serialized.includes('Priority=High'));
assert.ok(serialized.includes('Max-Age=3600'));
assert.ok(serialized.includes('Secure'));
});
});
});