cognium-dev 3.128.0 → 3.131.0

package/dist/cli.js

@@ -22600,6 +22600,13 @@ class LanguageSourcesPass {
     if (language === "go") {
       additionalSanitizers.push(...findGoMapAllowlistGuardSanitizers(code));
       additionalSanitizers.push(...findGoHtmlTemplateImportSanitizers(code));
+      const goMisconfigFindings = findGoPatternFindings(code, graph.ir.meta.file);
+      for (const finding of goMisconfigFindings) {
+        ctx.addFinding(finding);
+      }
+      for (const finding of findGoXssFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "python") {
       additionalSanitizers.push(...findPythonNetlocAllowlistGuardSanitizers(code));
@@ -22612,6 +22619,12 @@ class LanguageSourcesPass {
       for (const finding of pyMisconfigFindings) {
         ctx.addFinding(finding);
       }
+      for (const finding of findPythonFlaskStringConcatXssFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
+      for (const finding of findPythonJinjaMarkupXssFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "rust") {
       additionalSanitizers.push(...findRustSetAllowlistGuardSanitizers(code));
@@ -22621,6 +22634,18 @@ class LanguageSourcesPass {
       for (const finding of rustMisconfigFindings) {
         ctx.addFinding(finding);
       }
+      for (const finding of findRustHardcodedCredentialFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
+      for (const finding of findRustInsecureCookieFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
+      for (const finding of findRustJwtVerifyDisabledFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
+      for (const finding of findRustWeakCryptoEcbFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "javascript" || language === "typescript" || language === "htmljs") {
       additionalSanitizers.push(...findJsSafeJsonParseSanitizers(code));
@@ -22628,12 +22653,29 @@ class LanguageSourcesPass {
       additionalSanitizers.push(...findJsCsvFormulaPrefixSanitizers(code));
       additionalSanitizers.push(...findJsWrapperFunctionSanitizers(code));
       additionalSanitizers.push(...findJsSsrfAllowlistGuardSanitizers(code));
+      additionalSanitizers.push(...findJsArgvFormExecSanitizers(code));
+      additionalSanitizers.push(...findJsParameterizedSqlSanitizers(code));
+      for (const finding of findJsPatternFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
+      for (const finding of findJsVueVHtmlXssFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
+      for (const finding of findTsAngularBypassXssFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "java") {
       additionalSanitizers.push(...findJavaSafeJsonParseSanitizers(code));
       additionalSanitizers.push(...findJavaPathNormalizeStartsWithGuardSanitizers(code));
       additionalSanitizers.push(...findJavaInlineCrlfStripLogSanitizers(code));
       additionalSanitizers.push(...findJavaArgvFormExecSanitizers(code));
+      for (const finding of findJavaPatternFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
+      for (const finding of findJavaResponseWriterXssFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "python" || language === "javascript" || language === "typescript" || language === "go") {
       const exfilFindings = findExternalSecretExfiltrationFindings(code, graph.ir.meta.file, language);
@@ -24585,6 +24627,64 @@ function findJsSsrfAllowlistGuardSanitizers(code) {
   }
   return sanitizers;
 }
+function findJsArgvFormExecSanitizers(code) {
+  const sanitizers = [];
+  const lines = code.split(`
+`);
+  const argvExecRe = /\b(?:execFile|spawn)(?:Sync)?\s*\(\s*(?:'[^']*'|"[^"]*"|`[^`]*`)\s*,\s*\[/;
+  const shellArgvRe = /\b(?:execFile|spawn)(?:Sync)?\s*\(\s*['"`](?:[\w./-]*\/)?(?:sh|bash|zsh|ksh|dash|cmd(?:\.exe)?|powershell|pwsh)['"`]\s*,\s*\[\s*['"`]-c['"`]/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const text = lines[i2];
+    if (!argvExecRe.test(text))
+      continue;
+    if (shellArgvRe.test(text))
+      continue;
+    sanitizers.push({
+      type: "js_argv_form_exec",
+      method: "execFile",
+      line: i2 + 1,
+      sanitizes: ["command_injection", "external_taint_escape"]
+    });
+  }
+  return sanitizers;
+}
+function findJsParameterizedSqlSanitizers(code) {
+  const sanitizers = [];
+  const lines = code.split(`
+`);
+  const singleRe = /\.\s*(?:query|execute)\s*\(\s*'([^'\\]*(?:\\.[^'\\]*)*)'\s*,\s*\[/;
+  const doubleRe = /\.\s*(?:query|execute)\s*\(\s*"([^"\\]*(?:\\.[^"\\]*)*)"\s*,\s*\[/;
+  const tickRe = /\.\s*(?:query|execute)\s*\(\s*`([^`]*)`\s*,\s*\[/;
+  const placeholderRe = /(?:\$\d+|\?)/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const text = lines[i2];
+    let sql = null;
+    const s = singleRe.exec(text);
+    if (s)
+      sql = s[1];
+    if (sql == null) {
+      const d = doubleRe.exec(text);
+      if (d)
+        sql = d[1];
+    }
+    if (sql == null) {
+      const t = tickRe.exec(text);
+      if (t && !/\$\{/.test(t[1]))
+        sql = t[1];
+    }
+    if (sql == null)
+      continue;
+    if (!placeholderRe.test(sql))
+      continue;
+    sanitizers.push({
+      type: "js_parameterized_sql",
+      method: "query",
+      line: i2 + 1,
+      sanitizes: ["sql_injection", "external_taint_escape"]
+    });
+  }
+  return sanitizers;
+}
 function findJavaPathNormalizeStartsWithGuardSanitizers(code) {
   const sanitizers = [];
   const lines = code.split(`
@@ -25145,6 +25245,668 @@ function findRustPatternFindings(code, file) {
   }
   return out2;
 }
+function findRustHardcodedCredentialFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const re = /\b(?:pub\s+)?(?:const|static)\s+([A-Z][A-Z0-9_]*)\s*:\s*&\s*'?[a-z_]*\s*str\s*=\s*"([^"]+)"/;
+  const nameRe = /(?:^|_)(?:API[_]?KEY|SECRET|TOKEN|PASSWORD|PASSWD|PWD|AUTH)(?:_|$)/i;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    const m = trimmed.match(re);
+    if (!m)
+      continue;
+    const name2 = m[1];
+    const value = m[2];
+    if (!nameRe.test(name2))
+      continue;
+    if (value.length < 8)
+      continue;
+    if (/^(?:xxx|todo|fixme|placeholder|changeme)/i.test(value))
+      continue;
+    out2.push({
+      id: `hardcoded-credential-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "hardcoded-credential",
+      cwe: "CWE-798",
+      severity: "high",
+      level: "error",
+      message: `Hardcoded credential: const ${name2} contains a literal secret value`,
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findRustInsecureCookieFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const builderRe = /\bCookie\s*::\s*build\s*\(/;
+  const insecureFlagRe = /\.\s*(?:secure|http_only)\s*\(\s*false\s*\)/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    if (!builderRe.test(trimmed))
+      continue;
+    if (!insecureFlagRe.test(trimmed))
+      continue;
+    out2.push({
+      id: `insecure-cookie-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "insecure-cookie",
+      cwe: "CWE-1004",
+      severity: "medium",
+      level: "warning",
+      message: "Insecure cookie: Cookie::build chain disables Secure / HttpOnly flag(s)",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findRustJwtVerifyDisabledFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const re = /\.\s*insecure_disable_signature_validation\s*\(/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    if (!re.test(trimmed))
+      continue;
+    out2.push({
+      id: `jwt-verify-disabled-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "jwt-verify-disabled",
+      cwe: "CWE-347",
+      severity: "critical",
+      level: "error",
+      message: "JWT signature verification disabled: " + "Validation::insecure_disable_signature_validation() forfeits signature enforcement",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findRustWeakCryptoEcbFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const ctorRe = /\bAes(?:128|192|256)(?:Ecb)?\s*::\s*new\s*\(/;
+  const blockOpRe = /\.\s*(encrypt_block|decrypt_block)\s*\(/;
+  let sawCtor = false;
+  for (const line of lines) {
+    if (ctorRe.test(line)) {
+      sawCtor = true;
+      break;
+    }
+  }
+  if (!sawCtor)
+    return out2;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    if (!blockOpRe.test(trimmed))
+      continue;
+    out2.push({
+      id: `weak-crypto-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "weak-crypto",
+      cwe: "CWE-327",
+      severity: "high",
+      level: "error",
+      message: "Weak crypto (ECB mode): raw Aes::encrypt_block/decrypt_block " + "leaks repeating-block patterns. Use AES-GCM, AES-CTR, or " + "AES-CBC with an HMAC.",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findJavaPatternFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const jwtDecodeRe = /\bJWT\s*\.\s*decode\s*\(/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*"))
+      continue;
+    if (!jwtDecodeRe.test(trimmed))
+      continue;
+    if (/\.\s*verify\s*\(/.test(trimmed))
+      continue;
+    out2.push({
+      id: `jwt-verify-disabled-${file}-${i2 + 1}-decode`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "jwt-verify-disabled",
+      cwe: "CWE-347",
+      severity: "critical",
+      level: "error",
+      message: "JWT signature not verified: auth0 `JWT.decode(token)` parses " + "without checking the signature. Use `JWT.require(<algorithm>)" + ".build().verify(token)` to enforce verification.",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  const anonStartRe = /\bnew\s+X509TrustManager\s*\(\s*\)\s*\{/;
+  const checkServerSig = /\bcheckServerTrusted\s*\([^)]*\)\s*(?:throws\s+[^\{]*)?\{\s*\}/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    if (!anonStartRe.test(raw))
+      continue;
+    const end = Math.min(lines.length, i2 + 16);
+    let foundAt = -1;
+    for (let j = i2;j < end; j++) {
+      if (checkServerSig.test(lines[j])) {
+        foundAt = j;
+        break;
+      }
+    }
+    if (foundAt < 0)
+      continue;
+    out2.push({
+      id: `tls-verify-disabled-${file}-${foundAt + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "tls-verify-disabled",
+      cwe: "CWE-295",
+      severity: "high",
+      level: "error",
+      message: "TLS certificate verification disabled: anonymous X509TrustManager " + "with empty checkServerTrusted body accepts every certificate.",
+      file,
+      line: foundAt + 1,
+      snippet: lines[foundAt].trim().substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findGoPatternFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const cipherVars = new Set;
+  const ctorRe = /\b([a-zA-Z_]\w*)\s*(?:,\s*[a-zA-Z_]\w*)?\s*:?=\s*aes\.NewCipher\s*\(/;
+  for (const line of lines) {
+    const m = line.match(ctorRe);
+    if (m)
+      cipherVars.add(m[1]);
+  }
+  if (cipherVars.size === 0)
+    return out2;
+  for (const v of Array.from(cipherVars)) {
+    const wrapRe = new RegExp(`\\bcipher\\.New(?:GCM|CBCEncrypter|CBCDecrypter|CTR|OFB|CFBEncrypter|CFBDecrypter)\\s*\\(\\s*${v}\\b`);
+    for (const line of lines) {
+      if (wrapRe.test(line)) {
+        cipherVars.delete(v);
+        break;
+      }
+    }
+  }
+  if (cipherVars.size === 0)
+    return out2;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    for (const v of cipherVars) {
+      const opRe = new RegExp(`\\b${v}\\s*\\.\\s*(?:Encrypt|Decrypt)\\s*\\(`);
+      if (!opRe.test(trimmed))
+        continue;
+      out2.push({
+        id: `weak-crypto-${file}-${i2 + 1}`,
+        pass: "language-sources",
+        category: "security",
+        rule_id: "weak-crypto",
+        cwe: "CWE-327",
+        severity: "high",
+        level: "error",
+        message: "Weak crypto (ECB mode): raw aes.Cipher.Encrypt/Decrypt on a " + "block leaks repeating-block patterns. Wrap with cipher.NewGCM, " + "cipher.NewCTR, or cipher.NewCBCEncrypter + HMAC.",
+        file,
+        line: i2 + 1,
+        snippet: trimmed.substring(0, 100)
+      });
+      break;
+    }
+  }
+  return out2;
+}
+function findJsPatternFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const parseRe = /\blibxml(?:js)?\s*\.\s*parseXml(?:String)?\s*\(/;
+  const noentTrueRe = /\bnoent\s*:\s*true\b/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*"))
+      continue;
+    if (!parseRe.test(trimmed))
+      continue;
+    if (!noentTrueRe.test(trimmed))
+      continue;
+    out2.push({
+      id: `xml-entity-expansion-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "xml-entity-expansion",
+      cwe: "CWE-611",
+      severity: "high",
+      level: "error",
+      message: "XML external entity resolution enabled: libxmljs parseXml " + "called with `noent: true` resolves external entities (XXE / " + "billion-laughs). Omit the flag or set `noent: false`.",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findGoXssFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const rwNames = new Set;
+  const sigRe = /\(\s*([A-Za-z_]\w*)\s+http\.ResponseWriter\b/g;
+  for (const line of lines) {
+    let m;
+    sigRe.lastIndex = 0;
+    while ((m = sigRe.exec(line)) !== null)
+      rwNames.add(m[1]);
+  }
+  if (rwNames.size === 0)
+    return out2;
+  const escaperRe = /\b(?:html|template)\.(?:EscapeString|HTMLEscapeString|HTMLEscaper|JSEscapeString|URLQueryEscaper)\s*\(/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    const callRe = /\bfmt\.Fprint(?:f|ln)?\s*\(\s*([A-Za-z_]\w*)\s*,\s*([\s\S]*)\)\s*(?:\/\/.*)?$/;
+    const m = trimmed.match(callRe);
+    if (!m)
+      continue;
+    if (!rwNames.has(m[1]))
+      continue;
+    const tail = m[2];
+    if (escaperRe.test(tail))
+      continue;
+    if (!/[A-Za-z_]\w*/.test(tail.replace(/"[^"]*"|`[^`]*`/g, "")))
+      continue;
+    out2.push({
+      id: `xss-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "xss",
+      cwe: "CWE-79",
+      severity: "high",
+      level: "error",
+      message: "Reflected XSS: fmt.Fprint writes data to http.ResponseWriter " + "without HTML escaping. Wrap user-controlled args with " + "html.EscapeString / template.HTMLEscapeString.",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findJavaResponseWriterXssFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const respNames = new Set;
+  const sigRe = /\bHttpServletResponse\s+([A-Za-z_]\w*)\b/g;
+  for (const line of lines) {
+    let m;
+    sigRe.lastIndex = 0;
+    while ((m = sigRe.exec(line)) !== null)
+      respNames.add(m[1]);
+  }
+  if (respNames.size === 0)
+    return out2;
+  const safeWrapRe = /\b(?:Encode\.(?:forHtml|forHtmlAttribute|forHtmlContent|forJavaScript)|StringEscapeUtils\.escape(?:Html3|Html4|EcmaScript|Xml)|HtmlUtils\.htmlEscape(?:Decimal|Hex)?|Escaper\.escapeHtml|HtmlEscapers\.(?:escapeHtml|htmlEscaper)|Encoder\.encodeForHTML(?:Attribute)?|Jsoup\.clean)\s*\(/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*"))
+      continue;
+    const chainRe = /\b([A-Za-z_]\w*)\s*\.\s*getWriter\s*\(\s*\)\s*\.\s*(print|println|write|printf|format|append)\s*\(([\s\S]*)\)\s*;?\s*(?:\/\/.*)?$/;
+    const m = trimmed.match(chainRe);
+    if (!m)
+      continue;
+    const recv = m[1];
+    if (!respNames.has(recv))
+      continue;
+    const args2 = m[3];
+    if (safeWrapRe.test(args2))
+      continue;
+    const argsTrim = args2.trim();
+    if (/^"(?:\\.|[^"\\])*"$/.test(argsTrim))
+      continue;
+    if (!/[A-Za-z_]\w*/.test(argsTrim))
+      continue;
+    out2.push({
+      id: `xss-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "xss",
+      cwe: "CWE-79",
+      severity: "high",
+      level: "error",
+      message: "Reflected XSS: HttpServletResponse.getWriter()." + m[2] + "(...) writes data to the response without HTML escaping. " + "Wrap user-controlled values with OWASP Encode.forHtml / " + "StringEscapeUtils.escapeHtml4 / Jsoup.clean.",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findJsVueVHtmlXssFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const sourceRe = /\b(?:URLSearchParams|location\s*\.\s*(?:search|hash|href|pathname)|window\s*\.\s*location|route\s*\.\s*(?:query|params)|router\s*\.\s*(?:currentRoute|query)|\$route\s*\.\s*(?:query|params)|fetch\s*\(|axios\s*\.\s*(?:get|post)|XMLHttpRequest|document\s*\.\s*location)\b/;
+  const tplRe = /\btemplate\s*:\s*(['"`])([\s\S]*?)\1/g;
+  let tm;
+  const boundVars = new Set;
+  while ((tm = tplRe.exec(code)) !== null) {
+    const tpl = tm[2];
+    const vhRe = /\bv-html\s*=\s*"([^"]+)"/g;
+    let vm;
+    while ((vm = vhRe.exec(tpl)) !== null) {
+      const expr = vm[1].trim();
+      const idMatch = expr.match(/^([A-Za-z_$][\w$]*)/);
+      if (idMatch)
+        boundVars.add(idMatch[1]);
+    }
+  }
+  if (boundVars.size === 0)
+    return out2;
+  const taintedSet = new Set;
+  const assignRe = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\n]+)/g;
+  let am;
+  assignRe.lastIndex = 0;
+  while ((am = assignRe.exec(code)) !== null) {
+    if (sourceRe.test(am[2]))
+      taintedSet.add(am[1]);
+  }
+  for (let pass = 0;pass < 3; pass++) {
+    assignRe.lastIndex = 0;
+    const before = taintedSet.size;
+    while ((am = assignRe.exec(code)) !== null) {
+      if (taintedSet.has(am[1]))
+        continue;
+      for (const tv of taintedSet) {
+        if (new RegExp(`\\b${tv}\\b`).test(am[2])) {
+          taintedSet.add(am[1]);
+          break;
+        }
+      }
+    }
+    if (taintedSet.size === before)
+      break;
+  }
+  const taintedBindings = new Set;
+  for (const v of boundVars) {
+    const bindRe = new RegExp(`\\b${v}\\s*[:=]\\s*([^,;\\n]+)`);
+    for (const line of lines) {
+      const m = line.match(bindRe);
+      if (!m)
+        continue;
+      const val = m[1];
+      if (sourceRe.test(val)) {
+        taintedBindings.add(v);
+        break;
+      }
+      let found = false;
+      for (const tv of taintedSet) {
+        if (new RegExp(`\\b${tv}\\b`).test(val)) {
+          taintedBindings.add(v);
+          found = true;
+          break;
+        }
+      }
+      if (found)
+        break;
+    }
+    const propsRe = new RegExp(`\\bprops\\s*:\\s*\\[[^\\]]*['"\`]${v}['"\`][^\\]]*\\]`);
+    if (propsRe.test(code))
+      taintedBindings.add(v);
+  }
+  if (taintedBindings.size === 0)
+    return out2;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    if (!/v-html\s*=/.test(raw))
+      continue;
+    const vm = raw.match(/v-html\s*=\s*"([^"]+)"/);
+    if (!vm)
+      continue;
+    const idMatch = vm[1].trim().match(/^([A-Za-z_$][\w$]*)/);
+    if (!idMatch || !taintedBindings.has(idMatch[1]))
+      continue;
+    out2.push({
+      id: `xss-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "xss",
+      cwe: "CWE-79",
+      severity: "high",
+      level: "error",
+      message: 'Vue v-html XSS: directive binds to "' + idMatch[1] + '" which is sourced from user-controlled input. Use {{ }} ' + "interpolation (auto-escapes) or sanitize the HTML with " + "DOMPurify before binding.",
+      file,
+      line: i2 + 1,
+      snippet: raw.trim().substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findTsAngularBypassXssFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const sanitizerNames = new Set;
+  const declRe = /\b(?:public|private|protected|readonly|\s)?\s*([A-Za-z_$][\w$]*)\s*:\s*DomSanitizer\b/g;
+  let m;
+  declRe.lastIndex = 0;
+  while ((m = declRe.exec(code)) !== null)
+    sanitizerNames.add(m[1]);
+  if (sanitizerNames.size === 0)
+    return out2;
+  const assignRe = /\bthis\s*\.\s*([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*)\b/g;
+  let am;
+  assignRe.lastIndex = 0;
+  while ((am = assignRe.exec(code)) !== null) {
+    if (sanitizerNames.has(am[2]))
+      sanitizerNames.add(am[1]);
+  }
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*"))
+      continue;
+    const callRe = /\b(?:this\s*\.\s*)?([A-Za-z_$][\w$]*)\s*\.\s*bypassSecurityTrust(Html|Script|Url|ResourceUrl|Style)\s*\(([\s\S]*?)\)/;
+    const cm = trimmed.match(callRe);
+    if (!cm)
+      continue;
+    const recv = cm[1];
+    if (!sanitizerNames.has(recv))
+      continue;
+    const arg = cm[3].trim();
+    if (/^(['"`])[^'"`]*\1$/.test(arg))
+      continue;
+    out2.push({
+      id: `xss-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "xss",
+      cwe: "CWE-79",
+      severity: "high",
+      level: "error",
+      message: "Angular XSS: DomSanitizer.bypassSecurityTrust" + cm[2] + "() opts out of Angular's built-in sanitization for a " + "non-literal argument. Prefer leaving Angular's default " + "sanitizer in place, or sanitize the input with DOMPurify " + "before bypassing.",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findPythonFlaskStringConcatXssFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const fns = [];
+  const defRe = /^(\s*)def\s+([A-Za-z_]\w*)\s*\(/;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const dm = raw.match(defRe);
+    if (!dm)
+      continue;
+    const indent = dm[1].length;
+    let hasRoute = false;
+    for (let j = i2 - 1;j >= 0; j--) {
+      const prev = lines[j].trim();
+      if (prev === "" || prev.startsWith("#"))
+        continue;
+      if (!prev.startsWith("@"))
+        break;
+      if (/@\s*[A-Za-z_]\w*\s*\.\s*route\s*\(/.test(prev) || /@\s*route\s*\(/.test(prev)) {
+        hasRoute = true;
+      }
+    }
+    if (!hasRoute)
+      continue;
+    let end = lines.length;
+    for (let k = i2 + 1;k < lines.length; k++) {
+      const ln = lines[k];
+      if (!ln.trim())
+        continue;
+      const ind = ln.match(/^(\s*)/)?.[1].length ?? 0;
+      if (ind <= indent) {
+        end = k;
+        break;
+      }
+    }
+    fns.push({ name: dm[2], startLine: i2 + 1, endLine: end });
+  }
+  if (fns.length === 0)
+    return out2;
+  const requestSourceRe = /\b([A-Za-z_]\w*)\s*=\s*request\s*\.\s*(?:args|form|values|files|json|cookies|headers)(?:\s*\.\s*get\s*\(|\s*\[)/;
+  const escapeWrapRe = /\b(?:html\.escape|markupsafe\.escape|escape|markupsafe\.Markup\s*\.\s*escape|werkzeug\.utils\.escape)\s*\(/;
+  for (const fn of fns) {
+    const taintedVars = new Set;
+    for (let li = fn.startLine;li < fn.endLine; li++) {
+      const raw = lines[li];
+      const rm = raw.match(requestSourceRe);
+      if (rm)
+        taintedVars.add(rm[1]);
+    }
+    for (let li = fn.startLine;li < fn.endLine; li++) {
+      const raw = lines[li];
+      const trimmed = raw.trim();
+      if (!trimmed || trimmed.startsWith("#"))
+        continue;
+      const retMatch = trimmed.match(/^(?:return|yield)\s+(.+)$/);
+      if (!retMatch)
+        continue;
+      const expr = retMatch[1];
+      const inlineSource = /\brequest\s*\.\s*(?:args|form|values|files|cookies|headers)(?:\s*\.\s*get\s*\(|\s*\[)/.test(expr);
+      const hasTaintedVar = [...taintedVars].some((v) => new RegExp(`\\b${v}\\b`).test(expr));
+      if (!hasTaintedVar && !inlineSource)
+        continue;
+      if (escapeWrapRe.test(expr))
+        continue;
+      const buildsHtml = /['"`]\s*\+/.test(expr) || /\+\s*['"`]/.test(expr) || /\bf['"`][^{\n]*\{[^}]+\}/.test(expr) || /['"`]\s*%\s*[^=]/.test(expr) || /['"`]\.\s*format\s*\(/.test(expr);
+      if (!buildsHtml)
+        continue;
+      out2.push({
+        id: `xss-${file}-${li + 1}`,
+        pass: "language-sources",
+        category: "security",
+        rule_id: "xss",
+        cwe: "CWE-79",
+        severity: "high",
+        level: "error",
+        message: "Reflected XSS: Flask route returns HTML built from request " + "input via string concatenation / f-string / format. Wrap " + "user input with markupsafe.escape() or render via a " + "Jinja2 template (autoescape on by default).",
+        file,
+        line: li + 1,
+        snippet: trimmed.substring(0, 100)
+      });
+      break;
+    }
+  }
+  return out2;
+}
+function findPythonJinjaMarkupXssFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const importRe = /^\s*from\s+(?:markupsafe|flask)\s+import\s+(?:[^#\n]*\b)?Markup\b/m;
+  const classDefRe = /^\s*class\s+Markup\b/m;
+  if (!importRe.test(code))
+    return out2;
+  if (classDefRe.test(code))
+    return out2;
+  const requestSourceRe = /\b([A-Za-z_]\w*)\s*=\s*request\s*\.\s*(?:args|form|values|files|json|cookies|headers)(?:\s*\.\s*get\s*\(|\s*\[)/;
+  const taintedVars = new Set;
+  for (const line of lines) {
+    const m = line.match(requestSourceRe);
+    if (m)
+      taintedVars.add(m[1]);
+  }
+  if (taintedVars.size === 0)
+    return out2;
+  if (!/\.\s*render\s*\(/.test(code))
+    return out2;
+  const markupCallRe = /\bMarkup\s*\(\s*([A-Za-z_]\w*)\s*[,)]/g;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    let mm;
+    markupCallRe.lastIndex = 0;
+    while ((mm = markupCallRe.exec(trimmed)) !== null) {
+      const argName = mm[1];
+      if (!taintedVars.has(argName))
+        continue;
+      out2.push({
+        id: `xss-${file}-${i2 + 1}`,
+        pass: "language-sources",
+        category: "security",
+        rule_id: "xss",
+        cwe: "CWE-79",
+        severity: "high",
+        level: "error",
+        message: "Jinja2 autoescape bypass: Markup(" + argName + ") wraps a request-derived value, disabling autoescape when " + "rendered. Pass the raw value to render() and let Jinja2 " + "auto-escape, or sanitize with bleach.clean first.",
+        file,
+        line: i2 + 1,
+        snippet: trimmed.substring(0, 100)
+      });
+      break;
+    }
+  }
+  return out2;
+}
 
 // ../circle-ir/dist/analysis/passes/sink-filter-pass.js
 var JS_XSS_SANITIZERS = [
@@ -38272,7 +39034,7 @@ var colors = {
 };
 
 // src/version.ts
-var version = "3.128.0";
+var version = "3.131.0";
 
 // src/formatters.ts
 var LIBRARY_API_SURFACE_TAG2 = "library-api-surface:caller-responsibility";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cognium-dev",
-  "version": "3.128.0",
+  "version": "3.131.0",
   "description": "Static Application Security Testing CLI for detecting security vulnerabilities via taint tracking",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -66,7 +66,7 @@
   },
   "dependencies": {
     "@cognium/project-profile-detect": "^1.1.0",
-    "circle-ir": "^3.128.0"
+    "circle-ir": "^3.131.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",