circle-ir 3.216.0 → 4.0.0

package/dist/browser/circle-ir.js

@@ -4356,8 +4356,84 @@ function extractTypes(tree, cache, language) {
   if (isJavaScript) {
     return extractJavaScriptTypes(tree, cache);
   }
+  if (effectiveLanguage === "csharp") {
+    return extractCSharpTypes(tree, cache);
+  }
   return extractJavaTypes(tree, cache);
 }
+function extractCSharpTypes(tree, cache) {
+  const types = [];
+  const KINDS = {
+    class_declaration: "class",
+    record_declaration: "class",
+    struct_declaration: "class",
+    interface_declaration: "interface",
+    enum_declaration: "enum"
+  };
+  for (const kindNode of Object.keys(KINDS)) {
+    for (const node of getNodesFromCache(tree.rootNode, kindNode, cache)) {
+      const nameNode = node.childForFieldName("name");
+      const body2 = node.childForFieldName("body");
+      const methods = [];
+      if (body2) {
+        for (let i2 = 0; i2 < body2.childCount; i2++) {
+          const m = body2.child(i2);
+          if (!m || m.type !== "method_declaration") continue;
+          const mName = m.childForFieldName("name");
+          const paramList = m.childForFieldName("parameters");
+          const parameters = [];
+          if (paramList) {
+            for (let j = 0; j < paramList.childCount; j++) {
+              const pnode = paramList.child(j);
+              if (!pnode || pnode.type !== "parameter") continue;
+              const pName = pnode.childForFieldName("name");
+              const pType = pnode.childForFieldName("type");
+              if (pName) {
+                parameters.push({
+                  name: getNodeText(pName),
+                  type: pType ? getNodeText(pType) : null,
+                  annotations: [],
+                  line: pnode.startPosition.row + 1
+                });
+              }
+            }
+          }
+          const returns = m.childForFieldName("returns");
+          methods.push({
+            name: mName ? getNodeText(mName) : "unknown",
+            return_type: returns ? getNodeText(returns) : null,
+            parameters,
+            annotations: [],
+            modifiers: extractCSharpModifiers(m),
+            start_line: m.startPosition.row + 1,
+            end_line: m.endPosition.row + 1
+          });
+        }
+      }
+      types.push({
+        name: nameNode ? getNodeText(nameNode) : "anonymous",
+        kind: KINDS[kindNode],
+        package: null,
+        extends: null,
+        implements: [],
+        annotations: [],
+        methods,
+        fields: [],
+        start_line: node.startPosition.row + 1,
+        end_line: node.endPosition.row + 1
+      });
+    }
+  }
+  return types;
+}
+function extractCSharpModifiers(node) {
+  const mods = [];
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const c = node.child(i2);
+    if (c && c.type === "modifier") mods.push(getNodeText(c));
+  }
+  return mods;
+}
 function extractJavaTypes(tree, cache) {
   const types = [];
   const classes = getNodesFromCache(tree.rootNode, "class_declaration", cache);
@@ -5816,6 +5892,9 @@ function extractCalls(tree, cache, language) {
   if (isJavaScript) {
     return extractJavaScriptCalls(tree, cache);
   }
+  if (detectedLanguage === "csharp") {
+    return extractCSharpCalls(tree, cache);
+  }
   const context = buildResolutionContext(tree, cache);
   const invocations = getNodesFromCache(tree.rootNode, "method_invocation", cache);
   for (const inv of invocations) {
@@ -5830,6 +5909,107 @@ function extractCalls(tree, cache, language) {
   }
   return calls;
 }
+function buildCSharpReceiverTypeMap(tree, cache) {
+  const map = /* @__PURE__ */ new Map();
+  const simple = (t) => t.replace(/<[^>]*>/g, "").split(".").pop()?.trim() ?? t;
+  for (const vd of getNodesFromCache(tree.rootNode, "variable_declaration", cache)) {
+    const typeNode = vd.childForFieldName("type");
+    const declaredType = typeNode ? getNodeText(typeNode) : null;
+    for (let i2 = 0; i2 < vd.childCount; i2++) {
+      const decl = vd.child(i2);
+      if (!decl || decl.type !== "variable_declarator") continue;
+      const nameNode = decl.childForFieldName("name");
+      if (nameNode?.type !== "identifier") continue;
+      let t = declaredType && declaredType !== "var" ? declaredType : null;
+      if (!t) {
+        const oce = findFirstDescendant(decl, "object_creation_expression");
+        const oceType = oce?.childForFieldName("type");
+        if (oceType) t = getNodeText(oceType);
+      }
+      if (t && t !== "var") map.set(getNodeText(nameNode), simple(t));
+    }
+  }
+  return map;
+}
+function findFirstDescendant(node, type) {
+  for (let i2 = 0; i2 < node.childCount; i2++) {
+    const c = node.child(i2);
+    if (!c) continue;
+    if (c.type === type) return c;
+    const found = findFirstDescendant(c, type);
+    if (found) return found;
+  }
+  return null;
+}
+function extractCSharpCalls(tree, cache) {
+  const calls = [];
+  const typeMap = buildCSharpReceiverTypeMap(tree, cache);
+  const invocations = getNodesFromCache(tree.rootNode, "invocation_expression", cache);
+  for (const inv of invocations) {
+    const fn = inv.childForFieldName("function");
+    let methodName = "unknown";
+    let receiver = null;
+    if (fn?.type === "member_access_expression") {
+      const nameNode = fn.childForFieldName("name");
+      const exprNode = fn.childForFieldName("expression");
+      methodName = nameNode ? getNodeText(nameNode) : "unknown";
+      receiver = exprNode ? getNodeText(exprNode) : null;
+    } else if (fn) {
+      methodName = getNodeText(fn);
+    }
+    const argsNode = inv.childForFieldName("arguments");
+    calls.push({
+      method_name: methodName,
+      receiver,
+      receiver_type: receiver ? typeMap.get(receiver) ?? null : null,
+      receiver_type_fqn: null,
+      arguments: argsNode ? extractCSharpArguments(argsNode) : [],
+      location: { line: inv.startPosition.row + 1, column: inv.startPosition.column },
+      in_method: findEnclosingMethod(inv)
+    });
+  }
+  const objectCreations = getNodesFromCache(tree.rootNode, "object_creation_expression", cache);
+  for (const creation of objectCreations) {
+    const typeNode = creation.childForFieldName("type");
+    const argsNode = creation.childForFieldName("arguments");
+    calls.push({
+      method_name: typeNode ? getNodeText(typeNode) : "unknown",
+      receiver: null,
+      receiver_type: null,
+      receiver_type_fqn: null,
+      arguments: argsNode ? extractCSharpArguments(argsNode) : [],
+      location: { line: creation.startPosition.row + 1, column: creation.startPosition.column },
+      in_method: findEnclosingMethod(creation),
+      is_constructor: true
+    });
+  }
+  return calls;
+}
+function extractCSharpArguments(argsNode) {
+  const args2 = [];
+  let position = 0;
+  for (let i2 = 0; i2 < argsNode.childCount; i2++) {
+    const child = argsNode.child(i2);
+    if (!child || child.type !== "argument") continue;
+    let expr = null;
+    for (let j = child.childCount - 1; j >= 0; j--) {
+      const c = child.child(j);
+      if (c && c.isNamed) {
+        expr = c;
+        break;
+      }
+    }
+    const text = expr ? getNodeText(expr) : getNodeText(child);
+    args2.push({
+      position: position++,
+      expression: text,
+      variable: expr?.type === "identifier" ? text : null,
+      literal: expr?.type === "string_literal" ? text : null,
+      value: null
+    });
+  }
+  return args2;
+}
 function extractJavaScriptCalls(tree, cache) {
   const calls = [];
   const context = buildJSResolutionContext(tree, cache);
@@ -8932,8 +9112,72 @@ function buildDFG(tree, cache, language) {
   if (effectiveLanguage === "go") {
     return buildGoDFG(tree);
   }
+  if (effectiveLanguage === "csharp") {
+    return buildCSharpDFG(tree, cache);
+  }
   return buildJavaDFG(tree, cache);
 }
+function buildCSharpDFG(tree, cache) {
+  const defs = [];
+  const uses = [];
+  let defIdCounter = 1;
+  let useIdCounter = 1;
+  const scopeStack = [/* @__PURE__ */ new Map()];
+  const methods = [
+    ...getNodesFromCache(tree.rootNode, "method_declaration", cache),
+    ...getNodesFromCache(tree.rootNode, "constructor_declaration", cache),
+    ...getNodesFromCache(tree.rootNode, "local_function_statement", cache)
+  ];
+  for (const method of methods) {
+    scopeStack.push(/* @__PURE__ */ new Map());
+    const params = method.childForFieldName("parameters");
+    if (params) {
+      for (const def of extractParameterDefs(params, defIdCounter)) {
+        defs.push(def);
+        currentScope(scopeStack).set(def.variable, def.id);
+        defIdCounter++;
+      }
+    }
+    const body2 = method.childForFieldName("body");
+    if (body2) {
+      for (const decl of findNodes(body2, "variable_declarator")) {
+        const nameNode = decl.childForFieldName("name");
+        if (nameNode?.type === "identifier") {
+          const name2 = getNodeText(nameNode);
+          const def = { id: defIdCounter++, variable: name2, line: decl.startPosition.row + 1, kind: "local" };
+          defs.push(def);
+          currentScope(scopeStack).set(name2, def.id);
+        }
+      }
+      for (const asn of findNodes(body2, "assignment_expression")) {
+        const left = asn.childForFieldName("left");
+        if (left?.type === "identifier") {
+          const name2 = getNodeText(left);
+          const def = { id: defIdCounter++, variable: name2, line: asn.startPosition.row + 1, kind: "local" };
+          defs.push(def);
+          currentScope(scopeStack).set(name2, def.id);
+        }
+      }
+      const bodyUses = extractUses(body2, useIdCounter, scopeStack, false);
+      uses.push(...bodyUses.uses);
+      useIdCounter = bodyUses.nextId;
+    }
+    scopeStack.pop();
+  }
+  const classes = getNodesFromCache(tree.rootNode, "class_declaration", cache);
+  for (const cls of classes) {
+    const body2 = cls.childForFieldName("body");
+    if (body2) {
+      for (const def of extractFieldDefs(body2, defIdCounter)) {
+        defs.push(def);
+        currentScope(scopeStack).set(def.variable, def.id);
+        defIdCounter++;
+      }
+    }
+  }
+  const chains = computeChains(defs, uses);
+  return { defs, uses, chains };
+}
 function buildJavaDFG(tree, cache) {
   const defs = [];
   const uses = [];
@@ -9396,7 +9640,7 @@ function extractParameterDefs(params, startId) {
   for (let i2 = 0; i2 < params.childCount; i2++) {
     const param = params.child(i2);
     if (!param) continue;
-    if (param.type === "formal_parameter" || param.type === "spread_parameter") {
+    if (param.type === "formal_parameter" || param.type === "spread_parameter" || param.type === "parameter") {
       const nameNode = param.childForFieldName("name");
       if (nameNode) {
         defs.push({
@@ -13486,6 +13730,67 @@ var DEFAULT_SINKS = [
   { method: "put", class: "httpx", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0] },
   { method: "patch", class: "httpx", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0] },
   { method: "head", class: "httpx", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0] },
+  // C# SQLi (Phase-0 spike — ADO.NET). `new SqlCommand(sql, conn)` builds the
+  // command from a raw string; the tainted SQL is arg[0] of the constructor.
+  { method: "SqlCommand", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "NpgsqlCommand", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "MySqlCommand", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "SqliteCommand", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "OracleCommand", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "ExecuteSqlRaw", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "ExecuteSqlRawAsync", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "FromSqlRaw", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "FromSqlRawAsync", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  // C# command injection — Process.Start / ProcessStartInfo (CWE-78).
+  { method: "Start", class: "Process", type: "command_injection", cwe: "CWE-78", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "ProcessStartInfo", type: "command_injection", cwe: "CWE-78", severity: "critical", arg_positions: [0, 1], languages: ["csharp"] },
+  // C# path traversal — System.IO file APIs (CWE-22). Distinctive method names.
+  { method: "ReadAllText", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "ReadAllBytes", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "ReadAllLines", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "WriteAllText", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "WriteAllBytes", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "AppendAllText", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "OpenRead", class: "File", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "OpenWrite", class: "File", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "FileStream", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "StreamReader", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "StreamWriter", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  // C# SSRF — HttpClient / WebClient / WebRequest (CWE-918).
+  { method: "GetAsync", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "PostAsync", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "PutAsync", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "DeleteAsync", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "GetStringAsync", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "GetByteArrayAsync", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "GetStreamAsync", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "SendAsync", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "DownloadString", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "DownloadData", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "DownloadFile", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [1], languages: ["csharp"] },
+  { method: "Create", class: "WebRequest", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  // C# code injection — dynamic script/assembly loading (CWE-94).
+  { method: "EvaluateAsync", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "RunAsync", class: "CSharpScript", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  // C# insecure deserialization — BinaryFormatter et al. (CWE-502).
+  { method: "Deserialize", class: "BinaryFormatter", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "Deserialize", class: "NetDataContractSerializer", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  // C# XSS — raw HTML output (CWE-79).
+  { method: "Raw", class: "Html", type: "xss", cwe: "CWE-79", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "Write", class: "Response", type: "xss", cwe: "CWE-79", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "HtmlString", type: "xss", cwe: "CWE-79", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  // C# LDAP injection — System.DirectoryServices (CWE-90). The user-built
+  // filter is the constructor argument.
+  { method: "DirectorySearcher", type: "ldap_injection", cwe: "CWE-90", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "DirectoryEntry", type: "ldap_injection", cwe: "CWE-90", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  // C# XPath injection — System.Xml.XPath (CWE-643). Distinctive selector methods.
+  { method: "SelectSingleNode", type: "xpath_injection", cwe: "CWE-643", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "SelectNodes", type: "xpath_injection", cwe: "CWE-643", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "Compile", class: "XPathExpression", type: "xpath_injection", cwe: "CWE-643", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  // C# XXE — untrusted XML into a parser without DTD hardening (CWE-611).
+  { method: "LoadXml", type: "xxe", cwe: "CWE-611", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "Load", class: "XmlDocument", type: "xxe", cwe: "CWE-611", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "Load", class: "XDocument", type: "xxe", cwe: "CWE-611", severity: "high", arg_positions: [0], languages: ["csharp"] },
   // Python SQLi — asyncpg Connection.*
   { method: "execute", class: "Connection", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0] },
   { method: "fetch", class: "Connection", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0] },
@@ -13693,6 +13998,15 @@ var DEFAULT_SANITIZERS = [
   { method: "escapeCsv", removes: ["xss"] },
   // OWASP HTML sanitizer (`com.googlecode.owasp-java-html-sanitizer`).
   { method: "sanitize", class: "PolicyFactory", removes: ["xss"] },
+  // C# sanitizers (Phase-1). HTML encoders neutralise XSS; Path.GetFileName
+  // strips any directory component (basename) so a traversal payload cannot
+  // escape the target directory. Method names are C#-distinctive.
+  { method: "HtmlEncode", removes: ["xss"] },
+  // HttpUtility / WebUtility
+  { method: "JavaScriptStringEncode", removes: ["xss"] },
+  // HttpUtility
+  { method: "Encode", class: "HtmlEncoder", removes: ["xss"] },
+  { method: "GetFileName", class: "Path", removes: ["path_traversal"] },
   // Java Base64 / Hex / MessageDigest — encoded output is binary-safe
   // (cognium-dev #213 seventh slice). None of these carry attacker
   // shell/SQL/HTML metacharacters through the encoding — Base64 emits
@@ -14531,7 +14845,7 @@ function findSources(calls, types, patterns, sourceLines, language) {
       const skipMethods = ["toString", "hashCode", "equals", "compareTo"];
       if (skipMethods.includes(method.name)) continue;
       for (const param of method.parameters) {
-        const isTaintable = param.type ? isInterproceduralTaintableType(param.type) : true;
+        const isTaintable = param.type ? isInterproceduralTaintableType(param.type, language) : true;
         if (isTaintable) {
           const paramLine = param.line ?? method.start_line;
           sources.push({
@@ -14554,7 +14868,7 @@ function findSources(calls, types, patterns, sourceLines, language) {
             // interprocedural_param at the method decl line instead of the
             // real HTTP source, breaking downstream sink-type filters
             // (regressed #78, #92.1, #105 FP-31, #215 recall).
-            ...language === "java" ? { variable: param.name } : {}
+            ...language === "java" || language === "csharp" ? { variable: param.name } : {}
           });
         }
       }
@@ -14651,7 +14965,7 @@ function findSources(calls, types, patterns, sourceLines, language) {
   }
   return result;
 }
-function isInterproceduralTaintableType(typeName) {
+function isInterproceduralTaintableType(typeName, language) {
   const baseType = typeName.split("<")[0].trim();
   const excludedTypes = [
     // Servlet framework - taint comes from specific methods, not the parameter itself
@@ -14724,6 +15038,26 @@ function isInterproceduralTaintableType(typeName) {
   if (taintableTypes.includes(baseType)) {
     return true;
   }
+  if (language === "csharp") {
+    const csharpTaintable = [
+      "string",
+      "object",
+      "IEnumerable",
+      "ICollection",
+      "IList",
+      "Dictionary",
+      "IDictionary",
+      "IReadOnlyList",
+      "IReadOnlyCollection",
+      // Byte/stream payloads carry deserialization / upload input.
+      "Stream",
+      "byte[]",
+      "Byte[]",
+      "MemoryStream"
+    ];
+    const leaf = baseType.split(".").pop() ?? baseType;
+    if (csharpTaintable.includes(baseType) || csharpTaintable.includes(leaf)) return true;
+  }
   if (typeName.endsWith("[]")) {
     const elementType = typeName.slice(0, -2);
     if (elementType === "String" || elementType === "Object" || elementType === "byte") {
@@ -25014,6 +25348,73 @@ var GoPlugin = class extends BaseLanguagePlugin {
   }
 };
 
+// src/languages/plugins/csharp.ts
+var CSharpPlugin = class extends BaseLanguagePlugin {
+  id = "csharp";
+  name = "C#";
+  extensions = [".cs"];
+  wasmPath = "tree-sitter-csharp.wasm";
+  nodeTypes = {
+    // Type declarations
+    classDeclaration: ["class_declaration", "record_declaration", "struct_declaration"],
+    interfaceDeclaration: ["interface_declaration"],
+    enumDeclaration: ["enum_declaration"],
+    functionDeclaration: [],
+    methodDeclaration: ["method_declaration", "constructor_declaration", "local_function_statement"],
+    // Expressions — NB these diverge from Java (invocation_expression vs
+    // method_invocation, local_declaration_statement vs local_variable_declaration).
+    methodCall: ["invocation_expression"],
+    functionCall: [],
+    assignment: ["assignment_expression"],
+    variableDeclaration: ["local_declaration_statement", "field_declaration", "variable_declaration"],
+    // Parameters and arguments
+    parameter: ["parameter"],
+    argument: ["argument_list"],
+    // Attributes (C# analogue of annotations/decorators)
+    annotation: ["attribute", "attribute_list"],
+    decorator: [],
+    // Imports
+    importStatement: ["using_directive"],
+    // Control flow
+    ifStatement: ["if_statement"],
+    forStatement: ["for_statement", "for_each_statement"],
+    whileStatement: ["while_statement"],
+    tryStatement: ["try_statement"],
+    returnStatement: ["return_statement"]
+  };
+  detectFramework(context) {
+    for (const imp of context.imports) {
+      const path = imp.from_package || imp.imported_name;
+      if (path.startsWith("Microsoft.AspNetCore") || path.startsWith("Microsoft.Extensions")) {
+        return { name: "aspnetcore", confidence: 0.9, indicators: [`using: ${path}`] };
+      }
+      if (path.startsWith("Microsoft.EntityFrameworkCore")) {
+        return { name: "efcore", confidence: 0.9, indicators: [`using: ${path}`] };
+      }
+    }
+    return void 0;
+  }
+  // --- LanguagePlugin contract (unused by the main analyze() path; Phase-1) ---
+  extractTypes(_context) {
+    return [];
+  }
+  extractCalls(_context) {
+    return [];
+  }
+  extractImports(_context) {
+    return [];
+  }
+  extractPackage(_context) {
+    return void 0;
+  }
+  getBuiltinSources() {
+    return [];
+  }
+  getBuiltinSinks() {
+    return [];
+  }
+};
+
 // src/languages/plugins/index.ts
 function registerBuiltinPlugins() {
   registerLanguage(new JavaPlugin());
@@ -25024,6 +25425,7 @@ function registerBuiltinPlugins() {
   registerLanguage(new HtmlPlugin());
   registerLanguage(new VuePlugin());
   registerLanguage(new GoPlugin());
+  registerLanguage(new CSharpPlugin());
 }
 
 // src/analysis/html/html-extractor.ts
@@ -25892,6 +26294,7 @@ var LanguageSourcesPass = class {
     additionalSources.push(...findStaticFieldSources(types, code, language));
     additionalSources.push(...findSetterChainSources(types, code, language));
     additionalSources.push(...findJavaScriptAssignmentSources(code, language));
+    additionalSources.push(...findCSharpRequestSources(code, language));
     const jsDOMSinks = findJavaScriptDOMSinks(code, language);
     for (const s of jsDOMSinks) {
       const alreadyExists = additionalSinks.some((x) => x.line === s.line && x.cwe === s.cwe);
@@ -26546,6 +26949,30 @@ function findSetterChainSources(types, sourceCode, language) {
   }
   return sources;
 }
+function findCSharpRequestSources(sourceCode, language) {
+  if (language !== "csharp") return [];
+  const sources = [];
+  const lines = sourceCode.split("\n");
+  const assignRe = /^\s*(?:var\s+|[A-Za-z_][\w.<>\[\]]*\s+)?([A-Za-z_]\w*)\s*=\s*(.+?);?\s*$/;
+  const requestReadRe = /\bRequest\s*\.\s*(?:Query|Form|Headers|Cookies|QueryString|RouteValues|Body|Files|Params)\b/;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const m = assignRe.exec(lines[i2]);
+    if (!m) continue;
+    const [, varName, rhs] = m;
+    if (!requestReadRe.test(rhs)) continue;
+    const lineNumber = i2 + 1;
+    if (sources.some((s) => s.line === lineNumber && s.variable === varName)) continue;
+    sources.push({
+      type: "http_param",
+      location: `${varName} = ${rhs.trim().substring(0, 50)}${rhs.length > 50 ? "..." : ""}`,
+      severity: "high",
+      line: lineNumber,
+      confidence: 1,
+      variable: varName
+    });
+  }
+  return sources;
+}
 function findJavaScriptAssignmentSources(sourceCode, language) {
   if (!["javascript", "typescript"].includes(language)) return [];
   const sources = [];
@@ -32531,6 +32958,13 @@ var REPLACE_ALL_TO_PLACEHOLDER_RE = /\.replaceAll\s*\([\s\S]*?,\s*"[\s,?]*\?[\s,
 var HTML_CONTENT_TYPE_RE = /text\/html|TEXT_HTML/;
 var FETCH_GLOBAL_RECEIVER_RE = /(?:^|[^.\w])(?:window|globalThis|self|global)\s*\.\s*fetch\s*\(/;
 var FETCH_MEMBER_RECEIVER_RE = /[\w$)\]]\s*\.\s*fetch\s*\(/;
+var NOSQL_ARRAY_METHODS = /* @__PURE__ */ new Set(["find", "filter", "some", "every", "findIndex", "findLast"]);
+var FUNCTION_FIRST_ARG_RE = /\.\s*(?:find|filter|some|every|findIndex|findLast)\s*\(\s*(?:async\s+)?(?:function\b|(?:\([^()]*\)|[A-Za-z_$][\w$]*)\s*=>)/;
+var ORM_BUILDER_KEY_RE = /[{,]\s*(?:where|select|populate|include|orderBy|relations|attributes)\s*:/;
+var BROWSER_COMPONENT_EXT_RE = /\.(?:jsx|tsx|vue|svelte)$/;
+var CLIENT_SIGNAL_RE = /["']use client["']|\buse(?:State|Effect|Ref|Callback|Memo|Context|Reducer|LayoutEffect)\s*\(|\b(?:window|document|localStorage|sessionStorage|navigator)\s*\.|\son(?:Click|Change|Submit|Input|KeyDown|KeyUp|MouseOver|Focus|Blur)\s*=/;
+var SERVER_SIGNAL_RE = /["']use server["']|\b(?:getServerSideProps|getStaticProps|getStaticPaths)\b|from\s+["']next\/server["']|\bNext(?:Api)?(?:Request|Response)\b|from\s+["'](?:node:)?(?:fs|child_process|http|https|net|dns|dgram)["']|\bexport\s+(?:default\s+)?(?:async\s+)?function\s+handler\s*\(/;
+var FIXED_HOST_TEMPLATE_RE = /`https?:\/\/[^/${}\s`]+[/`]/;
 function javaTraversalRejectGuardedLines(code) {
   const covered = /* @__PURE__ */ new Set();
   const lines = code.split("\n");
@@ -32622,6 +33056,49 @@ function jsSsrfHostGuardedLines(code) {
   }
   return covered;
 }
+var CSHARP_SANITIZER_RES = [
+  { re: /\b(?:HtmlEncode|JavaScriptStringEncode)\s*\(/, type: "xss" },
+  { re: /\bHtmlEncoder\s*\.\s*Encode\s*\(/, type: "xss" },
+  { re: /\bPath\s*\.\s*GetFileName\s*\(/, type: "path_traversal" }
+];
+function csharpSanitizedVarsByType(code) {
+  const lines = code.split("\n");
+  const byType = /* @__PURE__ */ new Map();
+  const assignRe = /^\s*(?:var\s+|[A-Za-z_][\w.<>\[\]]*\s+)?([A-Za-z_]\w*)\s*=\s*(.+?);?\s*$/;
+  for (const { type } of CSHARP_SANITIZER_RES) {
+    if (!byType.has(type)) byType.set(type, /* @__PURE__ */ new Set());
+  }
+  for (const line of lines) {
+    const m = assignRe.exec(line);
+    if (!m) continue;
+    const [, lhs, rhs] = m;
+    for (const { re, type } of CSHARP_SANITIZER_RES) {
+      if (re.test(rhs)) byType.get(type).add(lhs);
+    }
+  }
+  let changed = true;
+  let guard = 0;
+  while (changed && guard < lines.length + 2) {
+    changed = false;
+    guard++;
+    for (const line of lines) {
+      const m = assignRe.exec(line);
+      if (!m) continue;
+      const [, lhs, rhs] = m;
+      for (const [type, set] of byType) {
+        if (set.has(lhs)) continue;
+        const refsSanitized = [...set].some(
+          (v) => new RegExp(`(?<![\\w])${escapeRegex(v)}(?![\\w])`).test(rhs)
+        );
+        if (refsSanitized) {
+          set.add(lhs);
+          changed = true;
+        }
+      }
+    }
+  }
+  return byType;
+}
 var JAVA_INLINE_MATCHES_RE = /\.\s*matches\s*\(\s*"((?:[^"\\]|\\.)*)"\s*\)/g;
 function resolveJavaReceiverType(receiver, sinkLine, sourceLines) {
   if (!receiver || !/^[A-Za-z_]\w*$/.test(receiver)) return null;
@@ -33325,6 +33802,37 @@ var SinkFilterPass = class {
         return !FETCH_MEMBER_RECEIVER_RE.test(sinkLineText);
       });
     }
+    if (["javascript", "typescript"].includes(language)) {
+      const sourceLines = ctx.code.split("\n");
+      filtered = filtered.filter((sink) => {
+        if (sink.type !== "nosql_injection") return true;
+        if (!NOSQL_ARRAY_METHODS.has(sink.method ?? "")) return true;
+        const sinkLineText = sourceLines[sink.line - 1] ?? "";
+        return !FUNCTION_FIRST_ARG_RE.test(sinkLineText);
+      });
+    }
+    if (["javascript", "typescript"].includes(language)) {
+      const sourceLines = ctx.code.split("\n");
+      filtered = filtered.filter((sink) => {
+        if (sink.type !== "sql_injection" && sink.type !== "nosql_injection") return true;
+        const sinkLineText = sourceLines[sink.line - 1] ?? "";
+        return !ORM_BUILDER_KEY_RE.test(sinkLineText);
+      });
+    }
+    if (["javascript", "typescript", "tsx"].includes(language)) {
+      const file = ctx.graph?.ir?.meta?.file ?? "";
+      if (BROWSER_COMPONENT_EXT_RE.test(file) && CLIENT_SIGNAL_RE.test(ctx.code) && !SERVER_SIGNAL_RE.test(ctx.code)) {
+        filtered = filtered.filter((sink) => sink.type !== "ssrf");
+      }
+    }
+    if (["javascript", "typescript"].includes(language)) {
+      const sourceLines = ctx.code.split("\n");
+      filtered = filtered.filter((sink) => {
+        if (sink.type !== "ssrf") return true;
+        const sinkLineText = sourceLines[sink.line - 1] ?? "";
+        return !FIXED_HOST_TEMPLATE_RE.test(sinkLineText);
+      });
+    }
     if (["javascript", "typescript"].includes(language)) {
       const guardedLines = jsSsrfHostGuardedLines(ctx.code);
       if (guardedLines.size > 0) {
@@ -33333,6 +33841,23 @@ var SinkFilterPass = class {
         );
       }
     }
+    if (language === "csharp") {
+      const sourceLines = ctx.code.split("\n");
+      const sanitizedByType = csharpSanitizedVarsByType(ctx.code);
+      filtered = filtered.filter((sink) => {
+        const sinkLineText = sourceLines[sink.line - 1] ?? "";
+        for (const { re, type } of CSHARP_SANITIZER_RES) {
+          if (type === sink.type && re.test(sinkLineText)) return false;
+        }
+        const sanitizedVars = sanitizedByType.get(sink.type);
+        if (sanitizedVars && sanitizedVars.size > 0) {
+          for (const v of sanitizedVars) {
+            if (new RegExp(`(?<![\\w])${escapeRegex(v)}(?![\\w])`).test(sinkLineText)) return false;
+          }
+        }
+        return true;
+      });
+    }
     if (["javascript", "typescript"].includes(language)) {
       const sourceLines = ctx.code.split("\n");
       filtered = filtered.filter((sink) => {
@@ -35781,7 +36306,7 @@ function detectExpressionScanFlows(calls, sources, sinks, sanitizers, unreachabl
       }
     }
   }
-  if (language === "java" && typeof code === "string" && sourcesWithVar.length > 0) {
+  if ((language === "java" || language === "csharp") && typeof code === "string" && sourcesWithVar.length > 0) {
     const seedVars = new Set(sourcesWithVar.map((s) => s.variable));
     const derived = buildJavaTaintedVars(code, seedVars);
     if (derived.size > 0) {