FilesExpand file tree

main

/

totp.test.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

85 lines (69 loc) · 2.93 KB

main

/

totp.test.ts

Copy path

Top

File metadata and controls

• Code
• Blame

85 lines (69 loc) · 2.93 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

// SPDX-License-Identifier: AGPL-3.0-or-later

import assert from "node:assert/strict";

import test from "node:test";

import {

base32Decode,

base32Encode,

generateBackupCodes,

generateTotpCode,

generateTotpSecret,

generateTotpUri,

verifyAndConsumeBackupCode,

verifyTotpCode,

} from "../src/util/totp.js";

test("TOTP Utility - Base32 roundtrip", () => {

const original = Buffer.from("Hello ModelScript 2FA World!", "utf8");

const encoded = base32Encode(original);

assert.ok(encoded.length > 0);

const decoded = base32Decode(encoded);

assert.deepEqual(decoded, original);

});

test("TOTP Utility - Secret and URI generation", () => {

const secret = generateTotpSecret();

assert.strictEqual(secret.length, 32); // 20 bytes = 160 bits / 5 = 32 chars

assert.match(secret, /^[A-Z2-7]+$/);

const uri = generateTotpUri({

accountName: "alice@modelscript.org",

secret,

});

assert.ok(uri.startsWith("otpauth://totp/ModelScript:alice%40modelscript.org?"));

assert.ok(uri.includes(`secret=${secret}`));

assert.ok(uri.includes("digits=6"));

assert.ok(uri.includes("period=30"));

});

test("TOTP Utility - Code generation and verification with drift window", () => {

const secret = generateTotpSecret();

const now = Date.now();

const code = generateTotpCode(secret, now);

assert.strictEqual(code.length, 6);

assert.match(code, /^\d{6}$/);

// Verification at same timestamp

assert.strictEqual(verifyTotpCode(secret, code, 1, now), true);

// Verification within 30-second window drift

assert.strictEqual(verifyTotpCode(secret, code, 1, now + 25_000), true);

assert.strictEqual(verifyTotpCode(secret, code, 1, now - 25_000), true);

// Invalid code

assert.strictEqual(verifyTotpCode(secret, "000000" === code ? "999999" : "000000", 1, now), false);

// Malformed codes

assert.strictEqual(verifyTotpCode(secret, "abc", 1, now), false);

assert.strictEqual(verifyTotpCode(secret, "1234567", 1, now), false);

});

test("TOTP Utility - Single-use backup codes generation and consumption", () => {

const { plainCodes, hashedCodes } = generateBackupCodes(10);

assert.strictEqual(plainCodes.length, 10);

assert.strictEqual(hashedCodes.length, 10);

const codeToUse = plainCodes[0]!;

assert.match(codeToUse, /^[0-9A-F]{4}-[0-9A-F]{4}$/);

// Consume first code

const result1 = verifyAndConsumeBackupCode(codeToUse, hashedCodes);

assert.strictEqual(result1.valid, true);

assert.strictEqual(result1.remainingHashes.length, 9);

assert.strictEqual(result1.remainingHashes.includes(hashedCodes[0]!), false);

// Attempting to consume same code again should fail

const result2 = verifyAndConsumeBackupCode(codeToUse, result1.remainingHashes);

assert.strictEqual(result2.valid, false);

assert.strictEqual(result2.remainingHashes.length, 9);

// Invalid code consumption

const invalidResult = verifyAndConsumeBackupCode("FFFF-FFFF", result1.remainingHashes);

assert.strictEqual(invalidResult.valid, false);

});