205 lines
9.7 KiB
TypeScript
205 lines
9.7 KiB
TypeScript
// @vitest-environment node
|
||
import { beforeEach, describe, expect, test } from "vitest";
|
||
|
||
const codePattern = /^[23456789ABCDEFGHJKLMNPQRSTUVWXYZ]{4}-[23456789ABCDEFGHJKLMNPQRSTUVWXYZ]{4}-[23456789ABCDEFGHJKLMNPQRSTUVWXYZ]{4}$/;
|
||
|
||
describe("recovery-codes.server", () => {
|
||
beforeEach(() => {
|
||
process.env.CRYPTO_SECRET = "test-recovery-code-secret";
|
||
});
|
||
|
||
test("generates the default count of unique human-readable codes with hash-only storage entries", async () => {
|
||
const { DEFAULT_RECOVERY_CODE_COUNT, generateRecoveryCodes } = await import("./recovery-codes.server");
|
||
const generatedAt = new Date("2026-05-08T14:00:00.000Z");
|
||
|
||
const result = generateRecoveryCodes({ now: generatedAt });
|
||
|
||
expect(result.codes).toHaveLength(DEFAULT_RECOVERY_CODE_COUNT);
|
||
expect(new Set(result.codes).size).toBe(DEFAULT_RECOVERY_CODE_COUNT);
|
||
expect(result.codes).toEqual(Array.from({ length: DEFAULT_RECOVERY_CODE_COUNT }, () => expect.stringMatching(codePattern)));
|
||
expect(result.generatedAt).toBe(generatedAt);
|
||
expect(result.entries).toHaveLength(DEFAULT_RECOVERY_CODE_COUNT);
|
||
for (const [index, entry] of result.entries.entries()) {
|
||
expect(entry).toEqual({ hash: expect.stringMatching(/^[a-f0-9]{64}$/), usedAt: null, createdAt: generatedAt });
|
||
expect(entry.hash).not.toBe(result.codes[index]);
|
||
expect(JSON.stringify(entry)).not.toContain(result.codes[index]);
|
||
}
|
||
});
|
||
|
||
test("normalizes code input and verifies hashes with constant-length safe comparison", async () => {
|
||
const { hashRecoveryCode, normalizeRecoveryCode, verifyRecoveryCodeHash } = await import("./recovery-codes.server");
|
||
const code = "2345-6789-ABCD";
|
||
const hash = hashRecoveryCode(code);
|
||
|
||
expect(normalizeRecoveryCode(" 2345 6789 abcd ")).toBe(code);
|
||
expect(hash).toMatch(/^[a-f0-9]{64}$/);
|
||
expect(verifyRecoveryCodeHash("23456789abcd", hash!)).toBe(true);
|
||
expect(verifyRecoveryCodeHash("2345-6789-ABCE", hash!)).toBe(false);
|
||
expect(verifyRecoveryCodeHash("2345-6789-ABCD", "abcd")).toBe(false);
|
||
});
|
||
|
||
test("rejects malformed input before hashing or verification", async () => {
|
||
const { hashRecoveryCode, normalizeRecoveryCode, verifyRecoveryCodeHash } = await import("./recovery-codes.server");
|
||
|
||
expect(normalizeRecoveryCode("")).toBeNull();
|
||
expect(normalizeRecoveryCode("1234-5678-ABCD")).toBeNull();
|
||
expect(normalizeRecoveryCode("2345-6789-ABC")).toBeNull();
|
||
expect(normalizeRecoveryCode("2345-6789-ABCI")).toBeNull();
|
||
expect(hashRecoveryCode("2345-6789-ABCI")).toBeNull();
|
||
expect(verifyRecoveryCodeHash("2345-6789-ABCI", "00".repeat(32))).toBe(false);
|
||
});
|
||
|
||
test("consumes a valid recovery code once and rejects replay", async () => {
|
||
const { consumeRecoveryCode, generateRecoveryCodes } = await import("./recovery-codes.server");
|
||
const generated = generateRecoveryCodes({ count: 2, now: new Date("2026-05-08T14:00:00.000Z") });
|
||
const firstUseAt = new Date("2026-05-08T14:05:00.000Z");
|
||
const replayAt = new Date("2026-05-08T14:06:00.000Z");
|
||
|
||
const firstUse = consumeRecoveryCode(generated.entries, generated.codes[0], { now: firstUseAt });
|
||
const replay = consumeRecoveryCode(firstUse.entries, generated.codes[0], { now: replayAt });
|
||
const wrongCode = consumeRecoveryCode(firstUse.entries, "2345-6789-ABCD", { now: replayAt });
|
||
|
||
expect(firstUse.matched).toBe(true);
|
||
expect(firstUse.usedAt).toBe(firstUseAt);
|
||
expect(firstUse.entries[0].usedAt).toBe(firstUseAt);
|
||
expect(firstUse.entries[1].usedAt).toBeNull();
|
||
expect(replay).toEqual({ matched: false, entries: firstUse.entries, usedAt: null });
|
||
expect(wrongCode).toEqual({ matched: false, entries: firstUse.entries, usedAt: null });
|
||
});
|
||
|
||
test("generation does not loop indefinitely: succeeds on the first attempt under healthy entropy", async () => {
|
||
const { generateRecoveryCodes, DEFAULT_RECOVERY_CODE_COUNT } = await import("./recovery-codes.server");
|
||
|
||
const result = generateRecoveryCodes();
|
||
|
||
expect(result.codes).toHaveLength(DEFAULT_RECOVERY_CODE_COUNT);
|
||
expect(new Set(result.codes).size).toBe(DEFAULT_RECOVERY_CODE_COUNT);
|
||
});
|
||
|
||
test("generation completes in bounded time even when asked for the maximum count (no rejection-sampling loop)", async () => {
|
||
const { generateRecoveryCodes } = await import("./recovery-codes.server");
|
||
|
||
// The legacy implementation rebuilt a `Set` with the codes and looped
|
||
// until uniqueness — pathological under bad entropy. We assert a strict
|
||
// wall-clock bound to catch any regression that re-introduces unbounded
|
||
// looping.
|
||
const start = Date.now();
|
||
const result = generateRecoveryCodes({ count: 50 });
|
||
const elapsed = Date.now() - start;
|
||
|
||
expect(result.codes).toHaveLength(50);
|
||
expect(new Set(result.codes).size).toBe(50);
|
||
expect(elapsed).toBeLessThan(500);
|
||
});
|
||
|
||
test("status helpers redact raw codes and hashes when serialized", async () => {
|
||
const { consumeRecoveryCode, generateRecoveryCodes, getRecoveryCodeStatus } = await import("./recovery-codes.server");
|
||
const generatedAt = new Date("2026-05-08T14:00:00.000Z");
|
||
const usedAt = new Date("2026-05-08T14:10:00.000Z");
|
||
const generated = generateRecoveryCodes({ count: 3, now: generatedAt });
|
||
const consumed = consumeRecoveryCode(generated.entries, generated.codes[1], { now: usedAt });
|
||
|
||
const status = getRecoveryCodeStatus(consumed.entries);
|
||
const serialized = JSON.stringify(status);
|
||
|
||
expect(status).toEqual({
|
||
configured: true,
|
||
totalCount: 3,
|
||
remainingCount: 2,
|
||
usedCount: 1,
|
||
generatedAt,
|
||
lastUsedAt: usedAt,
|
||
});
|
||
for (const code of generated.codes) {
|
||
expect(serialized).not.toContain(code);
|
||
}
|
||
for (const entry of generated.entries) {
|
||
expect(serialized).not.toContain(entry.hash);
|
||
}
|
||
expect(serialized).not.toMatch(/hash|code|secret/i);
|
||
});
|
||
|
||
test("status helper reports an unconfigured state for null or undefined entries", async () => {
|
||
const { getRecoveryCodeStatus } = await import("./recovery-codes.server");
|
||
|
||
expect(getRecoveryCodeStatus(null)).toEqual({
|
||
configured: false,
|
||
totalCount: 0,
|
||
remainingCount: 0,
|
||
usedCount: 0,
|
||
generatedAt: null,
|
||
lastUsedAt: null,
|
||
});
|
||
expect(getRecoveryCodeStatus(undefined, { generatedAt: null, lastUsedAt: null })).toEqual({
|
||
configured: false,
|
||
totalCount: 0,
|
||
remainingCount: 0,
|
||
usedCount: 0,
|
||
generatedAt: null,
|
||
lastUsedAt: null,
|
||
});
|
||
});
|
||
|
||
test("consumeRecoveryCode rejects malformed codes and uses the current time when no now option is supplied", async () => {
|
||
const { consumeRecoveryCode, generateRecoveryCodes } = await import("./recovery-codes.server");
|
||
const generated = generateRecoveryCodes({ count: 1, now: new Date("2026-05-08T14:00:00.000Z") });
|
||
|
||
expect(consumeRecoveryCode(generated.entries, "bad-code")).toEqual({
|
||
matched: false,
|
||
entries: generated.entries,
|
||
usedAt: null,
|
||
});
|
||
|
||
const consumed = consumeRecoveryCode(generated.entries, generated.codes[0]);
|
||
expect(consumed.matched).toBe(true);
|
||
expect(consumed.usedAt).toBeInstanceOf(Date);
|
||
expect(consumed.entries[0].usedAt).toBe(consumed.usedAt);
|
||
});
|
||
|
||
test("rejects non-positive and non-integer count, segment, and segment-length parameters", async () => {
|
||
const { generateRecoveryCode, generateRecoveryCodes, normalizeRecoveryCode } = await import("./recovery-codes.server");
|
||
|
||
// Integer-but-non-positive values reach the `value <= 0` guard branch...
|
||
expect(() => generateRecoveryCode({ segments: 0 })).toThrow("segments must be a positive integer");
|
||
expect(() => generateRecoveryCode({ segmentLength: -1 })).toThrow("segmentLength must be a positive integer");
|
||
expect(() => generateRecoveryCodes({ count: 0 })).toThrow("count must be a positive integer");
|
||
expect(() => normalizeRecoveryCode("2345-6789-ABCD", { segments: 0 })).toThrow("segments must be a positive integer");
|
||
expect(() => normalizeRecoveryCode("2345-6789-ABCD", { segmentLength: 0 })).toThrow("segmentLength must be a positive integer");
|
||
// ...while a fractional value trips the `!Number.isInteger(value)` guard first.
|
||
expect(() => generateRecoveryCode({ segments: 2.5 })).toThrow("segments must be a positive integer");
|
||
});
|
||
|
||
test("generateRecoveryCode honours explicit shapes and falls back to the default segment layout", async () => {
|
||
const { generateRecoveryCode } = await import("./recovery-codes.server");
|
||
|
||
// No options → both `??` defaults are exercised (3 segments × 4 chars).
|
||
expect(generateRecoveryCode()).toMatch(codePattern);
|
||
// Explicit options → the provided values win over the defaults.
|
||
expect(generateRecoveryCode({ segments: 2, segmentLength: 5 })).toMatch(
|
||
/^[23456789ABCDEFGHJKLMNPQRSTUVWXYZ]{5}-[23456789ABCDEFGHJKLMNPQRSTUVWXYZ]{5}$/,
|
||
);
|
||
});
|
||
|
||
test("status helper keeps the most recent usage timestamp and stays null-safe when the first entry lacks a creation date", async () => {
|
||
const { getRecoveryCodeStatus } = await import("./recovery-codes.server");
|
||
|
||
// Two used entries with the later one first forces the reduce to keep the
|
||
// running `latest` (the `entry > latest` comparison resolves to false), and
|
||
// an undefined `createdAt` on the first entry exercises the `?? null`
|
||
// fallback for `generatedAt`.
|
||
const entries = [
|
||
{ hash: "aa", usedAt: new Date("2026-05-08T10:00:00.000Z"), createdAt: undefined as unknown as Date },
|
||
{ hash: "bb", usedAt: new Date("2026-05-08T09:00:00.000Z"), createdAt: new Date("2026-05-08T08:00:00.000Z") },
|
||
];
|
||
|
||
expect(getRecoveryCodeStatus(entries)).toEqual({
|
||
configured: true,
|
||
totalCount: 2,
|
||
remainingCount: 0,
|
||
usedCount: 2,
|
||
generatedAt: null,
|
||
lastUsedAt: new Date("2026-05-08T10:00:00.000Z"),
|
||
});
|
||
});
|
||
});
|