circle-ir 3.167.0 → 3.173.0

package/dist/core/circle-ir-core.cjs

@@ -7543,33 +7543,33 @@ function detectLanguage2(tree) {
   if (pythonScore > jsScore && pythonScore > javaScore) return "python";
   return jsScore > javaScore ? "javascript" : "java";
 }
-function extractImports(tree, language) {
+function extractImports(tree, language, cache) {
   const effectiveLanguage = language ?? detectLanguage2(tree);
   const isJavaScript = effectiveLanguage === "javascript" || effectiveLanguage === "typescript" || effectiveLanguage === "tsx";
   const isPython = effectiveLanguage === "python";
   const isRust = effectiveLanguage === "rust";
   if (effectiveLanguage === "go") {
-    return extractGoImports(tree);
+    return extractGoImports(tree, cache);
   }
   if (isRust) {
-    return extractRustImports(tree);
+    return extractRustImports(tree, cache);
   }
   if (isPython) {
-    return extractPythonImports(tree);
+    return extractPythonImports(tree, cache);
   }
   if (isJavaScript) {
-    return extractJavaScriptImports(tree);
+    return extractJavaScriptImports(tree, cache);
   }
-  return extractJavaImports(tree);
+  return extractJavaImports(tree, cache);
 }
-function extractJavaScriptImports(tree) {
+function extractJavaScriptImports(tree, cache) {
   const imports = [];
-  const importStatements = findNodes(tree.rootNode, "import_statement");
+  const importStatements = getNodesFromCache(tree.rootNode, "import_statement", cache);
   for (const importStmt of importStatements) {
     const importInfos = extractJSImportInfo(importStmt);
     imports.push(...importInfos);
   }
-  const exportStatements = findNodes(tree.rootNode, "export_statement");
+  const exportStatements = getNodesFromCache(tree.rootNode, "export_statement", cache);
   for (const exportStmt of exportStatements) {
     const sourceNode = exportStmt.childForFieldName("source");
     if (!sourceNode) continue;
@@ -7583,13 +7583,13 @@ function extractJavaScriptImports(tree) {
       line_number: exportStmt.startPosition.row + 1
     });
   }
-  const requireCalls = findRequireCalls(tree);
+  const requireCalls = findRequireCalls(tree, cache);
   imports.push(...requireCalls);
   return imports;
 }
-function extractJavaImports(tree) {
+function extractJavaImports(tree, cache) {
   const imports = [];
-  const importDecls = findNodes(tree.rootNode, "import_declaration");
+  const importDecls = getNodesFromCache(tree.rootNode, "import_declaration", cache);
   for (const importDecl of importDecls) {
     const importInfo = extractJavaImportInfo(importDecl);
     if (importInfo) {
@@ -7737,9 +7737,9 @@ function extractJSImportInfo(node) {
   }
   return imports;
 }
-function findRequireCalls(tree) {
+function findRequireCalls(tree, cache) {
   const imports = [];
-  const callExpressions = findNodes(tree.rootNode, "call_expression");
+  const callExpressions = getNodesFromCache(tree.rootNode, "call_expression", cache);
   for (const call of callExpressions) {
     const funcNode = call.childForFieldName("function");
     if (!funcNode || getNodeText(funcNode) !== "require") continue;
@@ -7853,14 +7853,14 @@ function parseImportPath(fullPath, isWildcard) {
     fromPackage: fullPath.substring(0, lastDot)
   };
 }
-function extractPythonImports(tree) {
+function extractPythonImports(tree, cache) {
   const imports = [];
-  const importStatements = findNodes(tree.rootNode, "import_statement");
+  const importStatements = getNodesFromCache(tree.rootNode, "import_statement", cache);
   for (const stmt of importStatements) {
     const importInfos = extractPythonImportStatement(stmt);
     imports.push(...importInfos);
   }
-  const importFromStatements = findNodes(tree.rootNode, "import_from_statement");
+  const importFromStatements = getNodesFromCache(tree.rootNode, "import_from_statement", cache);
   for (const stmt of importFromStatements) {
     const importInfos = extractPythonFromImportStatement(stmt);
     imports.push(...importInfos);
@@ -7954,9 +7954,9 @@ function extractPythonFromImportStatement(node) {
   }
   return imports;
 }
-function extractRustImports(tree) {
+function extractRustImports(tree, cache) {
   const imports = [];
-  const useDecls = findNodes(tree.rootNode, "use_declaration");
+  const useDecls = getNodesFromCache(tree.rootNode, "use_declaration", cache);
   for (const useDecl of useDecls) {
     const useImports = extractRustUseDecl(useDecl);
     imports.push(...useImports);
@@ -8098,9 +8098,9 @@ function extractRustScopedUseList(node, lineNumber) {
   }
   return imports;
 }
-function extractGoImports(tree) {
+function extractGoImports(tree, cache) {
   const imports = [];
-  const importDecls = findNodes(tree.rootNode, "import_declaration");
+  const importDecls = getNodesFromCache(tree.rootNode, "import_declaration", cache);
   for (const decl of importDecls) {
     const singleSpec = findGoChildByType(decl, "import_spec");
     if (singleSpec) {
@@ -8235,7 +8235,7 @@ function detectLanguage3(tree) {
   }
   return jsScore > javaScore ? "javascript" : "java";
 }
-function buildCFG(tree, language) {
+function buildCFG(tree, language, cache) {
   const effectiveLanguage = language ?? detectLanguage3(tree);
   const isJavaScript = effectiveLanguage === "javascript" || effectiveLanguage === "typescript" || effectiveLanguage === "tsx";
   const allBlocks = [];
@@ -8249,11 +8249,11 @@ function buildCFG(tree, language) {
   }
   if (isJavaScript) {
     const functions = [
-      ...findNodes(tree.rootNode, "function_declaration"),
-      ...findNodes(tree.rootNode, "arrow_function"),
-      ...findNodes(tree.rootNode, "method_definition"),
-      ...findNodes(tree.rootNode, "function"),
-      ...findNodes(tree.rootNode, "function_expression")
+      ...getNodesFromCache(tree.rootNode, "function_declaration", cache),
+      ...getNodesFromCache(tree.rootNode, "arrow_function", cache),
+      ...getNodesFromCache(tree.rootNode, "method_definition", cache),
+      ...getNodesFromCache(tree.rootNode, "function", cache),
+      ...getNodesFromCache(tree.rootNode, "function_expression", cache)
     ];
     for (const func2 of functions) {
       const body2 = func2.childForFieldName("body");
@@ -8275,8 +8275,8 @@ function buildCFG(tree, language) {
     }
   } else {
     const methods = [
-      ...findNodes(tree.rootNode, "method_declaration"),
-      ...findNodes(tree.rootNode, "constructor_declaration")
+      ...getNodesFromCache(tree.rootNode, "method_declaration", cache),
+      ...getNodesFromCache(tree.rootNode, "constructor_declaration", cache)
     ];
     for (const method of methods) {
       const body2 = method.childForFieldName("body");
@@ -10529,7 +10529,86 @@ var DEFAULT_SOURCES = [
   { method: "recv", class: "TcpStream", type: "network_input", severity: "high", return_tainted: true },
   { method: "read", class: "TcpStream", type: "network_input", severity: "high", return_tainted: true },
   { method: "read_to_end", class: "TcpStream", type: "network_input", severity: "high", return_tainted: true },
-  { method: "read_to_string", class: "TcpStream", type: "network_input", severity: "high", return_tainted: true }
+  { method: "read_to_string", class: "TcpStream", type: "network_input", severity: "high", return_tainted: true },
+  // =========================================================================
+  // Modern taint sources (cognium-dev #242 — 3.170.0)
+  // GraphQL resolver args, gRPC request metadata, cache reads (second-order
+  // taint), and JWT claims (unverified decode). These attacker-influenced
+  // surfaces were previously silent — a resolver that concatenated an
+  // `Args`-annotated field into a SQL string produced zero flows.
+  // =========================================================================
+  // --- GraphQL resolver argument sources (JS / TS — Apollo, TypeGraphQL, NestJS) ---
+  // TypeGraphQL / NestJS annotate query/mutation/subscription methods; every
+  // parameter on the annotated method carries attacker input from the GraphQL
+  // POST body's `variables` field.
+  { method_annotation: "Query", type: "http_body", severity: "high", languages: ["javascript", "typescript"] },
+  { method_annotation: "Mutation", type: "http_body", severity: "high", languages: ["javascript", "typescript"] },
+  { method_annotation: "Subscription", type: "http_body", severity: "high", languages: ["javascript", "typescript"] },
+  { method_annotation: "FieldResolver", type: "http_body", severity: "high", languages: ["javascript", "typescript"] },
+  { method_annotation: "ResolveField", type: "http_body", severity: "high", languages: ["javascript", "typescript"] },
+  // Parameter-level: `@Arg('id') id: string`, `@Args('input') input: FooDto`.
+  { annotation: "Arg", type: "http_param", severity: "high", param_tainted: true, languages: ["javascript", "typescript"] },
+  { annotation: "Args", type: "http_param", severity: "high", param_tainted: true, languages: ["javascript", "typescript"] },
+  // --- GraphQL resolver argument sources (Python — Strawberry, Graphene, Ariadne) ---
+  { method_annotation: "strawberry.field", type: "http_body", severity: "high", languages: ["python"] },
+  { method_annotation: "strawberry.mutation", type: "http_body", severity: "high", languages: ["python"] },
+  { method_annotation: "strawberry.subscription", type: "http_body", severity: "high", languages: ["python"] },
+  // --- GraphQL resolver argument sources (Java — Netflix DGS, SPQR, graphql-java-annotations) ---
+  { method_annotation: "DgsQuery", type: "http_body", severity: "high", languages: ["java"] },
+  { method_annotation: "DgsMutation", type: "http_body", severity: "high", languages: ["java"] },
+  { method_annotation: "DgsSubscription", type: "http_body", severity: "high", languages: ["java"] },
+  { method_annotation: "DgsData", type: "http_body", severity: "high", languages: ["java"] },
+  { method_annotation: "GraphQLQuery", type: "http_body", severity: "high", languages: ["java"] },
+  { method_annotation: "GraphQLMutation", type: "http_body", severity: "high", languages: ["java"] },
+  { annotation: "InputArgument", type: "http_param", severity: "high", param_tainted: true, languages: ["java"] },
+  { annotation: "GraphQLArgument", type: "http_param", severity: "high", param_tainted: true, languages: ["java"] },
+  // --- gRPC request metadata (Python — grpcio) ---
+  // `context.invocation_metadata()` returns the caller-supplied metadata tuple.
+  // No `class` filter — receiver names vary (`context`, `ctx`, `servicer_context`).
+  { method: "invocation_metadata", type: "http_header", severity: "high", return_tainted: true, languages: ["python"] },
+  // --- gRPC request metadata (JS / TS — @grpc/grpc-js) ---
+  // `call.metadata.get(key)` / `call.metadata.getMap()` inside a service handler.
+  { method: "get", class: "Metadata", type: "http_header", severity: "high", return_tainted: true, languages: ["javascript", "typescript"] },
+  { method: "getMap", class: "Metadata", type: "http_header", severity: "high", return_tainted: true, languages: ["javascript", "typescript"] },
+  // --- gRPC request metadata (Go — google.golang.org/grpc/metadata) ---
+  // `md, _ := metadata.FromIncomingContext(ctx)` pulls the caller's headers.
+  { method: "FromIncomingContext", class: "metadata", type: "http_header", severity: "high", return_tainted: true, languages: ["go"] },
+  // --- gRPC request metadata (Java — io.grpc.Metadata) ---
+  // Server-side interceptor receives `Metadata headers`; `headers.get(KEY)`
+  // returns caller-supplied header values.
+  { method: "get", class: "Metadata", type: "http_header", severity: "high", return_tainted: true, languages: ["java"] },
+  // --- Cache reads (second-order taint — Redis / Memcached / Django cache) ---
+  // The cache round-trip is a canonical second-order sink: whatever was
+  // written previously (potentially attacker-controlled) resurfaces on read.
+  // Severity 'medium' — cache contents are usually filtered by the writer but
+  // the read side often forgets that guarantee. Class-scoped to `Redis`,
+  // `Jedis`, `cache` to avoid colliding with generic `Map.get()`.
+  { method: "get", class: "Redis", type: "db_input", severity: "medium", return_tainted: true, languages: ["python"] },
+  { method: "hget", class: "Redis", type: "db_input", severity: "medium", return_tainted: true, languages: ["python"] },
+  { method: "mget", class: "Redis", type: "db_input", severity: "medium", return_tainted: true, languages: ["python"] },
+  { method: "lrange", class: "Redis", type: "db_input", severity: "medium", return_tainted: true, languages: ["python"] },
+  { method: "get", class: "cache", type: "db_input", severity: "medium", return_tainted: true, languages: ["python"] },
+  { method: "get_many", class: "cache", type: "db_input", severity: "medium", return_tainted: true, languages: ["python"] },
+  { method: "get", class: "Redis", type: "db_input", severity: "medium", return_tainted: true, languages: ["javascript", "typescript"] },
+  { method: "hget", class: "Redis", type: "db_input", severity: "medium", return_tainted: true, languages: ["javascript", "typescript"] },
+  { method: "mget", class: "Redis", type: "db_input", severity: "medium", return_tainted: true, languages: ["javascript", "typescript"] },
+  { method: "get", class: "Jedis", type: "db_input", severity: "medium", return_tainted: true, languages: ["java"] },
+  { method: "hget", class: "Jedis", type: "db_input", severity: "medium", return_tainted: true, languages: ["java"] },
+  { method: "mget", class: "Jedis", type: "db_input", severity: "medium", return_tainted: true, languages: ["java"] },
+  // --- JWT claims (unverified decode — PyJWT / jose / jsonwebtoken / auth0 java-jwt / golang-jwt) ---
+  // A JWT's payload is *always* attacker-authored. Even after verification
+  // the *contents* of the claims (username, role, custom fields) are not
+  // trusted for downstream flows into SQL, HTML, shell, etc. The `decode`
+  // variants here return the parsed claims dictionary/object.
+  { method: "decode", class: "jwt", type: "http_header", severity: "high", return_tainted: true, languages: ["python"] },
+  { method: "get_unverified_claims", class: "jwt", type: "http_header", severity: "high", return_tainted: true, languages: ["python"] },
+  { method: "get_unverified_header", class: "jwt", type: "http_header", severity: "high", return_tainted: true, languages: ["python"] },
+  { method: "decode", class: "jwt", type: "http_header", severity: "high", return_tainted: true, languages: ["javascript", "typescript"] },
+  { method: "decode", class: "jsonwebtoken", type: "http_header", severity: "high", return_tainted: true, languages: ["javascript", "typescript"] },
+  { method: "decodeJwt", class: "jose", type: "http_header", severity: "high", return_tainted: true, languages: ["javascript", "typescript"] },
+  { method: "decodeProtectedHeader", class: "jose", type: "http_header", severity: "high", return_tainted: true, languages: ["javascript", "typescript"] },
+  { method: "decode", class: "JWT", type: "http_header", severity: "high", return_tainted: true, languages: ["java"] },
+  { method: "ParseUnverified", class: "jwt", type: "http_header", severity: "high", return_tainted: true, languages: ["go"] }
 ];
 var DEFAULT_SINKS = [
   // SQL Injection (CWE-89)
@@ -12582,6 +12661,9 @@ function findSources(calls, types, patterns, sourceLines, language) {
       for (const param of method.parameters) {
         for (const pattern of patterns) {
           if (pattern.annotation && pattern.param_tainted) {
+            if (pattern.languages && pattern.languages.length > 0 && language !== void 0 && !pattern.languages.includes(language)) {
+              continue;
+            }
             if (matchesAnnotation(param.annotations, pattern.annotation)) {
               const paramLine = param.line ?? method.start_line;
               sources.push({
@@ -12602,6 +12684,9 @@ function findSources(calls, types, patterns, sourceLines, language) {
     for (const method of type.methods) {
       for (const pattern of patterns) {
         if (!pattern.method_annotation) continue;
+        if (pattern.languages && pattern.languages.length > 0 && language !== void 0 && !pattern.languages.includes(language)) {
+          continue;
+        }
         if (!matchesAnnotation(method.annotations, pattern.method_annotation)) continue;
         for (const param of method.parameters) {
           const paramLine = param.line ?? method.start_line;
@@ -12866,7 +12951,7 @@ function isParameterizedQueryCall(call, pattern) {
     const secondArg = call.arguments.find((a) => a.position === 1);
     if (secondArg?.expression) {
       const expr = secondArg.expression.trim();
-      if (expr.startsWith("[")) {
+      if (expr.startsWith("[") && !/^\[\s*\]$/.test(expr)) {
         return true;
       }
     }
@@ -13307,52 +13392,74 @@ function matchesSourcePattern(call, pattern) {
   }
   return false;
 }
+var JS_SOURCE_PATTERN_CACHE = /* @__PURE__ */ new WeakMap();
+var JS_FALLBACK_COMPILED = (() => {
+  const bases = [
+    { base: "req\\.params", sourceType: "http_param" },
+    { base: "req\\.query", sourceType: "http_param" },
+    { base: "req\\.body", sourceType: "http_body" },
+    { base: "req\\.headers", sourceType: "http_header" },
+    { base: "req\\.cookies", sourceType: "http_cookie" },
+    { base: "req\\.url", sourceType: "http_path" },
+    { base: "req\\.path", sourceType: "http_path" },
+    { base: "req\\.originalUrl", sourceType: "http_path" },
+    { base: "req\\.file", sourceType: "file_input" },
+    { base: "req\\.files", sourceType: "file_input" },
+    { base: "request\\.params", sourceType: "http_param" },
+    { base: "request\\.query", sourceType: "http_param" },
+    { base: "request\\.body", sourceType: "http_body" },
+    { base: "request\\.headers", sourceType: "http_header" },
+    { base: "process\\.env", sourceType: "env_input" },
+    { base: "process\\.argv", sourceType: "io_input" },
+    { base: "ctx\\.query", sourceType: "http_param" },
+    { base: "ctx\\.params", sourceType: "http_param" },
+    { base: "ctx\\.request", sourceType: "http_body" }
+  ];
+  const exact = [];
+  const contained = [];
+  for (const { base, sourceType } of bases) {
+    exact.push({ pattern: new RegExp(`^${base}\\b`), sourceType });
+    contained.push({ pattern: new RegExp(`\\b${base}\\b`), sourceType });
+  }
+  return { exact, contained };
+})();
+function compileJsSourcePatterns(sourcePatterns) {
+  const cached = JS_SOURCE_PATTERN_CACHE.get(sourcePatterns);
+  if (cached) return cached;
+  const exact = [];
+  const contained = [];
+  for (const sp of sourcePatterns) {
+    if (sp.property && sp.object && sp.property_tainted) {
+      exact.push({
+        pattern: new RegExp(`^${sp.object}\\.${sp.property}\\b`),
+        sourceType: sp.type
+      });
+      contained.push({
+        pattern: new RegExp(`\\b${sp.object}\\.${sp.property}\\b`),
+        sourceType: sp.type
+      });
+    }
+  }
+  const compiled = { exact, contained };
+  JS_SOURCE_PATTERN_CACHE.set(sourcePatterns, compiled);
+  return compiled;
+}
 function isJavaScriptTaintedArgument(argExpression, sourcePatterns) {
-  const exactPatterns = [];
-  const containedPatterns = [];
-  if (sourcePatterns) {
-    for (const sp of sourcePatterns) {
-      if (sp.property && sp.object && sp.property_tainted) {
-        const exactRegex = new RegExp(`^${sp.object}\\.${sp.property}\\b`);
-        exactPatterns.push({ pattern: exactRegex, sourceType: sp.type });
-        const containedRegex = new RegExp(`\\b${sp.object}\\.${sp.property}\\b`);
-        containedPatterns.push({ pattern: containedRegex, sourceType: sp.type });
-      }
-    }
-  }
-  if (exactPatterns.length === 0) {
-    const basePatterns = [
-      { base: "req\\.params", sourceType: "http_param" },
-      { base: "req\\.query", sourceType: "http_param" },
-      { base: "req\\.body", sourceType: "http_body" },
-      { base: "req\\.headers", sourceType: "http_header" },
-      { base: "req\\.cookies", sourceType: "http_cookie" },
-      { base: "req\\.url", sourceType: "http_path" },
-      { base: "req\\.path", sourceType: "http_path" },
-      { base: "req\\.originalUrl", sourceType: "http_path" },
-      { base: "req\\.file", sourceType: "file_input" },
-      { base: "req\\.files", sourceType: "file_input" },
-      { base: "request\\.params", sourceType: "http_param" },
-      { base: "request\\.query", sourceType: "http_param" },
-      { base: "request\\.body", sourceType: "http_body" },
-      { base: "request\\.headers", sourceType: "http_header" },
-      { base: "process\\.env", sourceType: "env_input" },
-      { base: "process\\.argv", sourceType: "io_input" },
-      { base: "ctx\\.query", sourceType: "http_param" },
-      { base: "ctx\\.params", sourceType: "http_param" },
-      { base: "ctx\\.request", sourceType: "http_body" }
-    ];
-    for (const { base, sourceType } of basePatterns) {
-      exactPatterns.push({ pattern: new RegExp(`^${base}\\b`), sourceType });
-      containedPatterns.push({ pattern: new RegExp(`\\b${base}\\b`), sourceType });
+  let compiled;
+  if (sourcePatterns && sourcePatterns.length > 0) {
+    compiled = compileJsSourcePatterns(sourcePatterns);
+    if (compiled.exact.length === 0) {
+      compiled = JS_FALLBACK_COMPILED;
     }
+  } else {
+    compiled = JS_FALLBACK_COMPILED;
   }
-  for (const { pattern, sourceType } of exactPatterns) {
+  for (const { pattern, sourceType } of compiled.exact) {
     if (pattern.test(argExpression)) {
       return { isTainted: true, sourceType };
     }
   }
-  for (const { pattern, sourceType } of containedPatterns) {
+  for (const { pattern, sourceType } of compiled.contained) {
     if (pattern.test(argExpression)) {
       return { isTainted: true, sourceType };
     }
@@ -14344,6 +14451,20 @@ function walkBackwardDefs(startDefId, chainsByToDef, defById, options = {}) {
   return { visited, lines, hopCapReached };
 }
 
+// src/analysis/sanitizer-index.ts
+var SANITIZER_SET_CACHE = /* @__PURE__ */ new WeakMap();
+function getSanitizesSet(san) {
+  let s = SANITIZER_SET_CACHE.get(san);
+  if (!s) {
+    s = new Set(san.sanitizes);
+    SANITIZER_SET_CACHE.set(san, s);
+  }
+  return s;
+}
+function sanitizerCoversSink(san, sinkType) {
+  return getSanitizesSet(san).has(sinkType);
+}
+
 // src/analysis/taint-propagation.ts
 function buildSanitizersByLine(sanitizers) {
   const out2 = /* @__PURE__ */ new Map();
@@ -14580,7 +14701,7 @@ function checkSanitized(fromLine, toLine, sinkType, sanitizersByLine, ctx) {
   if (sanitizersAtTarget && sanitizersAtTarget.length > 0) {
     for (const san of sanitizersAtTarget) {
       if (isKnownSinkType) {
-        if (san.sanitizes.includes(sinkType)) {
+        if (sanitizerCoversSink(san, sinkType)) {
           return { sanitized: true, sanitizer: san };
         }
       } else if (san.sanitizes.length > 0) {
@@ -14602,7 +14723,7 @@ function checkSanitized(fromLine, toLine, sinkType, sanitizersByLine, ctx) {
       if (!sansAtLine || sansAtLine.length === 0) continue;
       for (const san of sansAtLine) {
         if (isKnownSinkType) {
-          if (san.sanitizes.includes(sinkType)) {
+          if (sanitizerCoversSink(san, sinkType)) {
             return { sanitized: true, sanitizer: san };
           }
         } else if (san.sanitizes.length > 0) {