@link-foundation/sensitive-data-sanitizer 0.21.4 → 0.21.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.21.6
+
+### Patch Changes
+
+- cbd6b3b: Preserve complete credential placeholders and public configuration values before Markdown backticks, including the exact `HIVE_MIND_CLAUDE_AUTH_AUTHORITY=conventional` opt-out. Keep masking actual HTML/script and keyword-prefixed credentials, with exact known secrets taking priority.
+
+## 0.21.5
+
+### Patch Changes
+
+- e61a218: Preserve Authorization and Proxy-Authorization scheme words when overlapping credential heuristics match exactly the scheme before a separate payload. Continue masking payloads, bare credentials, and exact known secrets.
+
 ## 0.21.4
 
 ### Patch Changes

package/docs/API.md

@@ -579,7 +579,7 @@ permission values and literal credential references. `publicKnowledge: false`
 restores IP detection; explicit `knownSecrets` and `knownPersonal` retain
 priority. No shell command or workflow expression is executed.
 
-Authorization headers (including Proxy-Authorization) redact the scheme and one credential token. Whitespace, C0 controls (including NUL), DEL, quotes, backslashes and commas end the value, preserving subsequent log text in shell and escaped JSON prompts. Matching brackets opened within a token are included in its redaction; unmatched closing brackets remain part of the surrounding log. Already-redacted tokens and known credential references remain exempt after an optional scheme, including `<token>` placeholders. The debug callback receives value-free `gitleaks-rule` events with rule ID, input length and elapsed milliseconds; tracing is off by default.
+Authorization headers (including Proxy-Authorization) preserve the scheme and redact the credential payload. Overlapping heuristic findings that cover exactly a scheme followed by a separate nonempty payload are ignored, including Gitleaks generic API-key findings on `SharedAccessSignature`. Bare credentials without a scheme, payload findings and exact `knownSecrets` matches remain subject to redaction. Whitespace, C0 controls (including NUL), DEL, quotes, backslashes and commas end the value, preserving subsequent log text in shell and escaped JSON prompts. Matching brackets opened within a token are included in its redaction; unmatched closing brackets remain part of the surrounding log. Already-redacted tokens and known credential references remain exempt after an optional scheme, including `<token>` placeholders. The debug callback receives value-free `gitleaks-rule` events with rule ID, input length and elapsed milliseconds; tracing is off by default.
 
 ## Caller-declared sensitive fields
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-foundation/sensitive-data-sanitizer",
-  "version": "0.21.4",
+  "version": "0.21.6",
   "description": "Offline sensitive-text sanitization with credential, multilingual personal-data and scanner union detection",
   "type": "module",
   "main": "src/index.js",

package/src/context.js

