@blamejs/core 0.18.53 → 0.18.55

package/lib/codepoint-class.js

@@ -1250,6 +1250,44 @@ function isIdentifierChar(cc) {
   return isAsciiAlnum(cc) || cc === 0x5F;                             // "_"
 }
 
+/**
+ * @primitive b.codepointClass.hasPairWhere
+ * @signature b.codepointClass.hasPairWhere(text, first, second, accept)
+ * @since     0.18.54
+ * @status    stable
+ * @related   b.codepointClass.splitLines
+ *
+ * Is there a place where `first` is immediately followed by `second`, and
+ * `accept` says that place counts? `accept(i)` is called with the index of
+ * `first`, and returns whether the construct opening there is a real one.
+ *
+ * This is the frame every two-character construct screen was writing out by
+ * hand: a path traversal opening on `..`, a regex inline-flag group on `(?`, a
+ * YAML merge key on `<<`. The literals and the follow-on tests differ, the scan
+ * does not, and three copies of a scan are three places for an off-by-one to
+ * live. It reads the string one character at a time, which is the property a
+ * guard needs: asking the question with a pattern would be a screen running the
+ * construct it screens over hostile text.
+ *
+ * `accept` decides alone — the scan does not skip past a hit it rejected, so
+ * overlapping openers are all offered. A screen that needs to COUNT
+ * non-overlapping occurrences is asking a different question and keeps its own
+ * cursor.
+ *
+ * @example
+ *   var CP = b.codepointClass;
+ *   CP.hasPairWhere("a/../b", ".", ".", function () { return true; });  // → true
+ *   CP.hasPairWhere("a.b", ".", ".", function () { return true; });     // → false
+ */
+function hasPairWhere(text, first, second, accept) {
+  if (typeof text !== "string") return false;
+  for (var i = 0; i + 1 < text.length; i += 1) {
+    if (text.charAt(i) !== first || text.charAt(i + 1) !== second) continue;
+    if (accept(i)) return true;
+  }
+  return false;
+}
+
 /**
  * @primitive b.codepointClass.splitLines
  * @signature b.codepointClass.splitLines(text)
@@ -1424,6 +1462,38 @@ function firstControlCharOffset(s, opts) {
   return -1;
 }
 
+/**
+ * @primitive b.codepointClass.firstLineInjectionCharOffset
+ * @signature b.codepointClass.firstLineInjectionCharOffset(s)
+ * @since     0.18.54
+ * @status    stable
+ * @related   b.codepointClass.firstControlCharOffset
+ *
+ * Return the index of the first CR, LF or NUL in `s`, or `-1` when there is
+ * none. These three are the bytes that end a line-oriented protocol record,
+ * so a value carrying one splits the record it is written into and the
+ * remainder is read as a second, attacker-chosen line: the header-injection
+ * class in HTTP and Set-Cookie, and the command-injection class in SMTP,
+ * POP3, IMAP and ManageSieve.
+ *
+ * Narrower than `firstControlCharOffset`, deliberately. That one refuses every
+ * C0 control and DEL, which is right for text a human wrote; this one answers
+ * the specific question a wire-protocol writer asks, so a caller adopting it
+ * does not silently start refusing values it used to accept.
+ *
+ * @example
+ *   b.codepointClass.firstLineInjectionCharOffset("nonce-42");        // -1
+ *   b.codepointClass.firstLineInjectionCharOffset("abc\r\nOK");       // 3
+ */
+function firstLineInjectionCharOffset(s) {
+  if (typeof s !== "string") return -1;
+  for (var i = 0; i < s.length; i += 1) {
+    var c = s.charCodeAt(i);
+    if (c === 0x0d || c === 0x0a || c === 0x00) return i;                        // CR / LF / NUL
+  }
+  return -1;
+}
+
 // Decode HTML numeric character references (hex &#x..; and decimal &#..;) just
 // enough to expose a scheme hidden behind entity-encoding. The trailing
 // semicolon is OPTIONAL — a browser decodes `&#106avascript:` (no semicolon)
@@ -1743,6 +1813,7 @@ module.exports = {
   caseFoldPartners:        caseFoldPartners,
   isForbiddenControlChar:  isForbiddenControlChar,
   firstControlCharOffset:  firstControlCharOffset,
+  firstLineInjectionCharOffset: firstLineInjectionCharOffset,
   decodeNumericEntities:   decodeNumericEntities,
   decodeMarkupEntities:    decodeMarkupEntities,
   NAMED_ENTITY_ASCII:      NAMED_ENTITY_ASCII,
@@ -1769,6 +1840,7 @@ module.exports = {
   isAsciiDigit:      isAsciiDigit,
   isAsciiHexDigit:   isAsciiHexDigit,
   isIdentifierChar:  isIdentifierChar,
+  hasPairWhere:      hasPairWhere,
   splitLines:        splitLines,
   splitLinesAny:     splitLinesAny,
   splitOnWhitespace: splitOnWhitespace,

package/lib/cookies.js

@@ -591,16 +591,13 @@ function parseSafe(cookieHeader, opts) {
     });
     return { jar: jar, issues: issues };
   }
