homeio

1import { randomBytes } from "node:crypto";
2import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
3
4const { mockEnv } = vi.hoisted(() => ({
5  mockEnv: {
6    AUTH_SESSION_SECRET: "test-session-secret-32-chars-long-aaaa",
7    AUTH_TOTP_ENCRYPTION_KEY: undefined as string | undefined,
8  },
9}));
10
11vi.mock("@/lib/server/env", () => ({
12  serverEnv: mockEnv,
13}));
14
15import {
16  decryptSecret,
17  encryptSecret,
18} from "@/lib/server/modules/auth/totp-crypto";
19
20const DEFAULT_SECRET = "test-session-secret-32-chars-long-aaaa";
21
22beforeEach(() => {
23  mockEnv.AUTH_SESSION_SECRET = DEFAULT_SECRET;
24  mockEnv.AUTH_TOTP_ENCRYPTION_KEY = undefined;
25});
26
27afterEach(() => {
28  vi.restoreAllMocks();
29});
30
31describe("totp-crypto", () => {
32  describe("encryptSecret / decryptSecret", () => {
33    it("round-trips a plaintext through the packed format", () => {
34      const plaintext = "JBSWY3DPEHPK3PXP";
35      const packed = encryptSecret(plaintext);
36
37      expect(packed).toMatch(/^[A-Za-z0-9+/=]+\.[A-Za-z0-9+/=]+\.[A-Za-z0-9+/=]+$/);
38      expect(decryptSecret(packed)).toBe(plaintext);
39    });
40
41    it("round-trips multi-byte UTF-8", () => {
42      const plaintext = "café — résumé — 🔐 backup\ncodes";
43      expect(decryptSecret(encryptSecret(plaintext))).toBe(plaintext);
44    });
45
46    it("produces a different ciphertext each call (random IV)", () => {
47      const plaintext = "JBSWY3DPEHPK3PXP";
48      const a = encryptSecret(plaintext);
49      const b = encryptSecret(plaintext);
50
51      expect(a).not.toBe(b);
52      expect(decryptSecret(a)).toBe(plaintext);
53      expect(decryptSecret(b)).toBe(plaintext);
54    });
55
56    it("rejects a packed string with the wrong number of parts", () => {
57      expect(() => decryptSecret("only.two")).toThrowError(
58        /Invalid encrypted secret format/,
59      );
60      expect(() => decryptSecret("a.b.c.d")).toThrowError(
61        /Invalid encrypted secret format/,
62      );
63    });
64
65    it("rejects an IV of the wrong length", () => {
66      const packed = encryptSecret("hello");
67      const [, cipherPart, tagPart] = packed.split(".");
68      // 8-byte IV — too short for AES-GCM-96.
69      const shortIv = Buffer.alloc(8, 0).toString("base64");
70      expect(() =>
71        decryptSecret(`${shortIv}.${cipherPart}.${tagPart}`),
72      ).toThrowError(/Invalid encrypted secret format/);
73    });
74
75    it("rejects a tag of the wrong length", () => {
76      const packed = encryptSecret("hello");
77      const [ivPart, cipherPart] = packed.split(".");
78      const shortTag = Buffer.alloc(8, 0).toString("base64");
79      expect(() =>
80        decryptSecret(`${ivPart}.${cipherPart}.${shortTag}`),
81      ).toThrowError(/Invalid encrypted secret format/);
82    });
83
84    it("throws when the ciphertext is tampered with", () => {
85      const packed = encryptSecret("hello");
86      const [ivPart, cipherPart, tagPart] = packed.split(".");
87
88      const tampered = Buffer.from(cipherPart, "base64");
89      tampered[0] = tampered[0] ^ 0xff;
90
91      expect(() =>
92        decryptSecret(`${ivPart}.${tampered.toString("base64")}.${tagPart}`),
93      ).toThrow();
94    });
95
96    it("throws when the tag is tampered with", () => {
97      const packed = encryptSecret("hello");
98      const [ivPart, cipherPart, tagPart] = packed.split(".");
99
100      const tampered = Buffer.from(tagPart, "base64");
101      tampered[0] = tampered[0] ^ 0xff;
102
103      expect(() =>
104        decryptSecret(`${ivPart}.${cipherPart}.${tampered.toString("base64")}`),
105      ).toThrow();
106    });
107  });
108
109  describe("key resolution", () => {
110    it("derives a key from AUTH_SESSION_SECRET when no explicit key is set", () => {
111      const packed = encryptSecret("secret");
112      expect(decryptSecret(packed)).toBe("secret");
113    });
114
115    it("cannot decrypt a ciphertext produced with a different AUTH_SESSION_SECRET", () => {
116      mockEnv.AUTH_SESSION_SECRET = "first-secret-32-chars-long-aaaaaaaaa";
117      const packed = encryptSecret("locked");
118
119      mockEnv.AUTH_SESSION_SECRET = "second-secret-32-chars-long-bbbbbbbb";
120      expect(() => decryptSecret(packed)).toThrow();
121    });
122
123    it("uses the explicit AUTH_TOTP_ENCRYPTION_KEY when provided", () => {
124      const explicitKey = randomBytes(32).toString("base64");
125      mockEnv.AUTH_TOTP_ENCRYPTION_KEY = explicitKey;
126
127      const packed = encryptSecret("explicit");
128      expect(decryptSecret(packed)).toBe("explicit");
129    });
130
131    it("produces a different ciphertext when the explicit key changes", () => {
132      const keyA = randomBytes(32).toString("base64");
133      const keyB = randomBytes(32).toString("base64");
134
135      mockEnv.AUTH_TOTP_ENCRYPTION_KEY = keyA;
136      const packedWithA = encryptSecret("rotate-me");
137
138      mockEnv.AUTH_TOTP_ENCRYPTION_KEY = keyB;
139      expect(() => decryptSecret(packedWithA)).toThrow();
140    });
141
142    it("rejects an explicit key that does not decode to 32 bytes", () => {
143      mockEnv.AUTH_TOTP_ENCRYPTION_KEY = Buffer.alloc(16, 0).toString("base64");
144      expect(() => encryptSecret("oops")).toThrowError(
145        /AUTH_TOTP_ENCRYPTION_KEY must decode to 32 bytes/,
146      );
147    });
148
149    it("ignores a whitespace-only AUTH_TOTP_ENCRYPTION_KEY and falls back to HKDF", () => {
150      mockEnv.AUTH_TOTP_ENCRYPTION_KEY = "   ";
151      const packed = encryptSecret("fallback");
152      expect(decryptSecret(packed)).toBe("fallback");
153    });
154  });
155});
156