cognium-dev 3.131.0 → 3.132.0

package/dist/cli.js

@@ -10902,8 +10902,8 @@ var DEFAULT_SINKS = [
   { method: "unmarshal", class: "Unmarshaller", type: "xxe", cwe: "CWE-611", severity: "high", arg_positions: [0] },
   { method: "newTransformer", class: "TransformerFactory", type: "xxe", cwe: "CWE-611", severity: "high", arg_positions: [0] },
   { method: "transform", class: "Transformer", type: "xxe", cwe: "CWE-611", severity: "high", arg_positions: [0] },
-  { method: "sendRedirect", class: "HttpServletResponse", type: "ssrf", cwe: "CWE-601", severity: "high", arg_positions: [0] },
-  { method: "sendRedirect", type: "ssrf", cwe: "CWE-601", severity: "high", arg_positions: [0] },
+  { method: "sendRedirect", class: "HttpServletResponse", type: "open_redirect", cwe: "CWE-601", severity: "high", arg_positions: [0] },
+  { method: "sendRedirect", type: "open_redirect", cwe: "CWE-601", severity: "high", arg_positions: [0] },
   { method: "openConnection", class: "URL", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [] },
   { method: "openStream", class: "URL", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [] },
   { method: "execute", class: "HttpClient", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0] },