-  for (var hi = 0; hi < cookieHeader.length; hi += 1) {
-    var ch = cookieHeader.charCodeAt(hi);
-    if (ch === 0x0D || ch === 0x0A || ch === 0x00) {                             // CR / LF / NUL forbidden in cookie header
-      issues.push({
-        kind: "header-control-byte", severity: "high",
-        snippet: "Cookie header contains CR / LF / NUL — proxy-side " +
-                 "header injection vector",
-      });
-      return { jar: jar, issues: issues };
-    }
+  if (codepointClass.firstLineInjectionCharOffset(cookieHeader) !== -1) {
+    issues.push({
+      kind: "header-control-byte", severity: "high",
+      snippet: "Cookie header contains CR / LF / NUL — proxy-side " +
+               "header injection vector",
+    });
+    return { jar: jar, issues: issues };
   }
 
   var pairs = cookieHeader.split(/;\s*/);

package/lib/credential-hash.js

@@ -372,8 +372,15 @@ function inspect(envelope) {
 function needsRehash(envelope, opts) {
   var decoded = _decodeEnvelope(envelope);
   if (!decoded) return true;     // unrecognized → migrate aggressively
+  // Same validation hash() applies to the same option. Reading the table with
+  // a fallback to the default meant a misspelled algo silently answered a
+  // different question than the caller asked — "is this row still the default?"
+  // instead of "is this row argon2id?" — on a credential-rotation decision. It
+  // also read through the prototype: algo "constructor" yielded a function,
+  // which compares unequal to every real algorithm id.
+  _validateOpts(opts);
   var targetAlgoName = (opts && opts.algo) || DEFAULTS.algo;
-  var targetId = NAME_TO_ID[targetAlgoName] || C.ACTIVE.CRED_HASH;
+  var targetId = NAME_TO_ID[targetAlgoName];
   if (decoded.algoId !== targetId) return true;
   if (decoded.algoId === C.CRED_HASH_IDS.ARGON2ID) {
     // Defer the parameter-lag check to the password primitive's

package/lib/crypto.js

@@ -1815,7 +1815,8 @@ function encryptMlkem768X25519(plaintext, recipient) {
 // algorithm gets a clear error rather than the generic "unsupported
 // KEM ID" path.
 //
-//   recipient: { privateKey, x25519PrivateKey }   — operator's keys
+//   recipient: the operator's two private keys, named privateKey (ML-KEM-768)
+//              and x25519PrivateKey (X25519)
 //   ciphertext: base64 envelope from encryptMlkem768X25519
 /**
  * @primitive b.crypto.decryptMlkem768X25519
@@ -1827,8 +1828,9 @@ function encryptMlkem768X25519(plaintext, recipient) {
  * envelope whose KEM ID byte is not `ML_KEM_768_X25519` so an
  * operator who calls this with a ciphertext sealed under a different
  * algorithm gets a clear error rather than the generic dispatch path.
- * Recipient shape is `{ privateKey, x25519PrivateKey }` — `privateKey`
- * is the ML-KEM-768 PEM, NOT the framework default ML-KEM-1024.
+ * The recipient carries two private keys: `privateKey`, which is the
+ * ML-KEM-768 PEM and NOT the framework default ML-KEM-1024, and
+ * `x25519PrivateKey`, which is the X25519 PEM.
  *
  * @example
  *   var pair = b.crypto.generateMlkem768X25519KeyPair();
@@ -1845,8 +1847,8 @@ function encryptMlkem768X25519(plaintext, recipient) {
 function decryptMlkem768X25519(ciphertext, recipient) {
   if (!recipient || typeof recipient !== "object" ||
       !recipient.privateKey || !recipient.x25519PrivateKey) {
-    throw new Error("decryptMlkem768X25519 requires { privateKey, x25519PrivateKey } " +
-                    "(privateKey is the ML-KEM-768 PEM, x25519PrivateKey is the X25519 PEM)");
+    throw new Error("decryptMlkem768X25519 requires both a privateKey, which is the " +
+                    "ML-KEM-768 PEM, and an x25519PrivateKey, which is the X25519 PEM");
   }
   var packed = Buffer.from(ciphertext, "base64");
   if (packed[0] !== C.ENVELOPE_MAGIC) {

package/lib/db-file-lifecycle.js

@@ -90,12 +90,17 @@ function _aad(dataDir, label) {
   return Buffer.from("blamejs.db-file-lifecycle.v1\0" + label + "\0" + (dataDir || ""), "utf8");
 }
 
-function _resolveTmpDir(operatorTmpDir, allowDiskFallback) {
+// Platform and stat are parameters so the non-Linux branch is reachable from a
+// Linux CI host. They also keep the "/dev/shm" literal off a direct fs call:
+// the path is only meaningful on Linux, and a leading slash on Windows is
+// drive-relative, so an unguarded probe there asks about C:\dev\shm and can be
+// answered yes by any directory an unprivileged user creates.
+function _resolveTmpDirFrom(operatorTmpDir, allowDiskFallback, platform, stat) {
   if (operatorTmpDir) return operatorTmpDir;
   // Linux: /dev/shm is the standard tmpfs mount.
-  if (process.platform === "linux") {
+  if (platform === "linux") {
     try {
-      var st = nodeFs.statSync("/dev/shm");
+      var st = stat("/dev/shm");
       if (st && st.isDirectory()) return "/dev/shm";
     } catch (_e) { /* fall through */ }
   }
@@ -108,6 +113,11 @@ function _resolveTmpDir(operatorTmpDir, allowDiskFallback) {
     "OR set opts.allowDiskFallback: true to accept disk-backed temporary storage.");
 }
 
+function _resolveTmpDir(operatorTmpDir, allowDiskFallback) {
+  return _resolveTmpDirFrom(operatorTmpDir, allowDiskFallback,
+    process.platform, nodeFs.statSync);
+}
+
 /**
  * @primitive b.db.fileLifecycle
  * @signature b.db.fileLifecycle(opts)
@@ -342,4 +352,5 @@ function fileLifecycle(opts) {
 module.exports = {
   fileLifecycle:        fileLifecycle,
   DbFileLifecycleError: DbFileLifecycleError,
+  _resolveTmpDirFromForTest: _resolveTmpDirFrom,
 };