@@ -143,6 +143,10 @@ export function configurationSetting(keyName, value) {
 function credentialMetadata(keyName, value) {
   return (
     configurationSetting(keyName, value) ||
+    // This documented opt-out enum is public; other authority values and
+    // names still carry credential evidence.
+    (keyName === 'HIVE_MIND_CLAUDE_AUTH_AUTHORITY' &&
+      value === 'conventional') ||
     (/(?:^|[_.-])auth[_.-](?:mode|method|type)$/i.test(keyName) &&
       /^(?:chatgpt|oauth2?|apikey|api_key|bearer|basic|none)$/i.test(value)) ||
     (keyName === 'id-token' && /^(?:write|read|none)$/.test(value)) ||
@@ -160,11 +164,13 @@ function credentialMetadata(keyName, value) {
 // Only a quote at the same escape depth closes it; embedded quotes belong to
 // the value. Offsets cover escape bytes as well as the decoded characters.
 export function valueRange(text, start, mode = 'token', maxLength = Infinity) {
-  const reference = referencePrefix(text.slice(start, start + 512));
+  const reference = referencePrefix(
+    text.slice(start, markdownEnd(text, start, 512))
+  );
   if (reference) {
     return { start, end: start + reference[0].length };
   }
-  const opening = text.slice(start).match(/^(\\*)(["'])/);
+  const opening = text.slice(start).match(/^(\\*)(["']|`+)/);
   if (opening) {
     const range = quotedRange(text, start, opening, maxLength);
     const outer = outerQuoteEnd(text, range.start, range.end);
@@ -173,7 +179,8 @@ export function valueRange(text, start, mode = 'token', maxLength = Infinity) {
   if (/^[{[]/.test(text.slice(start, start + 1))) {
     return undefined;
   }
-  const tail = text.slice(start, start + maxLength);
+  const tail = text.slice(start, markdownEnd(text, start, maxLength));
+  // Only a matching surrounding Markdown delimiter ends an unquoted value.
   const terminator =
     mode === 'query'
       ? /[\s&#"'<>]/
@@ -198,8 +205,8 @@ export function authorizationRanges(text, start) {
   if (reference) {
     return [{ start, end: start + reference[0].length }];
   }
-  const scheme = /^[a-z][a-z0-9_-]*[ \t]+/i.exec(text.slice(start));
-  const tokenStart = start + (scheme?.[0].length ?? 0);
+  const scheme = authorizationScheme(text, start);
+  const tokenStart = scheme?.payloadStart ?? start;
   const params = scheme ? authParams(text, tokenStart) : undefined;
   if (params) {
     return params;
@@ -208,6 +215,25 @@ export function authorizationRanges(text, start) {
   const token = text.slice(tokenStart, end);
   return usableAuthorization(token) ? [{ start: tokenStart, end }] : [];
 }
+
+// A scheme is structural only when a separate, nonempty payload follows it.
+// Share this boundary with span refinement so overlapping vendor detections
+// cannot mask the scheme that the Authorization parser deliberately preserves.
+export function authorizationScheme(text, start) {
+  const opening = /^(\\*)(["'])/.exec(text.slice(start));
+  start += opening?.[0].length ?? 0;
+  const scheme = /^([a-z][a-z0-9_-]*)[ \t]+/i.exec(text.slice(start));
+  if (!scheme) {
+    return undefined;
+  }
+  const payloadStart = start + scheme[0].length;
+  const char = text[payloadStart];
+  return char &&
+    !authorizationDelimiter(char, text.charCodeAt(payloadStart)) &&
+    !/[}\]>]/.test(char)
+    ? { start, end: start + scheme[1].length, payloadStart }
+    : undefined;
+}
 function authorizationEnd(text, tokenStart) {
   const brackets = [];
   let end = tokenStart;
@@ -302,6 +328,9 @@ function quotedRange(text, start, opening, maxLength) {
   const depth = opening[1].length,
     quote = opening[2];
   const valueStart = start + opening[0].length;
+  if (quote[0] === '`') {
+    return markdownRange(text, valueStart, quote.length, maxLength);
+  }
   for (
     let i = valueStart;
     i < Math.min(text.length, valueStart + maxLength);
@@ -334,6 +363,64 @@ function quotedRange(text, start, opening, maxLength) {
   };
 }
 
+// Markdown closes only at a run of the same length. Scan each run once so
+// long unmatched backtick runs cannot cause repeated prefix comparisons.
+function markdownRange(text, start, length, maxLength) {
+  const limit = Math.min(text.length, start + maxLength);
+  for (let i = start; i < limit; i++) {
+    if (text[i] !== '`') {
+      continue;
+    }
+    let end = i + 1;
+    while (end < limit && text[end] === '`') {
+      end++;
+    }
+    if (end - i === length && text[end] !== '`') {
+      return { start, end: i };
+    }
+    i = end - 1;
+  }
+  return { start, end: limit };
+}
+
+// Recognize surrounding inline Markdown within a bounded logical line. When
+// its opening or closing delimiter cannot be established, keep scanning the
+// full credential, including any literal material following a placeholder.
+function markdownEnd(text, start, maxLength) {
+  const end = Math.min(text.length, start + maxLength);
+  const from = Math.max(0, start - 4096);
+  const prefix = text.slice(from, start);
+  const lineStart =
+    Math.max(prefix.lastIndexOf('\n'), prefix.lastIndexOf('\r')) + 1;
+  if (from && !lineStart) {
+    return end;
+  }
+  let length = 0;
+  for (const run of prefix.slice(lineStart).matchAll(/`+/g)) {
+    if (!length) {
+      let slashes = 0;
+      for (
+        let i = lineStart + run.index - 1;
+        i >= 0 && prefix[i] === '\\';
+        i--
+      ) {
+        slashes++;
+      }
+      if (slashes % 2 === 0) {
+        length = run[0].length;
+      }
+    } else if (length === run[0].length) {
+      length = 0;
+    }
+  }
+  if (!length) {
+    return end;
+  }
+  const limit = Math.min(end, start + 4096);
+  const close = markdownRange(text, start, length, limit - start).end;
+  return close < limit ? close : end;
+}
+
 function plausibleLabel(value, type) {
   if (operationalValue(value, type)) {
     return false;
@@ -515,8 +602,11 @@ const angleEnd = {
 // detection view instead.
 const formattingTag = new RegExp(`^${htmlTag}`, 'i');
 function angleValue(text, start, mode) {
-  const tail = text.slice(start, start + 4096);
-  if (text[start] !== '<' || !angleEnd[mode] || formattingTag.test(tail)) {
+  if (text[start] !== '<' || !angleEnd[mode]) {
+    return undefined;
+  }
+  const tail = text.slice(start, markdownEnd(text, start, 4096));
+  if (formattingTag.test(tail)) {
     return undefined;
   }
   const placeholder = /^<[^<>\r\n]{1,64}>/.exec(tail)?.[0];
@@ -531,6 +621,23 @@ function angleValue(text, start, mode) {
   return { start, end: start + (stop < 0 ? tail.length : stop) };
 }
 
+// Scheme-prefixed values carry the credential after the keyword, just as
+// Authorization headers do. Never mask only `token` and leave its value.
+function credentialValueRange(text, start, mode) {
+  const valueStart = start;
+  if (mode === 'token') {
+    start +=
+      /^(?:token|Bearer|Basic)[ \t]+(?=\S)/i.exec(text.slice(start))?.[0]
+        .length ?? 0;
+  }
+  const range = angleValue(text, start, mode) ?? valueRange(text, start, mode);
+  // Keep the prefix in the value used for metadata checks: `token 0` is not
+  // the exact public setting `0`, even under a configuration name.
+  return range && start !== valueStart
+    ? { ...range, start: valueStart }
+    : range;
+}
+
 function credentialRange(text, match, camel) {
   const start = match.index + match[0].length;
   if (
@@ -543,7 +650,7 @@ function credentialRange(text, match, camel) {
     return authorizationRanges(text, start);
   }
   const mode = credentialMode(text, match);
-  const range = angleValue(text, start, mode) ?? valueRange(text, start, mode);
+  const range = credentialValueRange(text, start, mode);
   const value = range && mode === 'prose' ? generatedWord(text, range) : range;
   if (value && /^(?:set-)?cookie$/i.test(match[1])) {
     return cookieValues(text, value.start, value.end);
@@ -582,7 +689,8 @@ function detectCredentials(text, emit) {
   }
   const flags = new RegExp(`--(${key})(?:[ \\t]+|=)`, 'giu');
   for (const match of text.matchAll(flags)) {
-    const range = valueRange(text, match.index + match[0].length);
+    const start = match.index + match[0].length;
+    const range = credentialValueRange(text, start, 'token');
     if (range) {
       emitValue(text, range.start, range.end, emit, details, match[1]);
     }

package/src/credential-spans.js

@@ -1,4 +1,5 @@
 import { maskedValue } from './credentials.js';
+import { authorizationScheme } from './context.js';
 
 // Credential findings cover the secret, not the readable context around it:
 // PEM markers, URL hosts and user names, cookie names and the rest of a
@@ -159,7 +160,22 @@ function pemMarkers(text, findings) {
 
 export function refineCredentialSpans(text, findings) {
   const markers = pemMarkers(text, findings);
+  const schemes = new Map();
+  for (const header of text.matchAll(
+    /(?<![\w-])(?:Proxy-)?Authorization(?:\\*["'])?[ \t]*:[ \t]*/gi
+  )) {
+    const scheme = authorizationScheme(text, header.index + header[0].length);
+    if (scheme) {
+      schemes.set(scheme.start, scheme.end);
+    }
+  }
   const narrow = findings
+    .filter(
+      (finding) =>
+        finding.category !== 'credential' ||
+        finding.rule === 'known-secret' ||
+        schemes.get(finding.start) !== finding.end
+    )
     .filter(
       (finding) =>
         finding.category === 'credential' ||

package/src/credentials.js

@@ -89,7 +89,7 @@ export function templatedCredential(text, finding) {
 // Only variable references and the documented gh lookup are exempt. Arbitrary
 // shell commands and Actions expressions can contain literal credentials.
 export function referencePrefix(value) {
-  return /^(?:(?:token|Bearer|Basic)\s+)?(?:\$\{\{\s*(?:secrets|env|vars|github|inputs)\.[A-Za-z_][A-Za-z0-9_.]*\s*\}\}|\$\(gh\s+auth\s+token(?:\s+--hostname\s+[a-z0-9.-]+)?\))(?=$|[\s"',;\\])/i.exec(
+  return /^(?:(?:token|Bearer|Basic)\s+)?(?:\$\{[A-Za-z_][A-Za-z0-9_]*\}|\$[A-Za-z_][A-Za-z0-9_]*|\$\{\{\s*(?:secrets|env|vars|github|inputs)\.[A-Za-z_][A-Za-z0-9_.]*\s*\}\}|\$\(gh\s+auth\s+token(?:\s+--hostname\s+[a-z0-9.-]+)?\))(?=$|[\s"',;\\])/i.exec(
     value
   );
 }