serverless-ircd 0.9.0 → 0.11.0

package/packages/irc-core/tests/ports.test.ts

@@ -1,4 +1,5 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
+import { certIdentityFromSubject } from '../src/certfp';
 import {
   CapturingLogger,
   type Clock,
@@ -14,6 +15,7 @@ import {
   SequentialIdFactory,
   SystemClock,
   UuidIdFactory,
+  constantTimeEquals,
 } from '../src/ports';
 
 describe('SystemClock', () => {
@@ -54,6 +56,11 @@ describe('FakeClock', () => {
   });
 });
 
+// RFC 4122 v4 layout: 8-4-4-4-12 hex chars with the version nibble (M) fixed
+// to 4 and the variant nibble (N) constrained to 8-b. Used by the shape and
+// CSPRNG-sourcing tests below.
+const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
 describe('UuidIdFactory', () => {
   it('implements the IdFactory port', () => {
     const f: IdFactory = new UuidIdFactory();
@@ -74,6 +81,72 @@ describe('UuidIdFactory', () => {
     const f = new UuidIdFactory();
     expect(f.sessionId()).not.toBe(f.sessionId());
   });
+
+  it('emits RFC 4122 v4-shaped strings from every method', () => {
+    const f = new UuidIdFactory();
+    expect(f.batchId()).toMatch(UUID_V4_RE);
+    expect(f.nonce()).toMatch(UUID_V4_RE);
+    expect(f.sessionId()).toMatch(UUID_V4_RE);
+    expect(f.traceId()).toMatch(UUID_V4_RE);
+  });
+
+  it('does not consult Math.random (randomness comes from the CSPRNG)', () => {
+    // Regression guard: if a future change reverts to Math.random, mocking it
+    // to a constant would make the output deterministic. A CSPRNG-backed
+    // factory must not touch Math.random at all.
+    const original = Math.random;
+    let calls = 0;
+    Math.random = () => {
+      calls++;
+      return 0.5;
+    };
+    try {
+      const f = new UuidIdFactory();
+      const a = f.nonce();
+      const b = f.sessionId();
+      expect(calls).toBe(0);
+      expect(a).toMatch(UUID_V4_RE);
+      expect(b).toMatch(UUID_V4_RE);
+      // With Math.random pinned, a Math.random-backed impl would emit the
+      // same value every call; the CSPRNG emits two distinct values.
+      expect(a).not.toBe(b);
+    } finally {
+      Math.random = original;
+    }
+  });
+
+  it('produces hex digits indistinguishable from uniform (chi-square, CSPRNG regression guard)', () => {
+    // Regression guard against a biased or constant RNG. Counts the trailing
+    // 12 hex chars of each id — those bytes are 100% random in a UUIDv4 (the
+    // version nibble at index 14 and variant nibble at index 19 are
+    // structural and excluded from the bucket count). Buckets the chars by
+    // nibble value (0-15) and chi-squares against the uniform expectation.
+    //
+    // Non-determinism guard: the chi-square statistic for genuinely uniform
+    // input follows chi2 with 15 degrees of freedom (mean 15, stddev ~5.5).
+    // The chosen threshold (70) sits ~10σ above the mean — P(chi2_15 > 70) ≈
+    // 2e-9, i.e. effectively zero false-positives across billions of CI
+    // runs. A catastrophic revert (Math.random pinned to a constant) drives
+    // chi into the hundreds of millions, so headroom is enormous.
+    const f = new UuidIdFactory();
+    const N = 10_000;
+    const buckets = new Array<number>(16).fill(0);
+    for (let i = 0; i < N; i++) {
+      // Slice(24) is the trailing 'xxxxxxxxxxxx' group of the UUID string —
+      // 12 hex chars, all sourced from getRandomValues.
+      const tail = f.nonce().slice(24);
+      for (const c of tail) {
+        const idx = Number.parseInt(c, 16);
+        buckets[idx] = (buckets[idx] ?? 0) + 1;
+      }
+    }
+    const expected = (N * 12) / 16;
+    let chi = 0;
+    for (const observed of buckets) {
+      chi += (observed - expected) ** 2 / expected;
+    }
+    expect(chi).toBeLessThan(70);
+  });
 });
 
 describe('SequentialIdFactory', () => {
@@ -365,17 +438,22 @@ const _assertLogRecord: LogRecord = {
 void _assertLogRecord;
 
 describe('InMemoryMtlsIdentityProvider', () => {
-  it('returns the certificate subject for a known connection id', () => {
+  it('returns the certificate identity for a known connection id', () => {
     const provider = new InMemoryMtlsIdentityProvider([
-      { connId: 'c1', identity: 'CN=alice' },
-      { connId: 'c2', identity: 'CN=bob' },
+      { connId: 'c1', identity: certIdentityFromSubject('CN=alice') },
+      { connId: 'c2', identity: certIdentityFromSubject('CN=bob', 'ff11') },
     ]);
-    expect(provider.getIdentity('c1')).toBe('CN=alice');
-    expect(provider.getIdentity('c2')).toBe('CN=bob');
+    expect(provider.getIdentity('c1')).toEqual({
+      subject: 'CN=alice',
+      canonicalDn: 'cn=alice',
+    });
+    expect(provider.getIdentity('c2')?.fingerprint).toBe('ff11');
   });
 
   it('returns undefined for an unknown connection id', () => {
-    const provider = new InMemoryMtlsIdentityProvider([{ connId: 'c1', identity: 'CN=alice' }]);
+    const provider = new InMemoryMtlsIdentityProvider([
+      { connId: 'c1', identity: certIdentityFromSubject('CN=alice') },
+    ]);
     expect(provider.getIdentity('nope')).toBeUndefined();
   });
 
@@ -384,3 +462,88 @@ describe('InMemoryMtlsIdentityProvider', () => {
     expect(provider.getIdentity('c1')).toBeUndefined();
   });
 });
+
+// ============================================================================
+// constantTimeEquals — constant-time string equality
+// ============================================================================
+
+describe('constantTimeEquals', () => {
+  it('returns true for equal strings', () => {
+    expect(constantTimeEquals('s3cret', 's3cret')).toBe(true);
+  });
+
+  it('returns true for two empty strings', () => {
+    expect(constantTimeEquals('', '')).toBe(true);
+  });
+
+  it('returns false when the first character differs', () => {
+    expect(constantTimeEquals('X3cret', 's3cret')).toBe(false);
+  });
+
+  it('returns false when the last character differs', () => {
+    expect(constantTimeEquals('s3creX', 's3cret')).toBe(false);
+  });
+
+  it('returns false when the attempt is a proper prefix of the secret', () => {
+    expect(constantTimeEquals('s3cr', 's3cret')).toBe(false);
+  });
+
+  it('returns false when the attempt is longer than the secret', () => {
+    expect(constantTimeEquals('s3cret-extra', 's3cret')).toBe(false);
+  });
+
+  it('returns false for an empty attempt against a non-empty secret', () => {
+    expect(constantTimeEquals('', 's3cret')).toBe(false);
+  });
+
+  it('returns false for a non-empty attempt against an empty secret', () => {
+    expect(constantTimeEquals('s3cret', '')).toBe(false);
+  });
+
+  it('returns true for equal multi-byte strings', () => {
+    expect(constantTimeEquals('pässwörd', 'pässwörd')).toBe(true);
+  });
+
+  it('returns false for unequal multi-byte strings', () => {
+    expect(constantTimeEquals('pässwörd', 'password')).toBe(false);
+  });
+});
+
+// Deterministic timing-bucket proof: instead of measuring wall-clock time the
+// per-position read primitive (`charCodeAt`) is stubbed with a counter. A
+// constant-time compare reads every position of both inputs up to the longer
+// length, so the read count is identical across equal inputs, first-char
+// mismatches, last-char mismatches, and length mismatches of the same
+// magnitude — no distinguishable work bucket exists.
+describe('constantTimeEquals — timing buckets (deterministic read counts)', () => {
+  function countReads(a: string, b: string): number {
+    const spy = vi.spyOn(String.prototype, 'charCodeAt');
+    try {
+      constantTimeEquals(a, b);
+      return spy.mock.calls.length;
+    } finally {
+      spy.mockRestore();
+    }
+  }
+
+  it('reads every position of both inputs for same-length secrets (2 × length)', () => {
+    expect(countReads('s3cret', 's3cret')).toBe(12);
+    expect(countReads('X3cret', 's3cret')).toBe(12);
+    expect(countReads('s3creX', 's3cret')).toBe(12);
+    expect(countReads('s3c!et', 's3cret')).toBe(12);
+  });
+
+  it('reads the longer length even when the attempt is a length-mismatched prefix', () => {
+    expect(countReads('s3cr', 's3cret')).toBe(12);
+    expect(countReads('', 's3cret')).toBe(12);
+  });
+
+  it('reads the attempt length when the attempt is longer than the secret', () => {
+    expect(countReads('s3cret-longer', 's3cret')).toBe(26);
+    expect(countReads('X3cret-longer', 's3cret')).toBe(26);
+  });
+
+  it('spends zero reads on two empty strings', () => {
+    expect(countReads('', '')).toBe(0);
+  });
+});