141 lines
5.4 KiB
JavaScript
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'));
|
|
});
|
|
});
|
|
});
|