circle-ir 3.129.0 → 3.131.0

package/dist/browser/circle-ir.js

@@ -23654,6 +23654,9 @@ var LanguageSourcesPass = class {
       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));
@@ -23666,6 +23669,12 @@ var LanguageSourcesPass = class {
       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));
@@ -23694,9 +23703,17 @@ var LanguageSourcesPass = class {
       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));
@@ -23708,6 +23725,9 @@ var LanguageSourcesPass = class {
       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(
@@ -25454,6 +25474,55 @@ function findJsSsrfAllowlistGuardSanitizers(code) {
   }
   return sanitizers;
 }
+function findJsArgvFormExecSanitizers(code) {
+  const sanitizers = [];
+  const lines = code.split("\n");
+  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("\n");
+  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("\n");
@@ -26212,6 +26281,341 @@ function findJsPatternFindings(code, file) {
   }
   return out2;
 }
+function findGoXssFindings(code, file) {
+  const out2 = [];
+  const lines = code.split("\n");
+  const rwNames = /* @__PURE__ */ 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("\n");
+  const respNames = /* @__PURE__ */ 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("\n");
+  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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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("\n");
+  const sanitizerNames = /* @__PURE__ */ 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("\n");
+  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 = /* @__PURE__ */ 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) || // f-string with interpolation. Allow any non-`{` char between the
+      // opening quote and the first `{` (Python f-strings may embed `"`
+      // when single-quoted and vice-versa, e.g. f'<a href="{u}">').
+      /\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("\n");
+  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 = /* @__PURE__ */ 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;
+}
 
 // src/analysis/passes/sink-filter-pass.ts
 var JS_XSS_SANITIZERS = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "circle-ir",
-  "version": "3.129.0",
+  "version": "3.131.0",
   "description": "High-performance Static Application Security Testing (SAST) library for detecting security vulnerabilities through taint analysis",
   "main": "dist/index.js",
   "module": "dist/index.js",