@@ -13400,19 +13400,19 @@ function formatCallCode(call) {
 // ../circle-ir/dist/analysis/findings.js
 function canSourceReachSink(sourceType, sinkType) {
   const sourceToSinkMapping = {
-    http_param: ["sql_injection", "command_injection", "path_traversal", "xss", "xpath_injection", "ldap_injection", "ssrf", "mybatis_mapper_call", "code_injection", "crlf", "mass_assignment"],
-    http_body: ["sql_injection", "command_injection", "deserialization", "xxe", "xss", "code_injection", "mybatis_mapper_call", "crlf", "mass_assignment"],
-    http_header: ["sql_injection", "xss", "ssrf", "mybatis_mapper_call", "code_injection", "crlf"],
-    http_cookie: ["sql_injection", "xss", "mybatis_mapper_call", "code_injection", "crlf"],
-    http_path: ["path_traversal", "sql_injection", "ssrf", "mybatis_mapper_call"],
-    http_query: ["sql_injection", "command_injection", "xss", "ssrf", "mybatis_mapper_call", "code_injection", "crlf", "mass_assignment"],
+    http_param: ["sql_injection", "command_injection", "path_traversal", "xss", "xpath_injection", "ldap_injection", "ssrf", "mybatis_mapper_call", "code_injection", "crlf", "mass_assignment", "open_redirect"],
+    http_body: ["sql_injection", "command_injection", "deserialization", "xxe", "xss", "code_injection", "mybatis_mapper_call", "crlf", "mass_assignment", "open_redirect"],
+    http_header: ["sql_injection", "xss", "ssrf", "mybatis_mapper_call", "code_injection", "crlf", "open_redirect"],
+    http_cookie: ["sql_injection", "xss", "mybatis_mapper_call", "code_injection", "crlf", "open_redirect"],
+    http_path: ["path_traversal", "sql_injection", "ssrf", "mybatis_mapper_call", "open_redirect"],
+    http_query: ["sql_injection", "command_injection", "xss", "ssrf", "mybatis_mapper_call", "code_injection", "crlf", "mass_assignment", "open_redirect"],
     io_input: ["command_injection", "path_traversal", "deserialization", "xxe", "code_injection", "xss", "ssrf"],
     env_input: ["command_injection", "path_traversal"],
     db_input: ["xss", "sql_injection"],
     file_input: ["deserialization", "xxe", "path_traversal", "command_injection", "code_injection"],
     network_input: ["sql_injection", "command_injection", "xss", "ssrf"],
     config_param: ["sql_injection", "command_injection", "path_traversal", "xss", "ssrf"],
-    interprocedural_param: ["sql_injection", "command_injection", "path_traversal", "xss", "xpath_injection", "ldap_injection", "ssrf", "code_injection", "mybatis_mapper_call", "crlf", "mass_assignment"],
+    interprocedural_param: ["sql_injection", "command_injection", "path_traversal", "xss", "xpath_injection", "ldap_injection", "ssrf", "code_injection", "mybatis_mapper_call", "crlf", "mass_assignment", "open_redirect"],
     plugin_param: ["sql_injection", "command_injection", "path_traversal", "xss", "code_injection"]
   };
   const validSinks = sourceToSinkMapping[sourceType];
@@ -22607,6 +22607,9 @@ class LanguageSourcesPass {
       for (const finding of findGoXssFindings(code, graph.ir.meta.file)) {
         ctx.addFinding(finding);
       }
+      for (const finding of findGoLocationHeaderOpenRedirectFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "python") {
       additionalSanitizers.push(...findPythonNetlocAllowlistGuardSanitizers(code));
@@ -22625,6 +22628,9 @@ class LanguageSourcesPass {
       for (const finding of findPythonJinjaMarkupXssFindings(code, graph.ir.meta.file)) {
         ctx.addFinding(finding);
       }
+      for (const finding of findPythonHeadersSubscriptOpenRedirectFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "rust") {
       additionalSanitizers.push(...findRustSetAllowlistGuardSanitizers(code));
@@ -22646,6 +22652,9 @@ class LanguageSourcesPass {
       for (const finding of findRustWeakCryptoEcbFindings(code, graph.ir.meta.file)) {
         ctx.addFinding(finding);
       }
+      for (const finding of findRustAppendHeaderTupleOpenRedirectFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "javascript" || language === "typescript" || language === "htmljs") {
       additionalSanitizers.push(...findJsSafeJsonParseSanitizers(code));
@@ -22664,6 +22673,9 @@ class LanguageSourcesPass {
       for (const finding of findTsAngularBypassXssFindings(code, graph.ir.meta.file)) {
         ctx.addFinding(finding);
       }
+      for (const finding of findJsDomOpenRedirectFindings(code, graph.ir.meta.file)) {
+        ctx.addFinding(finding);
+      }
     }
     if (language === "java") {
       additionalSanitizers.push(...findJavaSafeJsonParseSanitizers(code));
@@ -25907,6 +25919,289 @@ function findPythonJinjaMarkupXssFindings(code, file) {
   }
   return out2;
 }
+function findGoLocationHeaderOpenRedirectFindings(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 safeWrapRe = /\b(?:net\/url|url)\.Parse\b[\s\S]{0,120}?\b(?:IsAbs|Host)\b|\bstrings\.HasPrefix\s*\(/;
+  const callRe = /\b([A-Za-z_]\w*)\s*\.\s*Header\s*\(\s*\)\s*\.\s*(?:Set|Add)\s*\(\s*(['"])([^'"]+)\2\s*,\s*([\s\S]*)\)\s*(?:\/\/.*)?$/;
+  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(callRe);
+    if (!m)
+      continue;
+    const recv = m[1];
+    if (!rwNames.has(recv))
+      continue;
+    const key = m[3];
+    if (key.toLowerCase() !== "location")
+      continue;
+    const valExpr = m[4];
+    const valTrim = valExpr.trim();
+    if (/^"(?:\\.|[^"\\])*"$/.test(valTrim))
+      continue;
+    if (safeWrapRe.test(valExpr))
+      continue;
+    out2.push({
+      id: `open_redirect-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "open_redirect",
+      cwe: "CWE-601",
+      severity: "high",
+      level: "error",
+      message: 'Open redirect: ResponseWriter.Header().Set("Location", ...) ' + "writes a user-controlled value into the Location header without " + "validating the target. Restrict to an allow-list of hosts/paths " + "or compare against a known-safe set before issuing the redirect.",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findPythonHeadersSubscriptOpenRedirectFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  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]);
+  }
+  const safeWrapRe = /\b(?:urllib\.parse\.urlparse|urlparse)\s*\([\s\S]{0,120}?\bnetloc\b|\b(?:startswith)\s*\(/;
+  const subscriptRe = /\b([A-Za-z_]\w*)\s*\.\s*headers\s*\[\s*(['"])([^'"]+)\2\s*\]\s*=\s*(.+)$/;
+  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(subscriptRe);
+    if (!m)
+      continue;
+    const key = m[3];
+    if (key.toLowerCase() !== "location")
+      continue;
+    const rhs = m[4].replace(/\s*(?:#.*)?$/, "").trim();
+    if (/^['"](?:\\.|[^'"\\])*['"]$/.test(rhs))
+      continue;
+    if (safeWrapRe.test(rhs))
+      continue;
+    const hasTaintedVar = [...taintedVars].some((v) => new RegExp(`\\b${v}\\b`).test(rhs));
+    const inlineSource = /\brequest\s*\.\s*(?:args|form|values|files|cookies|headers|json)(?:\s*\.\s*get\s*\(|\s*\[)/.test(rhs);
+    if (!hasTaintedVar && !inlineSource)
+      continue;
+    out2.push({
+      id: `open_redirect-${file}-${i2 + 1}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "open_redirect",
+      cwe: "CWE-601",
+      severity: "high",
+      level: "error",
+      message: 'Open redirect: response.headers["Location"] = ... assigns a ' + "user-controlled value to the Location header. Validate the URL " + "against an allow-list of trusted hosts before sending.",
+      file,
+      line: i2 + 1,
+      snippet: trimmed.substring(0, 100)
+    });
+  }
+  return out2;
+}
+function findRustAppendHeaderTupleOpenRedirectFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const extractorRe = /\b([A-Za-z_]\w*)\s*:\s*(?:web\s*::\s*)?(?:Query|Path|Form|Json)\s*<|\b([A-Za-z_]\w*)\s*:\s*&?\s*HttpRequest\b/g;
+  const extractorParams = new Set;
+  for (const line of lines) {
+    let m;
+    extractorRe.lastIndex = 0;
+    while ((m = extractorRe.exec(line)) !== null) {
+      const name2 = m[1] ?? m[2];
+      if (name2)
+        extractorParams.add(name2);
+    }
+  }
+  if (extractorParams.size === 0)
+    return out2;
+  const taintedVars = new Set(extractorParams);
+  const letRe = /\blet\s+(?:mut\s+)?([A-Za-z_]\w*)\s*(?::[^=]+)?=\s*([^;]+);/g;
+  for (let pass = 0;pass < 4; pass++) {
+    const before = taintedVars.size;
+    let lm;
+    letRe.lastIndex = 0;
+    while ((lm = letRe.exec(code)) !== null) {
+      const name2 = lm[1];
+      const rhs = lm[2];
+      if (taintedVars.has(name2))
+        continue;
+      for (const tv of taintedVars) {
+        if (new RegExp(`\\b${tv}\\b`).test(rhs)) {
+          taintedVars.add(name2);
+          break;
+        }
+      }
+    }
+    if (taintedVars.size === before)
+      break;
+  }
+  const safeWrapRe = /\b(?:Url\s*::\s*parse|url\s*::\s*Url\s*::\s*parse)\s*\([\s\S]{0,160}?\b(?:host_str|host|origin)\b/;
+  const tupleCallRe = /\.\s*(?:append_header|insert_header)\s*\(\s*\(\s*(['"])([^'"]+)\1\s*,\s*([^)]*?)\s*\)\s*\)/g;
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    let cm;
+    tupleCallRe.lastIndex = 0;
+    while ((cm = tupleCallRe.exec(raw)) !== null) {
+      const key = cm[2];
+      if (key.toLowerCase() !== "location")
+        continue;
+      const valExpr = cm[3];
+      if (/^['"](?:\\.|[^'"\\])*['"]$/.test(valExpr.trim()))
+        continue;
+      if (safeWrapRe.test(valExpr))
+        continue;
+      const hasTainted = [...taintedVars].some((v) => new RegExp(`\\b${v}\\b`).test(valExpr));
+      if (!hasTainted)
+        continue;
+      out2.push({
+        id: `open_redirect-${file}-${i2 + 1}`,
+        pass: "language-sources",
+        category: "security",
+        rule_id: "open_redirect",
+        cwe: "CWE-601",
+        severity: "high",
+        level: "error",
+        message: "Open redirect: HttpResponse builder " + '.append_header(("Location", ...)) sets the Location header from ' + "a request-derived value without allow-list validation. Parse " + "with url::Url::parse and compare host_str against an allow-list.",
+        file,
+        line: i2 + 1,
+        snippet: trimmed.substring(0, 100)
+      });
+      break;
+    }
+  }
+  return out2;
+}
+function findJsDomOpenRedirectFindings(code, file) {
+  const out2 = [];
+  const lines = code.split(`
+`);
+  const domSourceRe = /\blocation\s*\.\s*(?:search|hash|href|pathname)\b|\bwindow\s*\.\s*location\s*\.\s*(?:search|hash|href|pathname)\b|\bURLSearchParams\b|\bdocument\s*\.\s*(?:referrer|URL|location\s*\.\s*(?:search|hash|href|pathname))\b|\bwindow\s*\.\s*name\b/;
+  const taintedVars = 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 (domSourceRe.test(am[2]))
+      taintedVars.add(am[1]);
+  }
+  for (let pass = 0;pass < 4; pass++) {
+    const before = taintedVars.size;
+    assignRe.lastIndex = 0;
+    while ((am = assignRe.exec(code)) !== null) {
+      if (taintedVars.has(am[1]))
+        continue;
+      for (const tv of taintedVars) {
+        if (new RegExp(`\\b${tv}\\b`).test(am[2])) {
+          taintedVars.add(am[1]);
+          break;
+        }
+      }
+    }
+    if (taintedVars.size === before)
+      break;
+  }
+  const safeWrapRe = /\b(?:startsWith|includes)\s*\(\s*['"`]\/[^'"`]*['"`]\s*\)|\bnew\s+URL\s*\([\s\S]{0,80}?\)\s*\.\s*(?:origin|hostname)\s*===/;
+  const containsTaint = (expr) => {
+    if (domSourceRe.test(expr))
+      return true;
+    for (const tv of taintedVars) {
+      if (new RegExp(`\\b${tv}\\b`).test(expr))
+        return true;
+    }
+    return false;
+  };
+  const hrefSinkRe = /\b(?:(?:window|document|self|top|parent)\s*\.\s*)?location\s*\.\s*href\s*=\s*([^;\n]+?)\s*;?\s*(?:\/\/.*)?$/;
+  const locSinkRe = /\b(?:window|document|self|top|parent)\s*\.\s*location\s*=\s*([^;\n]+?)\s*;?\s*(?:\/\/.*)?$/;
+  const contentSinkRe = /\.\s*content\s*=\s*([^\n]+?)\s*$/;
+  const callSinkRe = /\b(?:(?:window|document|self|top|parent)\s*\.\s*)?location\s*\.\s*(?:assign|replace)\s*\(\s*([^)]+)\)/;
+  const emit = (line, msg, snippet) => {
+    out2.push({
+      id: `open_redirect-${file}-${line}`,
+      pass: "language-sources",
+      category: "security",
+      rule_id: "open_redirect",
+      cwe: "CWE-601",
+      severity: "high",
+      level: "error",
+      message: msg,
+      file,
+      line,
+      snippet: snippet.substring(0, 100)
+    });
+  };
+  const isLiteralOnly = (expr) => /^['"`](?:\\.|[^'"`\\])*['"`]$/.test(expr.trim());
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const raw = lines[i2];
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith("//"))
+      continue;
+    let matched = false;
+    const hm = trimmed.match(hrefSinkRe);
+    if (hm) {
+      const rhs = hm[1].trim();
+      if (!isLiteralOnly(rhs) && containsTaint(rhs) && !safeWrapRe.test(rhs)) {
+        emit(i2 + 1, "Open redirect: assignment to location.href uses a value " + "derived from a URL query/hash without allow-list validation. " + "Compare the target origin to a known-safe set before navigating.", trimmed);
+        matched = true;
+      }
+    }
+    if (!matched) {
+      const lm = trimmed.match(locSinkRe);
+      if (lm) {
+        const rhs = lm[1].trim();
+        if (!isLiteralOnly(rhs) && containsTaint(rhs) && !safeWrapRe.test(rhs)) {
+          emit(i2 + 1, "Open redirect: assignment to window.location uses a value " + "derived from a URL query/hash without allow-list validation. " + "Compare the target origin to a known-safe set before navigating.", trimmed);
+          matched = true;
+        }
+      }
+    }
+    if (!matched) {
+      const cm = trimmed.match(contentSinkRe);
+      if (cm) {
+        const rhs = cm[1].replace(/\s*\/\/.*$/, "").replace(/\s*;\s*$/, "").trim();
+        if (!isLiteralOnly(rhs) && /['"`][^'"`]*\burl\s*=/i.test(rhs) && containsTaint(rhs) && !safeWrapRe.test(rhs)) {
+          emit(i2 + 1, "Open redirect: DOM assignment to <meta>.content with a " + "meta-refresh URL built from a URL query/hash without " + "allow-list validation. Validate origin before navigating.", trimmed);
+          matched = true;
+        }
+      }
+    }
+    if (!matched) {
+      const callm = trimmed.match(callSinkRe);
+      if (callm) {
+        const arg = callm[1].trim();
+        if (!isLiteralOnly(arg) && containsTaint(arg) && !safeWrapRe.test(arg)) {
+          emit(i2 + 1, "Open redirect: location.assign / location.replace invoked " + "with a value derived from a URL query/hash without allow-" + "list validation. Validate origin before navigating.", trimmed);
+        }
+      }
+    }
+  }
+  return out2;
+}
 
 // ../circle-ir/dist/analysis/passes/sink-filter-pass.js
 var JS_XSS_SANITIZERS = [
@@ -27371,13 +27666,13 @@ class TaintPropagationPass {
     }));
     const arrayFlows = detectArrayElementFlows(calls, sources, sinks, constProp.taintedArrayElements, constProp.unreachableLines, types) ?? [];
     for (const f of arrayFlows) {
-      if (!flows.some((x) => x.source_line === f.source_line && x.sink_line === f.sink_line)) {
+      if (!flows.some((x) => x.source_line === f.source_line && x.sink_line === f.sink_line && x.sink_type === f.sink_type)) {
         flows.push(f);
       }
     }
     const collectionFlows = detectCollectionFlows(calls, sources, sinks, constProp.tainted, constProp.unreachableLines, ctx.code, types) ?? [];
     for (const f of collectionFlows) {
-      if (flows.some((x) => x.source_line === f.source_line && x.sink_line === f.sink_line))
+      if (flows.some((x) => x.source_line === f.source_line && x.sink_line === f.sink_line && x.sink_type === f.sink_type))
         continue;
       const flowForCheck = {
         source: { line: f.source_line },
@@ -27399,7 +27694,7 @@ class TaintPropagationPass {
     }
     const paramFlows = detectParameterSinkFlows(types, calls, sources, sinks, constProp.unreachableLines, constProp.tainted, ctx.code) ?? [];
     for (const f of paramFlows) {
-      if (!flows.some((x) => x.source_line === f.source_line && x.sink_line === f.sink_line)) {
+      if (!flows.some((x) => x.source_line === f.source_line && x.sink_line === f.sink_line && x.sink_type === f.sink_type)) {
         flows.push(f);
       }
     }
@@ -27837,7 +28132,7 @@ function detectParameterSinkFlows(types, calls, sources, sinks, unreachableLines
           }
           const paramSource = methodParamSources.get(arg.variable);
           if (paramSource) {
-            const exists = flows.some((f) => f.source_line === paramSource.line && f.sink_line === sink.line);
+            const exists = flows.some((f) => f.source_line === paramSource.line && f.sink_line === sink.line && f.sink_type === sink.type);
             if (!exists) {
               if (typeof code === "string" && isReassignedToLiteralBetween(code, arg.variable, paramSource.line, sink.line)) {
                 continue;
@@ -39034,7 +39329,7 @@ var colors = {
 };
 
 // src/version.ts
-var version = "3.131.0";
+var version = "3.132.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.131.0",
+  "version": "3.132.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.131.0"
+    "circle-ir": "^3.132.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",