neonctl 2.27.1 → 2.29.0

package/dist/psql/wire/sasl.js

@@ -24,23 +24,23 @@
  * Server signature verification uses `crypto.timingSafeEqual` to avoid
  * leaking timing information about the comparison result.
  */
-import { createHash, createHmac, pbkdf2Sync, randomBytes as nodeRandomBytes, timingSafeEqual, } from 'node:crypto';
+import { createHash, createHmac, randomBytes as nodeRandomBytes, pbkdf2Sync, timingSafeEqual, } from "node:crypto";
 export class SaslMechanismError extends Error {
     constructor(message) {
         super(message);
-        this.name = 'SaslMechanismError';
+        this.name = "SaslMechanismError";
     }
 }
 export class SaslVerificationError extends Error {
     constructor(message) {
         super(message);
-        this.name = 'SaslVerificationError';
+        this.name = "SaslVerificationError";
     }
 }
 export class SaslProtocolError extends Error {
     constructor(message) {
         super(message);
-        this.name = 'SaslProtocolError';
+        this.name = "SaslProtocolError";
     }
 }
 export function createScramClient(opts) {
@@ -49,9 +49,9 @@ export function createScramClient(opts) {
     // 18 raw bytes => 24 base64 chars; same width as upstream pg.
     // Commas are not part of the base64 alphabet, so the nonce is automatically
     // SCRAM-safe (RFC 5802 §5.1 forbids `,` in `r=`).
-    const clientNonce = rng(18).toString('base64');
+    const clientNonce = rng(18).toString("base64");
     const internal = {
-        state: 'init',
+        state: "init",
         mechanism,
         clientNonce,
         gs2Header,
@@ -69,15 +69,15 @@ export function createScramClient(opts) {
     };
 }
 function chooseMechanism(advertised, channelBinding) {
-    const hasPlus = advertised.includes('SCRAM-SHA-256-PLUS');
-    const hasPlain = advertised.includes('SCRAM-SHA-256');
+    const hasPlus = advertised.includes("SCRAM-SHA-256-PLUS");
+    const hasPlain = advertised.includes("SCRAM-SHA-256");
     if (channelBinding && hasPlus) {
-        const gs2 = 'p=tls-server-end-point,,';
+        const gs2 = "p=tls-server-end-point,,";
         return {
-            mechanism: 'SCRAM-SHA-256-PLUS',
+            mechanism: "SCRAM-SHA-256-PLUS",
             gs2Header: gs2,
             cbindInput: Buffer.concat([
-                Buffer.from(gs2, 'utf8'),
+                Buffer.from(gs2, "utf8"),
                 channelBinding.data,
             ]),
         };
@@ -86,96 +86,96 @@ function chooseMechanism(advertised, channelBinding) {
         // Client has channel-binding data but server doesn't advertise PLUS: per
         // RFC 5802 §6 the client must signal this with `y` so a downgrade attack
         // is detected (the server, if PLUS-capable, would have advertised it).
-        const gs2 = channelBinding ? 'y,,' : 'n,,';
+        const gs2 = channelBinding ? "y,," : "n,,";
         return {
-            mechanism: 'SCRAM-SHA-256',
+            mechanism: "SCRAM-SHA-256",
             gs2Header: gs2,
-            cbindInput: Buffer.from(gs2, 'utf8'),
+            cbindInput: Buffer.from(gs2, "utf8"),
         };
     }
-    throw new SaslMechanismError(`SASL: server offered [${advertised.join(', ')}] but only SCRAM-SHA-256 and SCRAM-SHA-256-PLUS are supported`);
+    throw new SaslMechanismError(`SASL: server offered [${advertised.join(", ")}] but only SCRAM-SHA-256 and SCRAM-SHA-256-PLUS are supported`);
 }
 function start(s) {
-    if (s.state !== 'init') {
+    if (s.state !== "init") {
         throw new SaslProtocolError(`SASL: start() called in state ${s.state}`);
     }
     // n=,r=<nonce> — the username field is empty because PostgreSQL ignores it
     // (the actual user was sent in StartupMessage) and an empty `n=` matches
     // libpq's wire output. Note pg sends `n=*` instead; both interoperate.
     const clientFirstBare = `n=,r=${s.clientNonce}`;
-    const clientFirstMessage = Buffer.from(s.gs2Header + clientFirstBare, 'utf8');
-    s.state = 'sent-first';
+    const clientFirstMessage = Buffer.from(s.gs2Header + clientFirstBare, "utf8");
+    s.state = "sent-first";
     return { mechanism: s.mechanism, clientFirstMessage };
 }
 function continueSession(s, serverFirst) {
-    if (s.state !== 'sent-first') {
+    if (s.state !== "sent-first") {
         throw new SaslProtocolError(`SASL: continue() called in state ${s.state}`);
     }
-    const serverFirstStr = serverFirst.toString('utf8');
+    const serverFirstStr = serverFirst.toString("utf8");
     const parsed = parseServerFirst(serverFirstStr);
     if (!parsed.nonce.startsWith(s.clientNonce)) {
-        throw new SaslProtocolError('SASL: server nonce does not start with client nonce');
+        throw new SaslProtocolError("SASL: server nonce does not start with client nonce");
     }
     if (parsed.nonce.length === s.clientNonce.length) {
-        throw new SaslProtocolError('SASL: server nonce is too short');
+        throw new SaslProtocolError("SASL: server nonce is too short");
     }
     const clientFirstBare = `n=,r=${s.clientNonce}`;
     const serverFirstString = `r=${parsed.nonce},s=${parsed.salt},i=${String(parsed.iteration)}`;
     // c=<base64 of GS2 header || optional CB data>
-    const channelBindingB64 = s.cbindInput.toString('base64');
+    const channelBindingB64 = s.cbindInput.toString("base64");
     const clientFinalWithoutProof = `c=${channelBindingB64},r=${parsed.nonce}`;
     const authMessage = `${clientFirstBare},${serverFirstString},${clientFinalWithoutProof}`;
-    const saltBytes = Buffer.from(parsed.salt, 'base64');
+    const saltBytes = Buffer.from(parsed.salt, "base64");
     // SASLprep the password before PBKDF2 (RFC 5802 §2.2). Our impl is minimal;
     // see saslprep() comment for the deviation from full RFC 4013.
     const normalizedPassword = saslprep(s.password);
-    const saltedPassword = pbkdf2Sync(Buffer.from(normalizedPassword, 'utf8'), saltBytes, parsed.iteration, 32, 'sha256');
-    const clientKey = hmac(saltedPassword, 'Client Key');
+    const saltedPassword = pbkdf2Sync(Buffer.from(normalizedPassword, "utf8"), saltBytes, parsed.iteration, 32, "sha256");
+    const clientKey = hmac(saltedPassword, "Client Key");
     const storedKey = sha256(clientKey);
     const clientSignature = hmac(storedKey, authMessage);
     const clientProof = xor(clientKey, clientSignature);
-    const serverKey = hmac(saltedPassword, 'Server Key');
+    const serverKey = hmac(saltedPassword, "Server Key");
     s.serverSignature = hmac(serverKey, authMessage);
-    s.state = 'sent-final';
-    return Buffer.from(`${clientFinalWithoutProof},p=${clientProof.toString('base64')}`, 'utf8');
+    s.state = "sent-final";
+    return Buffer.from(`${clientFinalWithoutProof},p=${clientProof.toString("base64")}`, "utf8");
 }
 function finishSession(s, serverFinal) {
-    if (s.state !== 'sent-final') {
+    if (s.state !== "sent-final") {
         throw new SaslProtocolError(`SASL: finish() called in state ${s.state}`);
     }
     if (s.serverSignature === null) {
         // Defensive: should be impossible because state machine guards it.
-        throw new SaslProtocolError('SASL: no server signature recorded');
+        throw new SaslProtocolError("SASL: no server signature recorded");
     }
-    const parsed = parseServerFinal(serverFinal.toString('utf8'));
-    const received = Buffer.from(parsed.serverSignature, 'base64');
+    const parsed = parseServerFinal(serverFinal.toString("utf8"));
+    const received = Buffer.from(parsed.serverSignature, "base64");
     // Constant-time comparison: defeats timing side channels that could let an
     // attacker (with control over `v=`) learn the prefix of our derived signature.
     if (received.length !== s.serverSignature.length ||
         !timingSafeEqual(received, s.serverSignature)) {
-        throw new SaslVerificationError('SASL: server signature does not match — possible MITM or wrong password');
+        throw new SaslVerificationError("SASL: server signature does not match — possible MITM or wrong password");
     }
-    s.state = 'done';
+    s.state = "done";
 }
 function parseServerFirst(text) {
     const attrs = parseAttributePairs(text);
-    const nonce = attrs.get('r');
+    const nonce = attrs.get("r");
     if (!nonce) {
-        throw new SaslProtocolError('SASL: server-first missing `r=` (nonce)');
+        throw new SaslProtocolError("SASL: server-first missing `r=` (nonce)");
     }
     if (!isPrintableChars(nonce)) {
-        throw new SaslProtocolError('SASL: server-first nonce contains non-printable characters');
+        throw new SaslProtocolError("SASL: server-first nonce contains non-printable characters");
     }
-    const salt = attrs.get('s');
+    const salt = attrs.get("s");
     if (!salt) {
-        throw new SaslProtocolError('SASL: server-first missing `s=` (salt)');
+        throw new SaslProtocolError("SASL: server-first missing `s=` (salt)");
     }
     if (!isBase64(salt)) {
-        throw new SaslProtocolError('SASL: server-first salt is not base64');
+        throw new SaslProtocolError("SASL: server-first salt is not base64");
     }
-    const iterStr = attrs.get('i');
+    const iterStr = attrs.get("i");
     if (!iterStr) {
-        throw new SaslProtocolError('SASL: server-first missing `i=` (iterations)');
+        throw new SaslProtocolError("SASL: server-first missing `i=` (iterations)");
     }
     if (!/^[1-9][0-9]*$/.test(iterStr)) {
         throw new SaslProtocolError(`SASL: server-first iteration count is not a positive integer: ${iterStr}`);
@@ -184,23 +184,23 @@ function parseServerFirst(text) {
 }
 function parseServerFinal(text) {
     const attrs = parseAttributePairs(text);
-    const errorAttr = attrs.get('e');
+    const errorAttr = attrs.get("e");
     if (errorAttr) {
         throw new SaslVerificationError(`SASL: server-final returned error: ${errorAttr}`);
     }
-    const v = attrs.get('v');
+    const v = attrs.get("v");
     if (!v) {
-        throw new SaslProtocolError('SASL: server-final missing `v=` (server signature)');
+        throw new SaslProtocolError("SASL: server-final missing `v=` (server signature)");
     }
     if (!isBase64(v)) {
-        throw new SaslProtocolError('SASL: server-final `v=` is not base64');
+        throw new SaslProtocolError("SASL: server-final `v=` is not base64");
     }
     return { serverSignature: v };
 }
 function parseAttributePairs(text) {
     const out = new Map();
-    for (const pair of text.split(',')) {
-        if (pair.length < 2 || pair[1] !== '=') {
+    for (const pair of text.split(",")) {
+        if (pair.length < 2 || pair[1] !== "=") {
             throw new SaslProtocolError(`SASL: malformed attribute pair: ${JSON.stringify(pair)}`);
         }
         const key = pair[0];
@@ -232,12 +232,12 @@ function isBase64(text) {
 // Crypto helpers
 // ---------------------------------------------------------------------------
 function hmac(key, msg) {
-    const h = createHmac('sha256', key);
+    const h = createHmac("sha256", key);
     h.update(msg);
     return h.digest();
 }
 function sha256(data) {
-    return createHash('sha256').update(data).digest();
+    return createHash("sha256").update(data).digest();
 }
 function xor(a, b) {
     if (a.length !== b.length) {
@@ -276,21 +276,21 @@ function xor(a, b) {
 // string so the source file stays ASCII-only and so we sidestep ESLint's
 // `no-irregular-whitespace` and `no-misleading-character-class` rules —
 // those only inspect raw regex literals, not dynamically-built patterns.
-const NON_ASCII_SPACE_RE = new RegExp('[' + '\u00A0\u1680' + '\u2000-\u200B' + '\u202F\u205F\u3000' + ']', 'g');
+const NON_ASCII_SPACE_RE = new RegExp("[" + "\u00A0\u1680" + "\u2000-\u200B" + "\u202F\u205F\u3000" + "]", "g");
 // Combining marks and ZWJ are intentionally in this class; RFC 3454 Table B.1
 // strips them precisely because they combine with neighbouring code points.
 /* eslint-disable no-misleading-character-class */
-const MAPPED_TO_NOTHING_RE = new RegExp('[' +
-    '\u00AD\u034F\u1806' +
-    '\u180B-\u180D' +
-    '\u200C\u200D\u2060' +
-    '\uFE00-\uFE0F' +
-    '\uFEFF' +
-    ']', 'g');
+const MAPPED_TO_NOTHING_RE = new RegExp("[" +
+    "\u00AD\u034F\u1806" +
+    "\u180B-\u180D" +
+    "\u200C\u200D\u2060" +
+    "\uFE00-\uFE0F" +
+    "\uFEFF" +
+    "]", "g");
 /* eslint-enable no-misleading-character-class */
 function saslprep(password) {
     return password
-        .replace(NON_ASCII_SPACE_RE, ' ')
-        .replace(MAPPED_TO_NOTHING_RE, '')
-        .normalize('NFKC');
+        .replace(NON_ASCII_SPACE_RE, " ")
+        .replace(MAPPED_TO_NOTHING_RE, "")
+        .normalize("NFKC");
 }