circle-ir 4.7.2 → 4.9.7

package/dist/browser/circle-ir.js

@@ -4375,6 +4375,7 @@ function extractCSharpTypes(tree, cache) {
       const nameNode = node.childForFieldName("name");
       const body2 = node.childForFieldName("body");
       const methods = [];
+      const fields = extractCSharpFields(body2);
       if (body2) {
         for (let i2 = 0; i2 < body2.childCount; i2++) {
           const m = body2.child(i2);
@@ -4392,7 +4393,7 @@ function extractCSharpTypes(tree, cache) {
                 parameters.push({
                   name: getNodeText(pName),
                   type: pType ? getNodeText(pType) : null,
-                  annotations: [],
+                  annotations: extractCSharpParamAnnotations(pnode),
                   line: pnode.startPosition.row + 1
                 });
               }
@@ -4418,7 +4419,7 @@ function extractCSharpTypes(tree, cache) {
         implements: [],
         annotations: [],
         methods,
-        fields: [],
+        fields,
         start_line: node.startPosition.row + 1,
         end_line: node.endPosition.row + 1
       });
@@ -4426,6 +4427,59 @@ function extractCSharpTypes(tree, cache) {
   }
   return types;
 }
+function extractCSharpFields(body2) {
+  const fields = [];
+  if (!body2) return fields;
+  for (let i2 = 0; i2 < body2.childCount; i2++) {
+    const c = body2.child(i2);
+    if (!c) continue;
+    if (c.type === "field_declaration") {
+      let varDecl = null;
+      for (let k = 0; k < c.childCount; k++) {
+        const cc = c.child(k);
+        if (cc?.type === "variable_declaration") {
+          varDecl = cc;
+          break;
+        }
+      }
+      if (!varDecl) continue;
+      const typeNode = varDecl.childForFieldName("type");
+      const type = typeNode ? getNodeText(typeNode) : null;
+      const modifiers = extractCSharpModifiers(c);
+      for (let k = 0; k < varDecl.childCount; k++) {
+        const decl = varDecl.child(k);
+        if (decl?.type !== "variable_declarator") continue;
+        const nameNode = decl.childForFieldName("name");
+        fields.push({ name: nameNode ? getNodeText(nameNode) : "unknown", type, modifiers, annotations: [] });
+      }
+    } else if (c.type === "property_declaration") {
+      const nameNode = c.childForFieldName("name");
+      if (!nameNode) continue;
+      const typeNode = c.childForFieldName("type");
+      fields.push({
+        name: getNodeText(nameNode),
+        type: typeNode ? getNodeText(typeNode) : null,
+        modifiers: extractCSharpModifiers(c),
+        annotations: []
+      });
+    }
+  }
+  return fields;
+}
+function extractCSharpParamAnnotations(param) {
+  const out2 = [];
+  for (let i2 = 0; i2 < param.childCount; i2++) {
+    const list = param.child(i2);
+    if (list?.type !== "attribute_list") continue;
+    for (let j = 0; j < list.childCount; j++) {
+      const attr = list.child(j);
+      if (attr?.type !== "attribute") continue;
+      const name2 = attr.childForFieldName("name");
+      if (name2) out2.push(getNodeText(name2));
+    }
+  }
+  return out2;
+}
 function extractCSharpModifiers(node) {
   const mods = [];
   for (let i2 = 0; i2 < node.childCount; i2++) {
@@ -6000,13 +6054,21 @@ function extractCSharpCalls(tree, cache) {
     const left = asn.childForFieldName("left");
     if (left?.type !== "member_access_expression") continue;
     const nameNode = left.childForFieldName("name");
-    if (!nameNode || getNodeText(nameNode) !== "CommandText") continue;
+    if (!nameNode) continue;
+    const propName = getNodeText(nameNode);
+    const exprNode = left.childForFieldName("expression");
+    if (propName === "Filter") {
+      const recv = exprNode ? getNodeText(exprNode) : null;
+      const recvType = recv ? typeMap.get(recv) : void 0;
+      if (recvType !== "DirectorySearcher") continue;
+    } else if (propName !== "CommandText") {
+      continue;
+    }
     const right = asn.childForFieldName("right");
     if (!right) continue;
     const rhsText = getNodeText(right);
-    const exprNode = left.childForFieldName("expression");
     calls.push({
-      method_name: "CommandText",
+      method_name: propName,
       receiver: exprNode ? getNodeText(exprNode) : null,
       receiver_type: null,
       receiver_type_fqn: null,
@@ -8572,6 +8634,9 @@ function buildCFG(tree, language, cache) {
   if (effectiveLanguage === "go") {
     return buildGoCFG(tree, blockIdCounter, cache);
   }
+  if (effectiveLanguage === "csharp") {
+    return buildCSharpCFG(tree, blockIdCounter, cache);
+  }
   if (isJavaScript) {
     const functions = [
       ...getNodesFromCache(tree.rootNode, "function_declaration", cache),
@@ -8584,7 +8649,7 @@ function buildCFG(tree, language, cache) {
       const body2 = func2.childForFieldName("body");
       if (!body2) continue;
       if (body2.type === "statement_block") {
-        const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, true);
+        const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, "js");
         allBlocks.push(...blocks);
         allEdges.push(...edges);
         blockIdCounter = nextId;
@@ -8606,7 +8671,7 @@ function buildCFG(tree, language, cache) {
     for (const method of methods) {
       const body2 = method.childForFieldName("body");
       if (!body2) continue;
-      const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, false);
+      const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, "java");
       allBlocks.push(...blocks);
       allEdges.push(...edges);
       blockIdCounter = nextId;
@@ -8614,7 +8679,28 @@ function buildCFG(tree, language, cache) {
   }
   return { blocks: allBlocks, edges: allEdges };
 }
-function buildMethodCFG(body2, startId, isJavaScript) {
+function buildCSharpCFG(tree, blockIdCounter, cache) {
+  const allBlocks = [];
+  const allEdges = [];
+  const containers = [
+    ...getNodesFromCache(tree.rootNode, "method_declaration", cache),
+    ...getNodesFromCache(tree.rootNode, "constructor_declaration", cache),
+    ...getNodesFromCache(tree.rootNode, "destructor_declaration", cache),
+    ...getNodesFromCache(tree.rootNode, "operator_declaration", cache),
+    ...getNodesFromCache(tree.rootNode, "local_function_statement", cache),
+    ...getNodesFromCache(tree.rootNode, "accessor_declaration", cache)
+  ];
+  for (const container of containers) {
+    const body2 = container.childForFieldName("body");
+    if (!body2 || body2.type !== "block") continue;
+    const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, "csharp");
+    allBlocks.push(...blocks);
+    allEdges.push(...edges);
+    blockIdCounter = nextId;
+  }
+  return { blocks: allBlocks, edges: allEdges };
+}
+function buildMethodCFG(body2, startId, dialect) {
   const blocks = [];
   const edges = [];
   let currentId = startId;
@@ -8625,7 +8711,7 @@ function buildMethodCFG(body2, startId, isJavaScript) {
     end_line: body2.startPosition.row + 1
   };
   blocks.push(entryBlock);
-  const result = processStatements(body2, currentId, blocks, edges, isJavaScript);
+  const result = processStatements(body2, currentId, blocks, edges, dialect);
   currentId = result.nextId;
   if (result.entryId !== -1) {
     edges.push({
@@ -8657,15 +8743,15 @@ function buildMethodCFG(body2, startId, isJavaScript) {
   }
   return { blocks, edges, nextId: currentId };
 }
-function processStatements(container, startId, blocks, edges, isJavaScript) {
+function processStatements(container, startId, blocks, edges, dialect) {
   let currentId = startId;
   let firstBlockId = -1;
   let lastExitIds = [];
   for (let i2 = 0; i2 < container.childCount; i2++) {
     const stmt = container.child(i2);
     if (!stmt) continue;
-    if (!isStatement(stmt, isJavaScript)) continue;
-    const result = processStatement(stmt, currentId, blocks, edges, isJavaScript);
+    if (!isStatement(stmt, dialect)) continue;
+    const result = processStatement(stmt, currentId, blocks, edges, dialect);
     currentId = result.nextId;
     if (firstBlockId === -1) {
       firstBlockId = result.entryId;
@@ -8686,31 +8772,49 @@ function processStatements(container, startId, blocks, edges, isJavaScript) {
     nextId: currentId
   };
 }
-function processStatement(stmt, startId, blocks, edges, isJavaScript) {
+function processStatement(stmt, startId, blocks, edges, dialect) {
   switch (stmt.type) {
     case "if_statement":
-      return processIfStatement(stmt, startId, blocks, edges, isJavaScript);
+      return processIfStatement(stmt, startId, blocks, edges, dialect);
     case "for_statement":
     case "enhanced_for_statement":
     case "for_in_statement":
     case "for_of_statement":
-      return processForStatement(stmt, startId, blocks, edges, isJavaScript);
+    case "foreach_statement":
+      return processForStatement(stmt, startId, blocks, edges, dialect);
     case "while_statement":
-      return processWhileStatement(stmt, startId, blocks, edges, isJavaScript);
+      return processWhileStatement(stmt, startId, blocks, edges, dialect);
     case "do_statement":
-      return processDoWhileStatement(stmt, startId, blocks, edges, isJavaScript);
+      return processDoWhileStatement(stmt, startId, blocks, edges, dialect);
     case "try_statement":
-      return processTryStatement(stmt, startId, blocks, edges, isJavaScript);
+      return processTryStatement(stmt, startId, blocks, edges, dialect);
     case "switch_expression":
     case "switch_statement":
-      return processSwitchStatement(stmt, startId, blocks, edges, isJavaScript);
+      return processSwitchStatement(stmt, startId, blocks, edges, dialect);
+    // C# scoped blocks add no branching — flow through the inner block so its
+    // nested statements are still captured.
+    case "using_statement":
+    case "lock_statement":
+    case "checked_statement":
+    case "unsafe_statement": {
+      const inner = stmt.childForFieldName("body") ?? lastBlockChild(stmt);
+      if (inner) return processStatement(inner, startId, blocks, edges, dialect);
+      return processSimpleStatement(stmt, startId, blocks);
+    }
     case "block":
     case "statement_block":
-      return processStatements(stmt, startId, blocks, edges, isJavaScript);
+      return processStatements(stmt, startId, blocks, edges, dialect);
     default:
       return processSimpleStatement(stmt, startId, blocks);
   }
 }
+function lastBlockChild(node) {
+  for (let i2 = node.childCount - 1; i2 >= 0; i2--) {
+    const c = node.child(i2);
+    if (c && c.type === "block") return c;
+  }
+  return null;
+}
 function processSimpleStatement(stmt, startId, blocks) {
   const block = {
     id: startId,
@@ -8725,7 +8829,7 @@ function processSimpleStatement(stmt, startId, blocks) {
     nextId: startId + 1
   };
 }
-function processIfStatement(stmt, startId, blocks, edges, isJavaScript) {
+function processIfStatement(stmt, startId, blocks, edges, dialect) {
   let currentId = startId;
   const condBlock = {
     id: currentId++,
@@ -8737,7 +8841,7 @@ function processIfStatement(stmt, startId, blocks, edges, isJavaScript) {
   const exitIds = [];
   const consequence = stmt.childForFieldName("consequence");
   if (consequence) {
-    const thenResult = processStatement(consequence, currentId, blocks, edges, isJavaScript);
+    const thenResult = processStatement(consequence, currentId, blocks, edges, dialect);
     currentId = thenResult.nextId;
     edges.push({
       from: condBlock.id,
@@ -8748,7 +8852,7 @@ function processIfStatement(stmt, startId, blocks, edges, isJavaScript) {
   }
   const alternative = stmt.childForFieldName("alternative");
   if (alternative) {
-    const elseResult = processStatement(alternative, currentId, blocks, edges, isJavaScript);
+    const elseResult = processStatement(alternative, currentId, blocks, edges, dialect);
     currentId = elseResult.nextId;
     edges.push({
       from: condBlock.id,
@@ -8765,7 +8869,7 @@ function processIfStatement(stmt, startId, blocks, edges, isJavaScript) {
     nextId: currentId
   };
 }
-function processForStatement(stmt, startId, blocks, edges, isJavaScript) {
+function processForStatement(stmt, startId, blocks, edges, dialect) {
   let currentId = startId;
   const loopBlock = {
     id: currentId++,
@@ -8776,7 +8880,7 @@ function processForStatement(stmt, startId, blocks, edges, isJavaScript) {
   blocks.push(loopBlock);
   const body2 = stmt.childForFieldName("body");
   if (body2) {
-    const bodyResult = processStatement(body2, currentId, blocks, edges, isJavaScript);
+    const bodyResult = processStatement(body2, currentId, blocks, edges, dialect);
     currentId = bodyResult.nextId;
     edges.push({
       from: loopBlock.id,
@@ -8798,16 +8902,16 @@ function processForStatement(stmt, startId, blocks, edges, isJavaScript) {
     nextId: currentId
   };
 }
-function processWhileStatement(stmt, startId, blocks, edges, isJavaScript) {
-  return processForStatement(stmt, startId, blocks, edges, isJavaScript);
+function processWhileStatement(stmt, startId, blocks, edges, dialect) {
+  return processForStatement(stmt, startId, blocks, edges, dialect);
 }
-function processDoWhileStatement(stmt, startId, blocks, edges, isJavaScript) {
+function processDoWhileStatement(stmt, startId, blocks, edges, dialect) {
   let currentId = startId;
   const body2 = stmt.childForFieldName("body");
   let bodyEntryId = currentId;
   let bodyExitIds = [];
   if (body2) {
-    const bodyResult = processStatement(body2, currentId, blocks, edges, isJavaScript);
+    const bodyResult = processStatement(body2, currentId, blocks, edges, dialect);
     currentId = bodyResult.nextId;
     bodyEntryId = bodyResult.entryId;
     bodyExitIds = bodyResult.exitIds;
@@ -8837,13 +8941,13 @@ function processDoWhileStatement(stmt, startId, blocks, edges, isJavaScript) {
     nextId: currentId
   };
 }
-function processTryStatement(stmt, startId, blocks, edges, isJavaScript) {
+function processTryStatement(stmt, startId, blocks, edges, dialect) {
   let currentId = startId;
   const exitIds = [];
   const body2 = stmt.childForFieldName("body");
   let tryEntryId = -1;
   if (body2) {
-    const bodyResult = processStatements(body2, currentId, blocks, edges, isJavaScript);
+    const bodyResult = processStatements(body2, currentId, blocks, edges, dialect);
     currentId = bodyResult.nextId;
     tryEntryId = bodyResult.entryId;
     exitIds.push(...bodyResult.exitIds);
@@ -8853,7 +8957,7 @@ function processTryStatement(stmt, startId, blocks, edges, isJavaScript) {
     if (child?.type === "catch_clause") {
       const catchBody = child.childForFieldName("body");
       if (catchBody) {
-        const catchResult = processStatements(catchBody, currentId, blocks, edges, isJavaScript);
+        const catchResult = processStatements(catchBody, currentId, blocks, edges, dialect);
         currentId = catchResult.nextId;
         if (tryEntryId !== -1) {
           edges.push({
@@ -8866,9 +8970,18 @@ function processTryStatement(stmt, startId, blocks, edges, isJavaScript) {
       }
     }
   }
-  const finallyClause = stmt.childForFieldName("finally") ?? stmt.childForFieldName("finalizer");
+  let finallyClause = stmt.childForFieldName("finally") ?? stmt.childForFieldName("finalizer");
+  if (!finallyClause && dialect === "csharp") {
+    for (let i2 = 0; i2 < stmt.childCount; i2++) {
+      const child = stmt.child(i2);
+      if (child?.type === "finally_clause") {
+        finallyClause = lastBlockChild(child);
+        break;
+      }
+    }
+  }
   if (finallyClause) {
-    const finallyResult = processStatements(finallyClause, currentId, blocks, edges, isJavaScript);
+    const finallyResult = processStatements(finallyClause, currentId, blocks, edges, dialect);
     currentId = finallyResult.nextId;
     for (const exitId of exitIds) {
       edges.push({
@@ -8889,7 +9002,7 @@ function processTryStatement(stmt, startId, blocks, edges, isJavaScript) {
     nextId: currentId
   };
 }
-function processSwitchStatement(stmt, startId, blocks, edges, isJavaScript) {
+function processSwitchStatement(stmt, startId, blocks, edges, dialect) {
   let currentId = startId;
   const switchBlock = {
     id: currentId++,
@@ -8901,11 +9014,11 @@ function processSwitchStatement(stmt, startId, blocks, edges, isJavaScript) {
   const exitIds = [];
   const body2 = stmt.childForFieldName("body");
   if (body2) {
-    const caseTypes = isJavaScript ? ["switch_case", "switch_default"] : ["switch_block_statement_group", "switch_rule"];
+    const caseTypes = dialect === "js" ? ["switch_case", "switch_default"] : dialect === "csharp" ? ["switch_section"] : ["switch_block_statement_group", "switch_rule"];
     for (let i2 = 0; i2 < body2.childCount; i2++) {
       const child = body2.child(i2);
       if (child && caseTypes.includes(child.type)) {
-        const caseResult = processStatements(child, currentId, blocks, edges, isJavaScript);
+        const caseResult = processStatements(child, currentId, blocks, edges, dialect);
         currentId = caseResult.nextId;
         if (caseResult.entryId !== -1) {
           edges.push({
@@ -8935,7 +9048,7 @@ function buildBashCFG(tree, startId, cache) {
   for (const func2 of functions) {
     const body2 = func2.childForFieldName("body");
     if (!body2) continue;
-    const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, false);
+    const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, "java");
     allBlocks.push(...blocks);
     allEdges.push(...edges);
     blockIdCounter = nextId;
@@ -8958,7 +9071,7 @@ function buildBashCFG(tree, startId, cache) {
     let lastExitIds = [];
     let firstBlockId = -1;
     for (const stmt of topLevelStatements) {
-      const result = processStatement(stmt, blockIdCounter, allBlocks, allEdges, false);
+      const result = processStatement(stmt, blockIdCounter, allBlocks, allEdges, "java");
       blockIdCounter = result.nextId;
       if (firstBlockId === -1) {
         firstBlockId = result.entryId;
@@ -9002,7 +9115,8 @@ function isBashStatement(node) {
   ]);
   return bashStatementTypes.has(node.type);
 }
-function isStatement(node, isJavaScript) {
+function isStatement(node, dialect) {
+  if (dialect === "csharp") return csharpStatementTypes.has(node.type);
   const javaStatementTypes = /* @__PURE__ */ new Set([
     "local_variable_declaration",
     "expression_statement",
@@ -9046,8 +9160,30 @@ function isStatement(node, isJavaScript) {
     "export_statement",
     "import_statement"
   ]);
-  return isJavaScript ? jsStatementTypes.has(node.type) : javaStatementTypes.has(node.type);
-}
+  return dialect === "js" ? jsStatementTypes.has(node.type) : javaStatementTypes.has(node.type);
+}
+var csharpStatementTypes = /* @__PURE__ */ new Set([
+  "local_declaration_statement",
+  "expression_statement",
+  "if_statement",
+  "for_statement",
+  "foreach_statement",
+  "while_statement",
+  "do_statement",
+  "try_statement",
+  "switch_statement",
+  "return_statement",
+  "throw_statement",
+  "break_statement",
+  "continue_statement",
+  "using_statement",
+  "lock_statement",
+  "checked_statement",
+  "unsafe_statement",
+  "yield_statement",
+  "goto_statement",
+  "block"
+]);
 function buildGoCFG(tree, blockIdCounter, cache) {
   const allBlocks = [];
   const allEdges = [];
@@ -9058,7 +9194,7 @@ function buildGoCFG(tree, blockIdCounter, cache) {
   for (const func2 of functions) {
     const body2 = func2.childForFieldName("body");
     if (!body2 || body2.type !== "block") continue;
-    const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, false);
+    const { blocks, edges, nextId } = buildMethodCFG(body2, blockIdCounter, "java");
     allBlocks.push(...blocks);
     allEdges.push(...edges);
     blockIdCounter = nextId;
@@ -13789,6 +13925,11 @@ var DEFAULT_SINKS = [
   // ADO.NET `cmd.CommandText = "…" + x` — emitted as a synthetic call by
   // extractCSharpCalls (property-assignment sink; the ctor-arg sink misses it).
   { method: "CommandText", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  // `DirectorySearcher.Filter = "(uid=" + x + ")"` — LDAP injection (cognium-ai#272).
+  // Emitted as a synthetic call by extractCSharpCalls ONLY when the receiver
+  // resolves to a DirectorySearcher, so this classless entry never over-matches
+  // other `.Filter =` assignments (DataView/BindingSource/collection filters).
+  { method: "Filter", type: "ldap_injection", cwe: "CWE-90", severity: "high", arg_positions: [0], languages: ["csharp"] },
   // ADO.NET `cmd.Execute*()` — object-carried sink (cognium-dev#271). The taint
   // rides the SqlCommand receiver (CommandText set from tainted data); the
   // receiver is surfaced as arg[0] by extractCSharpCalls, and the command object
@@ -13805,6 +13946,9 @@ var DEFAULT_SINKS = [
   // injectable — the second is the argv path where taint rides arg[1] (#276).
   { method: "Start", class: "Process", type: "command_injection", cwe: "CWE-78", severity: "critical", arg_positions: [0, 1], languages: ["csharp"] },
   { method: "ProcessStartInfo", type: "command_injection", cwe: "CWE-78", severity: "critical", arg_positions: [0, 1], languages: ["csharp"] },
+  // P/Invoke of libc `system(cmd)` — lowercase `system` in C# is virtually
+  // always the imported shell entry point (cognium-ai#275 interop/IlPinvoke).
+  { method: "system", type: "command_injection", cwe: "CWE-78", severity: "critical", arg_positions: [0], 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"] },
@@ -13833,6 +13977,9 @@ var DEFAULT_SINKS = [
   { method: "Delete", class: "Directory", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
   { method: "GetFiles", class: "Directory", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
   { method: "EnumerateFiles", class: "Directory", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  // ASP.NET `ControllerBase.PhysicalFile(path, contentType)` serves a file from
+  // an absolute disk path — attacker-controllable path is CWE-22 (cognium-ai#326/#275).
+  { method: "PhysicalFile", 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"] },
@@ -13857,6 +14004,17 @@ var DEFAULT_SINKS = [
   { method: "Load", class: "Assembly", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0], languages: ["csharp"] },
   { method: "LoadFrom", class: "Assembly", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0], languages: ["csharp"] },
   { method: "LoadFile", class: "Assembly", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  // C# server-side template injection (SSTI). Compiling an attacker-controlled
+  // template string is arbitrary code execution — classified as code_injection
+  // (CWE-94), matching how Python (Jinja2/Mako) and Node SSTI are modelled.
+  // Restricted to DISTINCTIVE template-compile APIs so the generic
+  // `Template.Parse` / `.Compile` names (int.Parse, Regex.Compile, …) are not
+  // over-matched. Taint-gated: a constant template never fires. `RunCompile`
+  // = RazorEngine; `CompileRenderStringAsync` = RazorLight; `Compile` is
+  // class-scoped to Handlebars. (cognium-dev#273)
+  { method: "RunCompile", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "CompileRenderStringAsync", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0, 1], languages: ["csharp"] },
+  { method: "Compile", class: "Handlebars", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0], languages: ["csharp"] },
   // C# insecure deserialization — the polymorphic BCL formatters that can
   // instantiate arbitrary types named in the payload (CWE-502, cognium-ai#318).
   // Each of these classes exists only to deserialize and is unsafe on untrusted
@@ -13871,6 +14029,14 @@ var DEFAULT_SINKS = [
   { 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"] },
+  // Blazor `new MarkupString(x)` renders its argument as raw HTML (the framework's
+  // documented "trusted markup" escape hatch) — attacker-controlled input is XSS. (ca#275)
+  { method: "MarkupString", class: "constructor", type: "xss", cwe: "CWE-79", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  // `String.Format(fmt, …)` with an attacker-controlled FORMAT string — CWE-134.
+  // Taint-gated on arg 0 (the format), so ordinary `String.Format("...", user)` where
+  // only an argument is tainted never fires. .NET composite formatting can't corrupt
+  // memory, so medium (FormatException DoS / unintended arg access), unlike C printf.
+  { method: "Format", class: "String", type: "format_string", cwe: "CWE-134", severity: "medium", 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"] },
@@ -13909,6 +14075,10 @@ var DEFAULT_SINKS = [
   { 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"] },
+  // XPathNavigator.Select/Evaluate — class-scoped (both names collide with LINQ
+  // `.Select`/`.Evaluate`, so they must resolve to an XPathNavigator receiver).
+  { method: "Select", class: "XPathNavigator", type: "xpath_injection", cwe: "CWE-643", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  { method: "Evaluate", class: "XPathNavigator", 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"] },
@@ -14972,7 +15142,8 @@ 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, language) : true;
+        const hasCSharpBindingAttr = language === "csharp" && param.annotations.some((a) => CSHARP_BINDING_ATTRS.has(a));
+        const isTaintable = hasCSharpBindingAttr ? true : param.type ? isInterproceduralTaintableType(param.type, language) : true;
         if (isTaintable) {
           const paramLine = param.line ?? method.start_line;
           sources.push({
@@ -15092,6 +15263,13 @@ function findSources(calls, types, patterns, sourceLines, language) {
   }
   return result;
 }
+var CSHARP_BINDING_ATTRS = /* @__PURE__ */ new Set([
+  "FromBody",
+  "FromQuery",
+  "FromRoute",
+  "FromForm",
+  "FromHeader"
+]);
 function isInterproceduralTaintableType(typeName, language) {
   const baseType = typeName.split("<")[0].trim();
   const excludedTypes = [
@@ -15330,33 +15508,195 @@ function isSafeJSChildProcessCall(call, pattern, language) {
   if (SHELL_PROGRAMS.has(program)) return false;
   return true;
 }
-function isSafeCSharpProcessStartCall(call, pattern, language) {
+var CSHARP_SHELL_PROGRAMS = /* @__PURE__ */ new Set([
+  "sh",
+  "bash",
+  "zsh",
+  "dash",
+  "ash",
+  "ksh",
+  "cmd",
+  "powershell",
+  "pwsh"
+]);
+function isConstNonShellExe(raw) {
+  if (!raw) return false;
+  const t = raw.trim();
+  if (!/^@?"[^"]*"$/.test(t)) return false;
+  const program = (t.replace(/^@?"|"$/g, "").split(/[\\/]/).pop() ?? "").toLowerCase().replace(/\.exe$/, "");
+  return !CSHARP_SHELL_PROGRAMS.has(program);
+}
+var PSI_CTOR_EXE_RE = /\bnew\s+ProcessStartInfo\s*(?:<[^>]*>)?\s*\(\s*(@?"[^"]*")/;
+function processStartInfoExe(expr, sourceLines) {
+  const inline = PSI_CTOR_EXE_RE.exec(expr);
+  if (inline) return inline[1];
+  if (sourceLines && /^[A-Za-z_]\w*$/.test(expr.trim())) {
+    const varName = expr.trim();
+    const assignRe = new RegExp(
+      `\\b${varName}\\s*=\\s*new\\s+ProcessStartInfo\\s*(?:<[^>]*>)?\\s*\\(\\s*(@?"[^"]*")`
+    );
+    for (const line of sourceLines) {
+      const m = assignRe.exec(line);
+      if (m) return m[1];
+    }
+  }
+  return null;
+}
+function isSafeCSharpProcessStartCall(call, pattern, language, sourceLines) {
   if (language !== "csharp") return false;
   if (pattern.type !== "command_injection") return false;
-  if (call.method_name !== "Start") return false;
-  if (call.arguments.length < 2) return false;
-  const fileArg = call.arguments.find((a) => a.position === 0);
-  if (!fileArg) return false;
-  let raw;
-  if (fileArg.literal !== null && fileArg.literal !== void 0) {
-    raw = String(fileArg.literal).trim();
+  const method = call.method_name;
+  if (method !== "Start" && method !== "ProcessStartInfo") return false;
+  if (call.arguments.length >= 2) {
+    const fileArg = call.arguments.find((a) => a.position === 0);
+    const raw = fileArg?.literal != null ? String(fileArg.literal) : fileArg?.expression;
+    return isConstNonShellExe(raw);
+  }
+  if (method === "Start" && call.arguments.length === 1) {
+    const arg0 = call.arguments.find((a) => a.position === 0);
+    const expr = (arg0?.expression ?? "").trim();
+    return isConstNonShellExe(processStartInfoExe(expr, sourceLines));
+  }
+  return false;
+}
+function stripCsLiterals(line) {
+  return line.replace(/\/\/.*$/, "").replace(/@?"(?:[^"\\]|\\.)*"/g, '""').replace(/'(?:[^'\\]|\\.)'/g, "''");
+}
+function csBraceDepthBefore(lines, idx) {
+  let depth = 0;
+  for (let i2 = 0; i2 < idx && i2 < lines.length; i2++) {
+    for (const ch of stripCsLiterals(lines[i2])) {
+      if (ch === "{") depth++;
+      else if (ch === "}") depth--;
+    }
+  }
+  return depth;
+}
+function netBraces(fragment) {
+  let n = 0;
+  for (const ch of fragment) {
+    if (ch === "{") n++;
+    else if (ch === "}") n--;
+  }
+  return n;
+}
+function splitCsIf(line) {
+  const m = /\bif\s*\(/.exec(line);
+  if (!m) return null;
+  const ifCol = m.index;
+  let i2 = m.index + m[0].length;
+  let depth = 1;
+  let inStr = false;
+  let strCh = "";
+  for (; i2 < line.length; i2++) {
+    const c = line[i2];
+    if (inStr) {
+      if (c === "\\") {
+        i2++;
+        continue;
+      }
+      if (c === strCh) inStr = false;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inStr = true;
+      strCh = c;
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")") {
+      depth--;
+      if (depth === 0) break;
+    }
+  }
+  if (depth !== 0) return null;
+  return { cond: line.slice(m.index + m[0].length, i2), rest: line.slice(i2 + 1), ifCol };
+}
+function csEqualityGuard(cond) {
+  const c = cond.trim();
+  let m = /^(.*?)\s*(==|!=)\s*@?"[^"]*"\s*$/.exec(c);
+  if (m) return { op: m[2], exprSide: m[1].trim() };
+  m = /^@?"[^"]*"\s*(==|!=)\s*(.*)$/.exec(c);
+  if (m) return { op: m[1], exprSide: m[2].trim() };
+  return null;
+}
+var CS_IDENT_RE = /[A-Za-z_]\w*/g;
+function csIdentifiers(expr) {
+  return new Set(expr.match(CS_IDENT_RE) ?? []);
+}
+function csThenBlock(lines, ifIdx, rest) {
+  const isExit = (s) => /^\s*(?:return|throw|continue|break)\b/.test(s);
+  let firstIdx;
+  let firstText;
+  if (rest.trim()) {
+    firstIdx = ifIdx;
+    firstText = rest;
   } else {
-    raw = (fileArg.expression ?? "").trim();
+    let j = ifIdx + 1;
+    while (j < lines.length && stripCsLiterals(lines[j]).trim() === "") j++;
+    firstIdx = j;
+    firstText = lines[j] ?? "";
   }
-  if (!/^@?"[^"]*"$/.test(raw)) return false;
-  const program = (raw.replace(/^@?"|"$/g, "").split(/[\\/]/).pop() ?? "").toLowerCase().replace(/\.exe$/, "");
-  const SHELL_PROGRAMS = /* @__PURE__ */ new Set([
-    "sh",
-    "bash",
-    "zsh",
-    "dash",
-    "ash",
-    "ksh",
-    "cmd",
-    "powershell",
-    "pwsh"
-  ]);
-  return !SHELL_PROGRAMS.has(program);
+  if (firstText.trim().startsWith("{")) {
+    let depth = 0;
+    let started = false;
+    let endLine = lines.length - 1;
+    let body2 = "";
+    for (let i2 = firstIdx; i2 < lines.length; i2++) {
+      const stripped = stripCsLiterals(i2 === firstIdx ? firstText : lines[i2]);
+      let broke = false;
+      for (const ch of stripped) {
+        if (ch === "{") {
+          depth++;
+          started = true;
+          if (depth === 1) continue;
+        } else if (ch === "}") {
+          depth--;
+          if (depth === 0) {
+            endLine = i2;
+            broke = true;
+            break;
+          }
+        }
+        if (started && depth >= 1) body2 += ch;
+      }
+      if (broke) break;
+      if (started) body2 += " ";
+    }
+    return { start: ifIdx, end: endLine, earlyExit: isExit(body2.trim()) };
+  }
+  return { start: ifIdx, end: firstIdx, earlyExit: isExit(firstText.trim()) };
+}
+function isCSharpSsrfHostAllowlistGuarded(call, pattern, language, sourceLines) {
+  if (language !== "csharp") return false;
+  if (pattern.type !== "ssrf") return false;
+  if (!sourceLines || sourceLines.length === 0) return false;
+  const candidates = /* @__PURE__ */ new Set();
+  for (const a of call.arguments) {
+    if (a.variable) candidates.add(a.variable);
+    for (const id of csIdentifiers(a.expression ?? "")) candidates.add(id);
+  }
+  if (candidates.size === 0) return false;
+  const sinkIdx = call.location.line - 1;
+  const sinkDepth = csBraceDepthBefore(sourceLines, sinkIdx);
+  for (let i2 = 0; i2 < sinkIdx; i2++) {
+    const parts2 = splitCsIf(sourceLines[i2]);
+    if (!parts2) continue;
+    const guard = csEqualityGuard(parts2.cond);
+    if (!guard) continue;
+    const guardIds = csIdentifiers(guard.exprSide);
+    if (![...guardIds].some((id) => candidates.has(id))) continue;
+    const block = csThenBlock(sourceLines, i2, parts2.rest);
+    if (guard.op === "==") {
+      if (sinkIdx >= block.start && sinkIdx <= block.end) return true;
+    } else {
+      const guardDepth = csBraceDepthBefore(sourceLines, i2) + netBraces(stripCsLiterals(sourceLines[i2]).slice(0, parts2.ifCol));
+      if (block.earlyExit && sinkIdx > block.end && guardDepth === sinkDepth) {
+        return true;
+      }
+    }
+  }
+  return false;
 }
 function isSafeRustCommandCall(call, pattern, language) {
   if (language !== "rust") return false;
@@ -15613,7 +15953,10 @@ function findSinks(calls, patterns, typeHierarchy, language, sourceLines, types)
         if (isSafeJSChildProcessCall(call, pattern, language)) {
           continue;
         }
-        if (isSafeCSharpProcessStartCall(call, pattern, language)) {
+        if (isSafeCSharpProcessStartCall(call, pattern, language, sourceLines)) {
+          continue;
+        }
+        if (isCSharpSsrfHostAllowlistGuarded(call, pattern, language, sourceLines)) {
           continue;
         }
         if (pattern.safe_if_class_literal_at !== void 0 && argIsClassLiteral(call, pattern.safe_if_class_literal_at, types)) {
@@ -26502,6 +26845,8 @@ var LanguageSourcesPass = class {
     additionalSources.push(...findSetterChainSources(types, code, language));
     additionalSources.push(...findJavaScriptAssignmentSources(code, language));
     additionalSources.push(...findCSharpRequestSources(code, language));
+    additionalSources.push(...findCSharpBindingAttributeSources(code, language));
+    additionalSources.push(...findCSharpMinimalApiSources(code, language));
     additionalSources.push(...findGoArgvSources(code, language));
     const jsDOMSinks = findJavaScriptDOMSinks(code, language);
     for (const s of jsDOMSinks) {
@@ -27209,6 +27554,89 @@ function findCSharpRequestSources(sourceCode, language) {
   }
   return sources;
 }
+var CSHARP_MINIMAL_API_BINDING = /* @__PURE__ */ new Map([
+  ["FromBody", "http_body"],
+  ["FromForm", "http_body"],
+  ["FromQuery", "http_param"],
+  ["FromRoute", "http_path"],
+  ["FromHeader", "http_param"]
+]);
+var CSHARP_NON_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "HttpContext",
+  "HttpRequest",
+  "HttpResponse",
+  "CancellationToken",
+  "ClaimsPrincipal",
+  "ILogger",
+  "IFormFileCollection"
+]);
+function findCSharpBindingAttributeSources(sourceCode, language) {
+  if (language !== "csharp") return [];
+  const sources = [];
+  const lines = sourceCode.split("\n");
+  const re = /\[\s*(FromQuery|FromBody|FromForm|FromRoute|FromHeader)(?:\s*\([^)]*\))?\s*\]\s*(?:\[[^\]]*\]\s*)*[\w.<>[\]?]+\s+([A-Za-z_]\w*)/g;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const lineRe = new RegExp(re.source, "g");
+    let m;
+    while ((m = lineRe.exec(lines[i2])) !== null) {
+      const attr = m[1];
+      const name2 = m[2];
+      const type = attr === "FromBody" || attr === "FromForm" ? "http_body" : attr === "FromRoute" ? "http_path" : "http_param";
+      if (sources.some((s) => s.line === i2 + 1 && s.variable === name2)) continue;
+      sources.push({
+        type,
+        location: `[${attr}] ${name2}`,
+        severity: "high",
+        line: i2 + 1,
+        confidence: 1,
+        variable: name2
+      });
+    }
+  }
+  return sources;
+}
+function findCSharpMinimalApiSources(sourceCode, language) {
+  if (language !== "csharp") return [];
+  const sources = [];
+  const lines = sourceCode.split("\n");
+  const mapRe = /\bMap(?:Get|Post|Put|Delete|Patch)\s*\(\s*(?:@?"[^"]*"|[\w.]+)\s*,\s*(?:\[[^\]]*\]\s*)?(?:async\s*)?\(([^)]*)\)\s*=>/;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const m = mapRe.exec(lines[i2]);
+    if (!m || !m[1].trim()) continue;
+    for (const rawParam of m[1].split(",")) {
+      const seed = classifyCSharpLambdaParam(rawParam);
+      if (!seed) continue;
+      if (sources.some((s) => s.line === i2 + 1 && s.variable === seed.name)) continue;
+      sources.push({
+        type: seed.type,
+        location: `${seed.name} (Minimal API ${seed.via})`,
+        severity: "high",
+        line: i2 + 1,
+        confidence: 1,
+        variable: seed.name
+      });
+    }
+  }
+  return sources;
+}
+function classifyCSharpLambdaParam(raw) {
+  const attrs = [...raw.matchAll(/\[([^\]]*)\]/g)].map((a) => a[1].split("(")[0].trim());
+  if (attrs.includes("FromServices")) return null;
+  if (attrs.some((a) => CSHARP_MINIMAL_API_BINDING.has(a))) return null;
+  const noAttr = raw.replace(/\[[^\]]*\]/g, "").trim();
+  const parts2 = noAttr.split(/\s+/).filter(Boolean);
+  if (parts2.length < 2) return null;
+  const name2 = parts2[parts2.length - 1];
+  if (!/^[A-Za-z_]\w*$/.test(name2)) return null;
+  const baseType = (parts2[parts2.length - 2] ?? "").replace(/[?\[\]]/g, "").split("<")[0].split(".").pop() ?? "";
+  if (CSHARP_NON_INPUT_TYPES.has(baseType)) return null;
+  for (const a of attrs) {
+    const t = CSHARP_MINIMAL_API_BINDING.get(a);
+    if (t) return { type: t, name: name2, via: `[${a}]` };
+  }
+  if (baseType === "string") return { type: "http_param", name: name2, via: "string param" };
+  return null;
+}
 function findJavaScriptAssignmentSources(sourceCode, language) {
   if (!["javascript", "typescript"].includes(language)) return [];
   const sources = [];
@@ -41534,6 +41962,9 @@ var JAVA_SET_HTTPONLY_TRUE_RE = /\.setHttpOnly\s*\(\s*true\s*\)/;
 var GO_SECURE_TRUE_RE = /\bSecure\s*:\s*true\b/;
 var GO_HTTPONLY_TRUE_RE = /\bHttpOnly\s*:\s*true\b/;
 var RUST_SET_COOKIE_MACRO_RE = /(format!|write!|writeln!)\s*\(([^()]*Set-Cookie[^()]*)\)/gis;
+var CS_COOKIE_OPTIONS_RE = /\bnew\s+CookieOptions\s*\{([^{}]*)\}/gs;
+var CS_SECURE_FALSE_RE = /\bSecure\s*=\s*false\b/;
+var CS_HTTPONLY_FALSE_RE = /\bHttpOnly\s*=\s*false\b/;
 var InsecureCookiePass = class {
   name = "insecure-cookie";
   category = "security";
@@ -41577,9 +42008,29 @@ var InsecureCookiePass = class {
         insecureCookies.push(det);
         this.emit(ctx, file, det, "rust");
       }
+    } else if (language === "csharp") {
+      for (const det of this.detectCSharpCookieOptions(code)) {
+        insecureCookies.push(det);
+        this.emit(ctx, file, det, "csharp");
+      }
     }
     return { insecureCookies };
   }
+  // ---------------- C# ----------------
+  detectCSharpCookieOptions(code) {
+    const out2 = [];
+    const re = new RegExp(CS_COOKIE_OPTIONS_RE.source, CS_COOKIE_OPTIONS_RE.flags);
+    let m;
+    while ((m = re.exec(code)) !== null) {
+      const body2 = m[1] ?? "";
+      const missingSecure = CS_SECURE_FALSE_RE.test(body2);
+      const missingHttpOnly = CS_HTTPONLY_FALSE_RE.test(body2);
+      if (!missingSecure && !missingHttpOnly) continue;
+      const line = code.slice(0, m.index).split("\n").length;
+      out2.push({ line, receiver: "CookieOptions", missingSecure, missingHttpOnly, optionsPresent: true });
+    }
+    return out2;
+  }
   // ---------------- JS / TS ----------------
   detectJs(call) {
     if (call.method_name !== "cookie") return null;
@@ -41681,15 +42132,15 @@ var InsecureCookiePass = class {
     const missing = [];
     if (det.missingSecure) {
       missing.push(
-        flavor === "js" ? "`secure: true`" : flavor === "python" ? "`secure=True`" : flavor === "java" ? "`setSecure(true)`" : flavor === "go" ? "`Secure: true`" : "`Secure` attribute"
+        flavor === "js" ? "`secure: true`" : flavor === "python" ? "`secure=True`" : flavor === "java" ? "`setSecure(true)`" : flavor === "go" ? "`Secure: true`" : flavor === "csharp" ? "`Secure = true`" : "`Secure` attribute"
       );
     }
     if (det.missingHttpOnly) {
       missing.push(
-        flavor === "js" ? "`httpOnly: true`" : flavor === "python" ? "`httponly=True`" : flavor === "java" ? "`setHttpOnly(true)`" : flavor === "go" ? "`HttpOnly: true`" : "`HttpOnly` attribute"
+        flavor === "js" ? "`httpOnly: true`" : flavor === "python" ? "`httponly=True`" : flavor === "java" ? "`setHttpOnly(true)`" : flavor === "go" ? "`HttpOnly: true`" : flavor === "csharp" ? "`HttpOnly = true`" : "`HttpOnly` attribute"
       );
     }
-    const fix = flavor === "js" ? 'Pass `{ secure: true, httpOnly: true, sameSite: "lax" }` as the third argument to `res.cookie()`.' : flavor === "python" ? 'Pass `secure=True, httponly=True, samesite="Lax"` to `response.set_cookie(...)`.' : flavor === "java" ? "After constructing the cookie, call `cookie.setSecure(true)` and `cookie.setHttpOnly(true)` before adding it to the response." : flavor === "go" ? "Set `Secure: true` and `HttpOnly: true` on the `http.Cookie` struct literal passed to `http.SetCookie`." : "Append `; Secure; HttpOnly` to the `Set-Cookie` header string.";
+    const fix = flavor === "js" ? 'Pass `{ secure: true, httpOnly: true, sameSite: "lax" }` as the third argument to `res.cookie()`.' : flavor === "python" ? 'Pass `secure=True, httponly=True, samesite="Lax"` to `response.set_cookie(...)`.' : flavor === "java" ? "After constructing the cookie, call `cookie.setSecure(true)` and `cookie.setHttpOnly(true)` before adding it to the response." : flavor === "go" ? "Set `Secure: true` and `HttpOnly: true` on the `http.Cookie` struct literal passed to `http.SetCookie`." : flavor === "csharp" ? "Set `Secure = true` and `HttpOnly = true` on the `CookieOptions` (or enforce them globally via `CookiePolicyOptions`)." : "Append `; Secure; HttpOnly` to the `Set-Cookie` header string.";
     ctx.addFinding({
       id: `${this.name}-${file}-${det.line}`,
       pass: this.name,
@@ -42160,6 +42611,7 @@ var ISSUE_CWE = {
   "hardcoded-key": "CWE-321",
   "weak-rsa-key": "CWE-326"
 };
+var CS_CIPHER_MODE_ECB_RE = /\bCipherMode\s*\.\s*ECB\b/;
 var WeakCryptoPass = class {
   name = "weak-crypto";
   category = "security";
@@ -42175,26 +42627,34 @@ var WeakCryptoPass = class {
     const findings = [];
     const constProp = ctx.hasResult("constant-propagation") ? ctx.getResult("constant-propagation") : null;
     const literalBindings = scanLiteralBindings(code, language);
+    const emit = (line, det) => {
+      findings.push({ line, language, ...det });
+      ctx.addFinding({
+        id: `${this.name}-${file}-${line}-${det.issue}`,
+        pass: this.name,
+        category: this.category,
+        rule_id: this.name,
+        cwe: ISSUE_CWE[det.issue],
+        severity: "high",
+        level: "error",
+        message: this.buildMessage(det),
+        file,
+        line,
+        fix: this.buildFix(det.issue),
+        evidence: { ...det, language }
+      });
+    };
     for (const call of graph.ir.calls) {
-      const detections = this.detect(call, language, constProp, literalBindings);
-      for (const det of detections) {
-        const line = call.location.line;
-        findings.push({ line, language, ...det });
-        const message = this.buildMessage(det);
-        ctx.addFinding({
-          id: `${this.name}-${file}-${line}-${det.issue}`,
-          pass: this.name,
-          category: this.category,
-          rule_id: this.name,
-          cwe: ISSUE_CWE[det.issue],
-          severity: "high",
-          level: "error",
-          message,
-          file,
-          line,
-          fix: this.buildFix(det.issue),
-          evidence: { ...det, language }
-        });
+      for (const det of this.detect(call, language, constProp, literalBindings)) {
+        emit(call.location.line, det);
+      }
+    }
+    if (language === "csharp") {
+      const lines = code.split("\n");
+      for (let i2 = 0; i2 < lines.length; i2++) {
+        if (CS_CIPHER_MODE_ECB_RE.test(lines[i2])) {
+          emit(i2 + 1, { issue: "ecb-mode", detail: "CipherMode.ECB", api: "SymmetricAlgorithm.Mode" });
+        }
       }
     }
     return { findings };
@@ -43434,8 +43894,12 @@ var InsecureDeserializationConfigPass = class {
   name = "insecure-deserialization-config";
   category = "security";
   run(ctx) {
+    if (ctx.language === "java") return this.runJava(ctx);
+    if (ctx.language === "csharp") return this.runCSharp(ctx);
+    return { findings: [] };
+  }
+  runJava(ctx) {
     const { graph, language } = ctx;
-    if (language !== "java") return { findings: [] };
     const file = graph.ir.meta.file;
     const findings = [];
     for (const call of graph.ir.calls) {
@@ -43460,12 +43924,46 @@ var InsecureDeserializationConfigPass = class {
     }
     return { findings };
   }
+  // C# — Json.NET `TypeNameHandling` set to a value other than `None` (ca#318).
+  // `TypeNameHandling.All/Auto/Objects/Arrays` makes Json.NET honour a `$type`
+  // field in the payload and instantiate the named .NET type, so
+  // `JsonConvert.DeserializeObject(untrusted, settings)` becomes a gadget-chain
+  // RCE (the .NET analogue of XStream's grant-all). The vulnerability is the
+  // constant setting, independent of flow — the secure value `None` never matches.
+  runCSharp(ctx) {
+    const file = ctx.graph.ir.meta.file;
+    const findings = [];
+    const lines = ctx.code.split("\n");
+    for (let i2 = 0; i2 < lines.length; i2++) {
+      const m = INSECURE_TYPE_NAME_HANDLING_RE.exec(lines[i2]);
+      if (!m) continue;
+      const line = i2 + 1;
+      const api = `TypeNameHandling = TypeNameHandling.${m[1]}`;
+      findings.push({ line, api });
+      ctx.addFinding({
+        id: `${this.name}-${file}-${line}`,
+        pass: this.name,
+        category: this.category,
+        rule_id: this.name,
+        cwe: "CWE-502",
+        severity: "high",
+        level: "error",
+        message: `Json.NET configured with TypeNameHandling.${m[1]}: a $type field in untrusted JSON can instantiate arbitrary .NET types (deserialization RCE)`,
+        file,
+        line,
+        fix: "Use TypeNameHandling.None (the default), or bind a SerializationBinder that allow-lists the exact types you deserialize.",
+        evidence: { api, language: "csharp" }
+      });
+    }
+    return { findings };
+  }
   isPermissiveXStreamConfig(call) {
     if (call.method_name !== "addPermission") return false;
     const arg0 = call.arguments[0]?.expression;
     return typeof arg0 === "string" && ANY_TYPE_PERMISSION_RE.test(arg0);
   }
 };
+var INSECURE_TYPE_NAME_HANDLING_RE = /\bTypeNameHandling\s*=\s*(?:Newtonsoft\.Json\.)?TypeNameHandling\.(All|Auto|Objects|Arrays)\b/;
 
 // src/analysis/passes/plaintext-password-storage-pass.ts
 function isWriteStorageCall(call, language) {
@@ -43708,6 +44206,8 @@ var VERIFY_FALSE_RE = /\bverify\s*=\s*False\b/;
 var REJECT_UNAUTHORIZED_FALSE_RE = /\brejectUnauthorized\s*:\s*false\b/;
 var INSECURE_SKIP_VERIFY_TRUE_RE = /\bInsecureSkipVerify\s*:\s*true\b/;
 var HOSTNAME_LAMBDA_TRUE_RE = /\(\s*\w+\s*,\s*\w+\s*\)\s*->\s*true\b/;
+var CS_CERT_CALLBACK_TRUE_RE = /\b(ServerCertificateValidationCallback|ServerCertificateCustomValidationCallback|RemoteCertificateValidationCallback)\s*(?:\+?=|\()\s*(?:\([^)]*\)|\w+)\s*=>\s*(?:true\b|\{\s*return\s+true\b)/;
+var CS_DANGEROUS_ACCEPT_RE = /\bDangerousAcceptAnyServerCertificateValidator\b/;
 var ALLOW_ALL_HOSTNAME_VERIFIERS = /* @__PURE__ */ new Set([
   "NoopHostnameVerifier.INSTANCE",
   "new AllowAllHostnameVerifier()",
@@ -43852,6 +44352,21 @@ var TlsVerifyDisabledPass = class {
         }
       }
     }
+    if (language === "csharp") {
+      for (let i2 = 0; i2 < lines.length; i2++) {
+        const l = lines[i2];
+        const m = CS_CERT_CALLBACK_TRUE_RE.exec(l);
+        if (m) {
+          out2.push({ line: i2 + 1, pattern: `${m[1]} => true`, api: m[1] });
+        } else if (CS_DANGEROUS_ACCEPT_RE.test(l)) {
+          out2.push({
+            line: i2 + 1,
+            pattern: "DangerousAcceptAnyServerCertificateValidator",
+            api: "HttpClientHandler"
+          });
+        }
+      }
+    }
     return out2;
   }
   fixFor(language, pattern) {
@@ -43873,6 +44388,9 @@ var TlsVerifyDisabledPass = class {
     if (pattern.includes("ssl._create_unverified_context")) {
       return "Do not use `_create_unverified_context()`. Use `ssl.create_default_context()`.";
     }
+    if (language === "csharp") {
+      return "Do not accept every certificate. Remove the always-true validation callback (and `DangerousAcceptAnyServerCertificateValidator`); rely on the platform default. To trust a private CA, validate the chain against it in the callback instead of returning true.";
+    }
     return "Restore TLS certificate and hostname verification.";
   }
 };
@@ -44376,6 +44894,8 @@ var PY_VERIFY_SIGNATURE_FALSE_RE = /["']verify_signature["']\s*:\s*False\b/;
 var PY_VERIFY_KW_FALSE_RE = /\bverify\s*=\s*False\b/;
 var PY_ALG_NONE_RE = /\balgorithms\s*=\s*[\[\(]\s*["']none["']/i;
 var JS_ALG_NONE_RE = /\balgorithms\s*:\s*\[\s*["']none["']/i;
+var CS_REQUIRE_SIGNED_FALSE_RE = /\bRequireSignedTokens\s*=\s*false\b/;
+var CS_SIGNATURE_VALIDATOR_BYPASS_RE = /\bSignatureValidator\s*=\s*[^;]*=>\s*new\s+JwtSecurityToken\b/;
 var JwtVerifyDisabledPass = class {
   name = "jwt-verify-disabled";
   category = "security";
@@ -44383,25 +44903,34 @@ var JwtVerifyDisabledPass = class {
     const { graph, language } = ctx;
     const file = graph.ir.meta.file;
     const findings = [];
+    const emit = (line, det) => {
+      findings.push({ line, language, ...det });
+      ctx.addFinding({
+        id: `${this.name}-${file}-${line}-${det.pattern}`,
+        pass: this.name,
+        category: this.category,
+        rule_id: this.name,
+        cwe: "CWE-347",
+        severity: "critical",
+        level: "error",
+        message: `JWT signature verification disabled via \`${det.pattern}\` in \`${det.api}\`. Any attacker can forge a token with arbitrary claims (user id, roles, expiry) since the signature is not checked.`,
+        file,
+        line,
+        fix: this.fixFor(language),
+        evidence: { ...det, language }
+      });
+    };
     for (const call of graph.ir.calls) {
-      const detections = this.detect(call, language);
-      for (const det of detections) {
-        const line = call.location.line;
-        findings.push({ line, language, ...det });
-        ctx.addFinding({
-          id: `${this.name}-${file}-${line}-${det.pattern}`,
-          pass: this.name,
-          category: this.category,
-          rule_id: this.name,
-          cwe: "CWE-347",
-          severity: "critical",
-          level: "error",
-          message: `JWT signature verification disabled via \`${det.pattern}\` in \`${det.api}\`. Any attacker can forge a token with arbitrary claims (user id, roles, expiry) since the signature is not checked.`,
-          file,
-          line,
-          fix: this.fixFor(language),
-          evidence: { ...det, language }
-        });
+      for (const det of this.detect(call, language)) emit(call.location.line, det);
+    }
+    if (language === "csharp") {
+      const lines = ctx.code.split("\n");
+      for (let i2 = 0; i2 < lines.length; i2++) {
+        if (CS_REQUIRE_SIGNED_FALSE_RE.test(lines[i2])) {
+          emit(i2 + 1, { pattern: "RequireSignedTokens = false", api: "TokenValidationParameters" });
+        } else if (CS_SIGNATURE_VALIDATOR_BYPASS_RE.test(lines[i2])) {
+          emit(i2 + 1, { pattern: "SignatureValidator returns an unvalidated token", api: "TokenValidationParameters" });
+        }
       }
     }
     return { findings };
@@ -44473,6 +45002,9 @@ var JwtVerifyDisabledPass = class {
     if (language === "java") {
       return "For auth0/java-jwt: use `JWT.require(Algorithm.HMAC256(secret))` or an RSA algorithm. For jjwt: call `parseClaimsJws(token)` (signature enforced) rather than `parse(token)` (signature ignored).";
     }
+    if (language === "csharp") {
+      return "Leave `RequireSignedTokens = true` and do not install a custom `SignatureValidator` that returns the token unverified. Configure `IssuerSigningKey`/`IssuerSigningKeys` and let the handler validate the signature.";
+    }
     return "Enforce JWT signature verification with a concrete algorithm (HS256/RS256/ES256). Never accept `alg: none`.";
   }
 };
@@ -45629,6 +46161,25 @@ function getNodeTypesForLanguage(language) {
         "selector_expression",
         "identifier"
       ]);
+    case "csharp":
+      return /* @__PURE__ */ new Set([
+        "method_invocation",
+        "object_creation_expression",
+        "class_declaration",
+        "method_declaration",
+        "constructor_declaration",
+        "field_declaration",
+        "import_declaration",
+        "interface_declaration",
+        "enum_declaration",
+        "package_declaration",
+        "local_variable_declaration",
+        // buildCSharpCFG method-like containers
+        "destructor_declaration",
+        "operator_declaration",
+        "local_function_statement",
+        "accessor_declaration"
+      ]);
     default:
       return /* @__PURE__ */ new Set([
         "method_invocation",