Files
skills/docs/security-stack/security/srp/src/groups/groups-2048.md
2026-05-29 08:20:56 +01:00

8.0 KiB
Raw Blame History

groups-2048

(no submodules)

Purpose

The bundled 2048-bit safe-prime group from RFC 5054 Appendix A. This is the default SRP-6a group every consumer of @suaveplan/srp gets without any additional import: N_2048 is a 256-byte modulus, g_2048 is the single byte 0x02, and BIT_LENGTH is the literal 2048. RFC 5054 deliberately bundles a small set of fixed safe primes to side-step trust-on-first-use over arbitrary moduli; we ship the 2048-bit one as the default because it sits at the contemporary security floor while keeping a 2048-bit modPow cheap enough (~5–20 ms) for an interactive login.

Features

  • N_2048 byte-exact to RFC 5054 Appendix A "2048-bit Group" literal.
  • g_2048 equal to Uint8Array([2]).
  • BIT_LENGTH literal-typed 2048.
  • Frozen Uint8Arrays — consumers cannot mutate the shared constant.
  • Reachable from the root @suaveplan/srp barrel AND from @suaveplan/srp/groups.

Usage: Basic Example

import { N_2048, g_2048, BIT_LENGTH } from "@suaveplan/srp/groups";

console.log(N_2048.byteLength); // 256
console.log(g_2048[0]); // 2
console.log(BIT_LENGTH); // 2048

Usage: Advanced Example

import { N_2048, g_2048 } from "@suaveplan/srp/groups";
import { defaultHashBridge } from "@suaveplan/srp/hash";
import { params2048Sha256 } from "@suaveplan/srp/params";

const params = params2048Sha256(defaultHashBridge("SHA256"));
// params.N is the same shared reference as N_2048.
// Use this params object for client + server handshakes.

API Reference

Export Type Description
N_2048 Uint8Array 256-byte modulus from RFC 5054 Appendix A.
g_2048 Uint8Array Single-byte generator 0x02.
BIT_LENGTH 2048 Literal bit length of N_2048.

Implementation Notes

The modulus is encoded as a hex literal in source rather than embedded as a base64 blob so a human reader can diff it against RFC 5054 Appendix A line-by-line. The hex string is split into eight 64-char chunks matching the eight rows the RFC prints. The byte-exact unit test (groups-2048.test.ts) reconstructs the same hex from the Uint8Array, uppercases it, and asserts equality against the same literal.

g_2048 is Uint8Array([2]) rather than a bigint because every place SRP mixes group elements into a hash uses PAD(g) over the group modulus; expressing g as a one-byte buffer up-front avoids a runtime bigint-to-bytes conversion at every hash site. The single-byte representation also matches the byte-shape every Uint8Array-keyed helper in this package expects.

The BIT_LENGTH literal is typed 2048 (not number) so consumers narrowing on the constant get a literal type back. This matters in test files where we assert that the bundled group is exactly the RFC's 2048-bit choice and not, say, a future 3072-bit upgrade.