circle-ir 4.9.27 → 4.9.29

package/dist/browser/circle-ir.js

@@ -4434,6 +4434,21 @@ function extractTypes(tree, cache, language) {
   }
   return extractJavaTypes(tree, cache);
 }
+function csharpMemberNodes(body2) {
+  if (!body2) return [];
+  const out2 = [];
+  const visit = (parent, depth) => {
+    if (depth > 32) return;
+    for (let i2 = 0; i2 < parent.childCount; i2++) {
+      const c = parent.child(i2);
+      if (!c) continue;
+      if (c.type.startsWith("preproc_")) visit(c, depth + 1);
+      else out2.push(c);
+    }
+  };
+  visit(body2, 0);
+  return out2;
+}
 function extractCSharpTypes(tree, cache) {
   const types = [];
   const KINDS = {
@@ -4450,9 +4465,8 @@ function extractCSharpTypes(tree, cache) {
       const methods = [];
       const fields = extractCSharpFields(body2);
       if (body2) {
-        for (let i2 = 0; i2 < body2.childCount; i2++) {
-          const m = body2.child(i2);
-          if (!m || m.type !== "method_declaration") continue;
+        for (const m of csharpMemberNodes(body2)) {
+          if (m.type !== "method_declaration") continue;
           const mName = m.childForFieldName("name");
           const paramList = m.childForFieldName("parameters");
           const parameters = [];
@@ -4503,9 +4517,7 @@ function extractCSharpTypes(tree, cache) {
 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;
+  for (const c of csharpMemberNodes(body2)) {
     if (c.type === "field_declaration") {
       let varDecl = null;
       for (let k = 0; k < c.childCount; k++) {
@@ -6039,6 +6051,13 @@ function extractCalls(tree, cache, language) {
 function buildCSharpReceiverTypeMap(tree, cache) {
   const map = /* @__PURE__ */ new Map();
   const simple = (t) => t.replace(/<[^>]*>/g, "").split(".").pop()?.trim() ?? t;
+  for (const prm of getNodesFromCache(tree.rootNode, "parameter", cache)) {
+    const nameNode = prm.childForFieldName("name");
+    const typeNode = prm.childForFieldName("type");
+    if (nameNode?.type !== "identifier" || !typeNode) continue;
+    const t = getNodeText(typeNode);
+    if (t && t !== "var") map.set(getNodeText(nameNode), simple(t));
+  }
   for (const vd of getNodesFromCache(tree.rootNode, "variable_declaration", cache)) {
     const typeNode = vd.childForFieldName("type");
     const declaredType = typeNode ? getNodeText(typeNode) : null;
@@ -6068,6 +6087,7 @@ function findFirstDescendant(node, type) {
   }
   return null;
 }
+var CSHARP_RESPONSE_TYPES = /* @__PURE__ */ new Set(["HttpResponse", "HttpResponseBase"]);
 var CSHARP_COMMAND_EXECUTE_METHODS = /* @__PURE__ */ new Set([
   "ExecuteScalar",
   "ExecuteReader",
@@ -6184,6 +6204,31 @@ function extractCSharpCalls(tree, cache) {
       });
       continue;
     }
+    if (left?.type === "identifier" && asn.parent?.type === "initializer_expression") {
+      const creation = asn.parent.parent;
+      if (creation?.type !== "object_creation_expression") continue;
+      const ctorType = creation.childForFieldName("type");
+      const right2 = asn.childForFieldName("right");
+      if (!ctorType || !right2) continue;
+      const typeName = csharpBareName(ctorType);
+      const rhsText2 = getNodeText(right2);
+      calls.push({
+        method_name: getNodeText(left),
+        receiver: typeName,
+        receiver_type: typeName,
+        receiver_type_fqn: null,
+        arguments: [{
+          position: 0,
+          expression: rhsText2,
+          variable: right2.type === "identifier" ? rhsText2 : null,
+          literal: CSHARP_LITERAL_NODE_TYPES.has(right2.type) ? rhsText2 : null,
+          value: null
+        }],
+        location: { line: asn.startPosition.row + 1, column: asn.startPosition.column },
+        in_method: findEnclosingMethod(asn)
+      });
+      continue;
+    }
     if (left?.type !== "member_access_expression") continue;
     const nameNode = left.childForFieldName("name");
     if (!nameNode) continue;
@@ -6193,6 +6238,14 @@ function extractCSharpCalls(tree, cache) {
       const recv = exprNode ? getNodeText(exprNode) : null;
       const recvType = recv ? typeMap.get(recv) : void 0;
       if (recvType !== "DirectorySearcher") continue;
+    } else if (propName === "StatusDescription") {
+      const recv = exprNode ? getNodeText(exprNode) : "";
+      const recvType = recv ? typeMap.get(recv) : void 0;
+      if (!/(^|\.)(Response|HttpResponse|Context\.Response)$/.test(recv) && !(recvType && CSHARP_RESPONSE_TYPES.has(recvType))) continue;
+    } else if (propName === "BaseAddress") {
+      const recv = exprNode ? getNodeText(exprNode) : null;
+      const recvType = recv ? typeMap.get(recv) : void 0;
+      if (recvType !== "HttpClient") continue;
     } else if (propName !== "CommandText") {
       continue;
     }
@@ -6215,8 +6268,34 @@ function extractCSharpCalls(tree, cache) {
       in_method: findEnclosingMethod(asn)
     });
   }
+  const casts = getNodesFromCache(tree.rootNode, "cast_expression", cache);
+  for (const cast of casts) {
+    const typeNode = cast.childForFieldName("type");
+    const valueNode = cast.childForFieldName("value");
+    if (!typeNode || !valueNode) continue;
+    const typeName = csharpBareName(typeNode);
+    if (!CSHARP_RAW_MARKUP_CAST_TYPES.has(typeName)) continue;
+    const valueText = getNodeText(valueNode);
+    calls.push({
+      method_name: typeName,
+      receiver: null,
+      receiver_type: null,
+      receiver_type_fqn: null,
+      arguments: [{
+        position: 0,
+        expression: valueText,
+        variable: valueNode.type === "identifier" ? valueText : null,
+        literal: CSHARP_LITERAL_NODE_TYPES.has(valueNode.type) ? valueText : null,
+        value: null
+      }],
+      location: { line: cast.startPosition.row + 1, column: cast.startPosition.column },
+      in_method: findEnclosingMethod(cast),
+      is_constructor: true
+    });
+  }
   return calls;
 }
+var CSHARP_RAW_MARKUP_CAST_TYPES = /* @__PURE__ */ new Set(["MarkupString"]);
 function extractCSharpArguments(argsNode) {
   const args2 = [];
   let position = 0;
@@ -6236,12 +6315,22 @@ function extractCSharpArguments(argsNode) {
       position: position++,
       expression: text,
       variable: expr?.type === "identifier" ? text : null,
-      literal: expr?.type === "string_literal" ? text : null,
+      literal: expr && CSHARP_LITERAL_NODE_TYPES.has(expr.type) ? text : null,
       value: null
     });
   }
   return args2;
 }
+var CSHARP_LITERAL_NODE_TYPES = /* @__PURE__ */ new Set([
+  "string_literal",
+  "verbatim_string_literal",
+  "raw_string_literal",
+  "character_literal",
+  "integer_literal",
+  "real_literal",
+  "boolean_literal",
+  "null_literal"
+]);
 function extractJavaScriptCalls(tree, cache) {
   const calls = [];
   const context = buildJSResolutionContext(tree, cache);
@@ -11652,6 +11741,23 @@ var DEFAULT_SOURCES = [
   { method: "next", class: "Scanner", type: "io_input", severity: "high", return_tainted: true },
   { method: "nextInt", class: "Scanner", type: "io_input", severity: "high", return_tainted: true },
   // Database result sources
+  // C# I/O, network and database reads (cognium-dev#502). Mirrors the Java
+  // rows above one-for-one, including the severity split: console/file I/O is
+  // `io_input` at high, a database row read is `db_input` at medium. There is
+  // no separate confidence tier — `type` + `severity` IS the tier, exactly as
+  // for `BufferedReader.readLine` vs `ResultSet.getString`.
+  { method: "ReadLine", class: "StreamReader", type: "io_input", severity: "high", return_tainted: true, languages: ["csharp"] },
+  { method: "ReadLineAsync", class: "StreamReader", type: "io_input", severity: "high", return_tainted: true, languages: ["csharp"] },
+  { method: "ReadToEnd", class: "StreamReader", type: "io_input", severity: "high", return_tainted: true, languages: ["csharp"] },
+  { method: "ReadToEndAsync", class: "StreamReader", type: "io_input", severity: "high", return_tainted: true, languages: ["csharp"] },
+  // Socket and HTTP-client reads. `GetStream` / `AcceptTcpClient` /
+  // `OpenRead` return the channel; the read off it is covered by the
+  // StreamReader rows above, and seeding the channel too lets a flow form when
+  // the read is inlined.
+  { method: "GetStream", class: "TcpClient", type: "network_input", severity: "high", return_tainted: true, languages: ["csharp"] },
+  { method: "AcceptTcpClient", class: "TcpListener", type: "network_input", severity: "high", return_tainted: true, languages: ["csharp"] },
+  { method: "OpenRead", class: "WebClient", type: "network_input", severity: "high", return_tainted: true, languages: ["csharp"] },
+  { method: "DownloadString", class: "WebClient", type: "network_input", severity: "high", return_tainted: true, languages: ["csharp"] },
   { method: "getString", class: "ResultSet", type: "db_input", severity: "medium", return_tainted: true },
   { method: "getObject", class: "ResultSet", type: "db_input", severity: "medium", return_tainted: true },
   { method: "getInt", class: "ResultSet", type: "db_input", severity: "medium", return_tainted: true },
@@ -13892,9 +13998,14 @@ var DEFAULT_SINKS = [
   { method: "deserialize", class: "bincode", type: "deserialization", cwe: "CWE-502", severity: "critical", arg_positions: [0] },
   { method: "from_str", class: "toml", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
   { method: "from_str", class: "ron", type: "deserialization", cwe: "CWE-502", severity: "high", arg_positions: [0] },
-  // Generic deserialization patterns
-  { method: "from_str", type: "deserialization", cwe: "CWE-502", severity: "medium", arg_positions: [0] },
-  { method: "from_slice", type: "deserialization", cwe: "CWE-502", severity: "medium", arg_positions: [0] },
+  // #294/#484: no classless `from_str` / `from_slice` deserialization sink.
+  // Those rows matched EVERY `T::from_str` / `from_slice` — `u32::from_str`,
+  // `Url::from_str`, `PublicKey::from_slice` — i.e. ordinary `FromStr` / byte
+  // parsing, which cannot instantiate an attacker-chosen type. Removing them
+  // was previously blocked because the class-scoped rows below could not match
+  // the IMPORTED call form (`use serde_json::from_str; from_str(&body)`); the
+  // `::` path-separator fix in taint-matcher.ts makes them match, so the
+  // classless rows are no longer load-bearing.
   // Rust XSS (actix-web, rocket, axum response body)
   { method: "body", class: "HttpResponseBuilder", type: "xss", cwe: "CWE-79", severity: "high", arg_positions: [0] },
   { method: "body", class: "HttpResponse", type: "xss", cwe: "CWE-79", severity: "high", arg_positions: [0] },
@@ -14211,8 +14322,12 @@ var DEFAULT_SINKS = [
   { 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"] },
+  // #502: the `(Stream)` overload takes no path — `new StreamReader(tcp.GetStream())`
+  // is not CWE-22. The `(string path)` overload still matches.
+  { method: "StreamReader", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], safe_if_stream_arg_at: 0, languages: ["csharp"] },
+  // #502: the `(Stream)` overload takes no path — `new StreamWriter(tcp.GetStream())`
+  // is not CWE-22. The `(string path)` overload still matches.
+  { method: "StreamWriter", type: "path_traversal", cwe: "CWE-22", severity: "high", arg_positions: [0], safe_if_stream_arg_at: 0, languages: ["csharp"] },
   // Remaining System.IO.File path APIs — class-scoped so they don't collide
   // with unrelated methods. Copy/Move take a source AND destination path (both
   // attacker-controllable → read-anywhere / write-anywhere), hence [0, 1].
@@ -14256,6 +14371,23 @@ var DEFAULT_SINKS = [
   // `new RestClient(userUrl)` points every later request at attacker-controlled
   // infrastructure. Ctor arg 0, taint-gated.
   { method: "RestClient", class: "constructor", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
+  // C# code injection — CodeDOM runtime compilation (CWE-94), cognium-dev#503
+  // part 2. `provider.CompileAssemblyFromSource(parameters, source)` compiles
+  // and can then execute attacker-supplied C#, so the source argument is the
+  // injection point. The signature is
+  // `CompileAssemblyFromSource(CompilerParameters, params string[] sources)`,
+  // so the sources begin at position 1 — position 0 is the options object.
+  //
+  // These rows are only useful together with the #530 StringBuilder
+  // propagation fix: the Juliet CWE-94 corpus accumulates the compiled source
+  // through `sb.Append(...)` and reads it back with `ToString()`, so before
+  // that fix the sink registered but no taint ever reached it.
+  { method: "CompileAssemblyFromSource", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [1, 2], languages: ["csharp"] },
+  { method: "CompileAssemblyFromSourceBatch", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [1, 2], languages: ["csharp"] },
+  // Roslyn's equivalent pair. `ParseText` turns text into a syntax tree and
+  // `Create` compiles it; either is the point where attacker text becomes code.
+  { method: "ParseText", class: "CSharpSyntaxTree", type: "code_injection", cwe: "CWE-94", severity: "critical", arg_positions: [0], languages: ["csharp"] },
+  { method: "ParseText", class: "SyntaxFactory", type: "code_injection", cwe: "CWE-94", severity: "critical", 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"] },
@@ -14300,6 +14432,10 @@ var DEFAULT_SINKS = [
   // 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"] },
+  // #503 (part 1): `Response.StatusDescription = "Bad " + data` writes
+  // attacker text into the HTTP status line (CWE-81). Surfaced by the
+  // property-assignment synthesiser in the C# extractor, receiver-gated there.
+  { method: "StatusDescription", class: "Response", type: "xss", cwe: "CWE-81", severity: "medium", arg_positions: [0], languages: ["csharp"] },
   // `return Content(html, "text/html")` on a controller writes arg 0 to the
   // response body unescaped (cognium-dev#275). Taint-gated on arg 0; the common
   // `Content(constantString)` and the JSON/plain-text content types are
@@ -14314,6 +14450,12 @@ var DEFAULT_SINKS = [
   // 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"] },
+  // #336: a tainted `HttpClient.BaseAddress` gives the attacker the scheme,
+  // host and port of every RELATIVE request made on that client, so the
+  // request arguments can all be constant and the destination still be
+  // attacker-chosen. Surfaced by the property-assignment synthesiser, which
+  // class-gates it to a resolved `HttpClient`.
+  { method: "BaseAddress", class: "HttpClient", type: "ssrf", cwe: "CWE-918", severity: "high", arg_positions: [0], languages: ["csharp"] },
   // C# open redirect — ASP.NET MVC / Minimal API redirect helpers (CWE-601,
   // cognium-dev#273/#275). Classless: `return Redirect(url)` on a controller is
   // an implicit-`this` call (no receiver), and `Results.Redirect(url)` /
@@ -16146,6 +16288,20 @@ function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var TYPE_TOKEN_RE = /^new\s+(?:TypeReference|TypeToken)\s*<[\s\S]*>\s*\(\s*\)\s*\{\s*\}$/;
+function argIsStreamExpression(call, position) {
+  const arg = call.arguments.find((a) => a.position === position);
+  if (!arg) return false;
+  const expr = (arg.expression ?? "").trim();
+  if (!expr) return false;
+  return (
+    // `new MemoryStream(...)`, `new FileStream(...)`, `new GZipStream(...)`
+    /^new\s+[A-Za-z_][\w.]*Stream\s*\(/.test(expr) || // `tcp.GetStream()`, `resp.GetResponseStream()`, `file.OpenReadStream()`
+    /\.\s*Get(?:Response)?Stream\s*\(/.test(expr) || /\.\s*OpenReadStream\s*\(/.test(expr) || // `wc.OpenRead(url)` returns a Stream (WebClient), as does `File.OpenRead`
+    /\.\s*OpenRead\s*\(/.test(expr) || // `Request.Body`, `x.BaseStream`
+    /\.\s*(?:Body|BaseStream)\s*$/.test(expr) || // a local whose name is stream-ish and is not a path string
+    /^(?:[A-Za-z_]\w*\.)*[A-Za-z_]*[sS]tream\d*$/.test(expr)
+  );
+}
 function argIsStringLiteral(call, position) {
   const arg = call.arguments.find((a) => a.position === position);
   if (!arg) return false;
@@ -16383,6 +16539,9 @@ function findSinks(calls, patterns, typeHierarchy, language, sourceLines, types)
         if (pattern.safe_if_string_literal_at !== void 0 && argIsStringLiteral(call, pattern.safe_if_string_literal_at)) {
           continue;
         }
+        if (pattern.safe_if_stream_arg_at !== void 0 && argIsStreamExpression(call, pattern.safe_if_stream_arg_at)) {
+          continue;
+        }
         if (pattern.type === "command_injection") {
           if (call.is_constructor) {
             if (!CWE_78_RECEIVER_ALLOWLIST.has(call.method_name)) {
@@ -16777,8 +16936,9 @@ function matchesSinkPattern(call, pattern, typeHierarchy, language) {
       return false;
     } else if (!call.receiver && !call.receiver_type) {
       const target = call.resolution?.target;
+      const normalisedTarget = language === "rust" ? target?.replace(/::/g, ".") : target;
       const expectedTail = `${pattern.class}.${pattern.method}`;
-      if (target && (target === expectedTail || target.endsWith("." + expectedTail))) {
+      if (normalisedTarget && (normalisedTarget === expectedTail || normalisedTarget.endsWith("." + expectedTail))) {
       } else {
         return false;
       }
@@ -19345,6 +19505,122 @@ var GO_PURE_PACKAGES = /* @__PURE__ */ new Set([
   "hex",
   "base64"
 ]);
+var CSHARP_PURE_STATIC_RECEIVERS = /* @__PURE__ */ new Set([
+  // formatting / conversion / parsing — return a derived value
+  "string",
+  "String",
+  "Convert",
+  "Encoding",
+  "BitConverter",
+  "Math",
+  "Int16",
+  "Int32",
+  "Int64",
+  "UInt16",
+  "UInt32",
+  "UInt64",
+  "Double",
+  "Single",
+  "Decimal",
+  "Boolean",
+  "Byte",
+  "SByte",
+  "Char",
+  "Guid",
+  "DateTime",
+  "DateTimeOffset",
+  "TimeSpan",
+  "Enum",
+  "Array",
+  "Buffer",
+  "Nullable",
+  "CultureInfo",
+  "StringComparer",
+  "Comparer",
+  "EqualityComparer",
+  // logging / diagnostics receivers
+  "Console",
+  "Debug",
+  "Trace",
+  "Logger",
+  "logger",
+  "_logger",
+  "Log"
+]);
+var CSHARP_NON_ESCAPE_METHODS = /* @__PURE__ */ new Set([
+  // string / value derivation
+  "ToString",
+  "ToArray",
+  "ToList",
+  "ToCharArray",
+  "GetHashCode",
+  "Equals",
+  "CompareTo",
+  "Trim",
+  "TrimStart",
+  "TrimEnd",
+  "Substring",
+  "Split",
+  "Join",
+  "Concat",
+  "PadLeft",
+  "PadRight",
+  "ToLower",
+  "ToUpper",
+  "ToLowerInvariant",
+  "ToUpperInvariant",
+  "StartsWith",
+  "EndsWith",
+  "Contains",
+  "IndexOf",
+  "LastIndexOf",
+  "Insert",
+  "Remove",
+  "Normalize",
+  "Append",
+  "AppendLine",
+  "AppendFormat",
+  "TryParse",
+  "Parse",
+  // structured logging (Microsoft.Extensions.Logging, Serilog, NLog, log4net)
+  "LogInformation",
+  "LogWarning",
+  "LogError",
+  "LogDebug",
+  "LogTrace",
+  "LogCritical",
+  "Information",
+  "Warning",
+  "Verbose",
+  "Fatal",
+  "BeginScope",
+  // Collection stores. A value put into a container has not left the program —
+  // the same reasoning that puts Go's `append` in GO_BUILTIN_CALLS. Measured
+  // on the 10 scored Juliet C# families these were 1,296 of the 2,368 escape
+  // rows remaining after the first pass of this gate (#474): `Add` 864,
+  // `AddLast` 432.
+  //
+  // Project methods are deliberately NOT gated, matching the Go gate's rule
+  // that an unknown call must still escape: Juliet's own `BadSink` /
+  // `GoodB2GSink` / `Action` dispatches account for a further 840 rows and are
+  // left alone, because "the callee is defined in this file" is a different
+  // claim needing its own change.
+  "Add",
+  "AddLast",
+  "AddFirst",
+  "AddRange",
+  "TryAdd",
+  "Insert",
+  "Push",
+  "Enqueue"
+]);
+function isCSharpNonEscapeCall(call) {
+  const name2 = call.method_name;
+  const recv = (call.receiver ?? "").split(".").pop() ?? "";
+  if (CSHARP_PURE_STATIC_RECEIVERS.has(recv)) return true;
+  if (CSHARP_NON_ESCAPE_METHODS.has(name2)) return true;
+  return false;
+}
 function isGoNonEscapeCall(call) {
   const name2 = call.method_name;
   const recv = (call.receiver ?? "").split(".").pop() ?? "";
@@ -19611,6 +19887,9 @@ function analyzeInterprocedural(graphOrTypes, callsOrSources, dfgOrSinks, source
         if (graph.ir.meta.language === "go" && isGoNonEscapeCall(call)) {
           continue;
         }
+        if (graph.ir.meta.language === "csharp" && isCSharpNonEscapeCall(call)) {
+          continue;
+        }
         const bashSafeBuiltins = /* @__PURE__ */ new Set([
           "echo",
           "printf",
@@ -27786,7 +28065,8 @@ var LanguageSourcesPass = class {
     }
     if (language === "csharp") {
       additionalSanitizers.push(
-        ...findCSharpFullPathStartsWithGuardSanitizers(code)
+        ...findCSharpFullPathStartsWithGuardSanitizers(code),
+        ...findCSharpEarlyReturnGuardSanitizers(code, language)
       );
     }
     if (language === "java") {
@@ -28443,23 +28723,35 @@ function findCSharpRequestSources(sourceCode, language) {
   const formFileDeclRe = /\bIFormFile\s+([A-Za-z_]\w*)/g;
   const httpRequestReceivers = /* @__PURE__ */ new Set(["Request"]);
   const httpRequestDeclRe = /\b(?:HttpRequest|HttpRequestBase)\??\s+([A-Za-z_]\w*)/g;
+  const streamReaderVars = /* @__PURE__ */ new Set();
+  const streamReaderDeclRe = /\b(?:StreamReader|TextReader|BinaryReader)\??\s+([A-Za-z_]\w*)/g;
+  const dbReaderVars = /* @__PURE__ */ new Set();
+  const dbReaderDeclRe = /\b(?:SqlDataReader|DbDataReader|IDataReader|OdbcDataReader|OleDbDataReader)\??\s+([A-Za-z_]\w*)/g;
   for (const line of lines) {
     const formRe = new RegExp(formFileDeclRe.source, "g");
     let d;
     while ((d = formRe.exec(line)) !== null) formFileParams.add(d[1]);
     const reqRe = new RegExp(httpRequestDeclRe.source, "g");
     while ((d = reqRe.exec(line)) !== null) httpRequestReceivers.add(d[1]);
+    const srRe = new RegExp(streamReaderDeclRe.source, "g");
+    while ((d = srRe.exec(line)) !== null) streamReaderVars.add(d[1]);
+    const dbRe = new RegExp(dbReaderDeclRe.source, "g");
+    while ((d = dbRe.exec(line)) !== null) dbReaderVars.add(d[1]);
   }
+  const streamReadRe = streamReaderVars.size > 0 ? new RegExp(`\\b(?:${[...streamReaderVars].join("|")})\\s*\\.\\s*(?:ReadLine|ReadToEnd|ReadLineAsync|ReadToEndAsync|ReadBlock|Read)\\s*\\(`) : null;
+  const dbReadRe = dbReaderVars.size > 0 ? new RegExp(`\\b(?:${[...dbReaderVars].join("|")})\\s*\\.\\s*(?:GetString|GetValue|GetInt32|GetInt64|GetDecimal|GetDateTime|GetFieldValue|\\[)`) : null;
   const formFileReadRe = formFileParams.size > 0 ? new RegExp(`\\b(?:${[...formFileParams].join("|")})\\s*\\.\\s*(?:FileName|ContentType)\\b`) : null;
   const requestReadRe = new RegExp(
     `\\b(?:${[...httpRequestReceivers].join("|")})\\s*\\.\\s*(?:Query|Form|Headers|Cookies|QueryString|RouteValues|Body|Files|Params)\\b`
   );
-  const classify = (text) => requestReadRe.test(text) ? "http_param" : formFileReadRe?.test(text) ? "http_param" : consoleReadRe.test(text) ? "io_input" : envReadRe.test(text) ? "env_input" : null;
+  const classify = (text) => requestReadRe.test(text) ? "http_param" : formFileReadRe?.test(text) ? "http_param" : consoleReadRe.test(text) ? "io_input" : envReadRe.test(text) ? "env_input" : streamReadRe?.test(text) ? "io_input" : dbReadRe?.test(text) ? "db_input" : null;
   const inlineReads = [
     [requestReadRe, "http_param"],
     [formFileReadRe, "http_param"],
     [consoleReadRe, "io_input"],
-    [envReadRe, "env_input"]
+    [envReadRe, "env_input"],
+    [streamReadRe, "io_input"],
+    [dbReadRe, "db_input"]
   ];
   const inlineRead = (text) => {
     const argsStart = text.indexOf("(");
@@ -28480,7 +28772,8 @@ function findCSharpRequestSources(sourceCode, language) {
   const embeddedAssignRe = /(?:^|[{;])\s*(?:await\s+)?(?:using\s*\(?\s*)?(?:var\s+|[A-Za-z_][\w.<>\[\]]*\s+)?([A-Za-z_]\w*)\s*=(?!=)\s*([^;{}]+)/;
   for (let i2 = 0; i2 < lines.length; i2++) {
     const m = assignRe.exec(lines[i2]);
-    if (!m) {
+    const rhsCrossesBlock = m !== null && m[2].includes("{");
+    if (!m || rhsCrossesBlock) {
       const stmt = lines[i2];
       if (stmt.includes("{") && !/^\s*(?:\/\/|\/\*|\*)/.test(stmt)) {
         const emb = new RegExp(embeddedAssignRe.source, "g");
@@ -28496,7 +28789,8 @@ function findCSharpRequestSources(sourceCode, language) {
           sources.push({
             type: type3,
             location: `${varName2} = ${rhs2.trim().substring(0, 50)}${rhs2.length > 50 ? "..." : ""}`,
-            severity: "high",
+            // #502 — Java parity: a database row read is medium, I/O is high.
+            severity: type3 === "db_input" ? "medium" : "high",
             line: lineNumber3,
             confidence: 1,
             variable: varName2
@@ -28515,7 +28809,7 @@ function findCSharpRequestSources(sourceCode, language) {
       sources.push({
         type: type2,
         location: `${read} in ${code.substring(0, 50)}${code.length > 50 ? "..." : ""}`,
-        severity: "high",
+        severity: type2 === "db_input" ? "medium" : "high",
         line: lineNumber2,
         confidence: 1,
         variable: "<inline>",
@@ -28531,7 +28825,8 @@ function findCSharpRequestSources(sourceCode, language) {
     sources.push({
       type,
       location: `${varName} = ${rhs.trim().substring(0, 50)}${rhs.length > 50 ? "..." : ""}`,
-      severity: "high",
+      // #502 — Java parity: a database row read is medium, I/O is high.
+      severity: type === "db_input" ? "medium" : "high",
       line: lineNumber,
       confidence: 1,
       variable: varName
@@ -28698,7 +28993,8 @@ function findPythonAssignmentSources(sourceCode, language) {
           sources.push({
             type,
             location: `${varName} = ${rhs.trim().substring(0, 50)}${rhs.length > 50 ? "..." : ""}`,
-            severity: "high",
+            // #502 — Java parity: a database row read is medium, I/O is high.
+            severity: type === "db_input" ? "medium" : "high",
             line: lineNumber,
             confidence: 0.95,
             variable: varName
@@ -30902,6 +31198,66 @@ function guardRejects(lines, i2, terminatorRe, window2) {
   }
   return false;
 }
+function findCSharpEarlyReturnGuardSanitizers(code, language) {
+  if (language !== "csharp") return [];
+  const sanitizers = [];
+  const lines = code.split("\n");
+  const terminatorRe = /\b(throw|return)\b/;
+  const allowlistRes = [
+    /\bif\s*\(\s*Array\s*\.\s*IndexOf\s*\([^,]+,\s*([A-Za-z_][\w.]*)\s*\)\s*<\s*0\s*\)/,
+    /\bif\s*\(\s*!\s*[A-Za-z_][\w.]*\s*\.\s*Contains\s*\(\s*([A-Za-z_][\w.]*)\s*\)\s*\)/
+  ];
+  const charClassRe = /\bif\s*\(\s*!\s*([A-Za-z_][\w.]*)\s*\.\s*All\s*\(\s*char\s*\.\s*Is[A-Za-z]+\s*\)\s*\)/;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    let guardedExpr = null;
+    for (const re of allowlistRes) {
+      const m = re.exec(lines[i2]);
+      if (m) {
+        guardedExpr = m[1];
+        break;
+      }
+    }
+    if (!guardedExpr) {
+      const m = charClassRe.exec(lines[i2]);
+      if (m) guardedExpr = m[1];
+    }
+    if (!guardedExpr) continue;
+    if (!guardRejects(lines, i2, terminatorRe, 6)) continue;
+    const root = guardedExpr.split(".")[0];
+    const guarded = /* @__PURE__ */ new Set([guardedExpr, root]);
+    const assignRe = /^\s*(?:(?:var|string)\s+)?([A-Za-z_]\w*)\s*=(?!=)\s*(.*)$/;
+    for (let b = i2 - 1; b >= 0; b--) {
+      const a = assignRe.exec(lines[b]);
+      if (!a || !guarded.has(a[1])) continue;
+      for (const id of a[2].match(/[A-Za-z_]\w*/g) ?? []) guarded.add(id);
+    }
+    const mentions = (t) => {
+      for (const n of guarded) if (new RegExp(`\\b${n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`).test(t)) return true;
+      return false;
+    };
+    for (let l = i2 + 1; l < lines.length; l++) {
+      const a = assignRe.exec(lines[l]);
+      if (a && mentions(a[2])) guarded.add(a[1]);
+      if (mentions(lines[l])) {
+        sanitizers.push({
+          type: "csharp_early_return_guard",
+          method: "guard",
+          line: l + 1,
+          sanitizes: [
+            "ssrf",
+            "xpath_injection",
+            "ldap_injection",
+            "path_traversal",
+            "command_injection",
+            "sql_injection",
+            "external_taint_escape"
+          ]
+        });
+      }
+    }
+  }
+  return sanitizers;
+}
 function findCSharpFullPathStartsWithGuardSanitizers(code) {
   const sanitizers = [];
   const lines = code.split("\n");
@@ -37299,6 +37655,53 @@ var LibraryProfileXssGatePass = class {
 };
 
 // src/analysis/passes/taint-propagation-pass.ts
+var CONTAINER_READ_SOURCES = /* @__PURE__ */ new Set(["plugin_param", "config_param"]);
+function makeConstPropVeto(constProp, graph, sources, code) {
+  const lines = typeof code === "string" ? code.split("\n") : [];
+  const selfReassign = /* @__PURE__ */ new Map();
+  const escape = (v) => v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  for (const [line, defs] of graph.defsByLine) {
+    const text = lines[line - 1];
+    if (!text) continue;
+    for (const d of defs) {
+      if (d.kind !== "local" && d.kind !== "param") continue;
+      const v = escape(d.variable);
+      const m = new RegExp(`(?:^|[^\\w.$])${v}\\s*(?:([-+*/%&|^]|<<|>>)=|=(?!=))(.*)$`).exec(text);
+      if (!m) continue;
+      if (m[1] || new RegExp(`(?:^|[^\\w.$])${v}\\b`).test(m[2])) {
+        const arr = selfReassign.get(d.variable) ?? [];
+        arr.push(line);
+        selfReassign.set(d.variable, arr);
+      }
+    }
+  }
+  const reassignedAt = (v, line) => (selfReassign.get(v) ?? []).includes(line);
+  const defAt = (v, line) => {
+    const own = (graph.defsByLine.get(line) ?? []).find((d) => d.variable === v);
+    if (own) return own;
+    const use = (graph.usesByLine.get(line) ?? []).find((u) => u.variable === v && u.def_id != null);
+    return use ? graph.defById.get(use.def_id) : void 0;
+  };
+  return (step, sourceLine, sinkLine) => {
+    const r = isFalsePositive(constProp, step.line, step.variable);
+    if (!r.isFalsePositive) return false;
+    if (r.reason !== "variable_not_tainted") return true;
+    const lo = Math.min(sourceLine, sinkLine);
+    let d = defAt(step.variable, step.line);
+    let selfHops = 0;
+    for (let guard = 0; d && d.line > lo && reassignedAt(d.variable, d.line) && guard < 32; guard++) {
+      const here = d.id;
+      const prior = (graph.usesByLine.get(d.line) ?? []).find((u) => u.variable === d.variable && u.def_id != null && u.def_id !== here);
+      if (!prior) break;
+      selfHops++;
+      d = graph.defById.get(prior.def_id);
+    }
+    if (!d) return true;
+    if (d.line === sourceLine && sources.some((s) => s.line === sourceLine && !CONTAINER_READ_SOURCES.has(s.type))) return false;
+    if (selfHops > 0 && d.line >= lo) return false;
+    return true;
+  };
+}
 var TaintPropagationPass = class {
   name = "taint-propagation";
   category = "security";
@@ -37316,11 +37719,11 @@ var TaintPropagationPass = class {
       return { flows: [] };
     }
     const propagationResult = propagateTaint(graph, sources, sinks, sanitizers);
+    const isVetoed = makeConstPropVeto(constProp, graph, sources, ctx.code);
     const verifiedFlows = propagationResult.flows.filter((flow) => {
       if (constProp.unreachableLines.has(flow.sink.line)) return false;
       for (const step of flow.path) {
-        const fpCheck = isFalsePositive(constProp, step.line, step.variable);
-        if (fpCheck.isFalsePositive) return false;
+        if (isVetoed(step, flow.source.line, flow.sink.line)) return false;
       }
       if (isCorrelatedPredicateFP(constProp, flow)) return false;
       return true;
@@ -37413,7 +37816,7 @@ var TaintPropagationPass = class {
       if (isCorrelatedPredicateFP(constProp, flowForCheck)) continue;
       let isFP = false;
       for (const step of f.path) {
-        if (isFalsePositive(constProp, step.line, step.variable).isFalsePositive) {
+        if (isVetoed(step, f.source_line, f.sink_line)) {
           isFP = true;
           break;
         }
@@ -37436,7 +37839,7 @@ var TaintPropagationPass = class {
       if (isCorrelatedPredicateFP(constProp, flowForCheck)) continue;
       let isFP = false;
       for (const step of f.path) {
-        if (isFalsePositive(constProp, step.line, step.variable).isFalsePositive) {
+        if (isVetoed(step, f.source_line, f.sink_line)) {
           isFP = true;
           break;
         }
@@ -38121,13 +38524,22 @@ function maskStringLiteralsForTokenScan(expr) {
   }
   return out2;
 }
+function argsReferenceTaintedVar(expr, sources) {
+  const codePart = expr.replace(/\$@?"(?:[^"\\]|\\.)*"/g, (lit) => " " + [...lit.matchAll(/\{([^}]*)\}/g)].map((x) => x[1]).join(" ") + " ").replace(/@?"(?:[^"\\]|\\.)*"/g, " ").replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
+  return sources.some(
+    (s) => new RegExp(
+      `(?<![\\p{L}\\p{N}_])${s.variable.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\p{L}\\p{N}_])`,
+      "u"
+    ).test(codePart)
+  );
+}
 function detectExpressionScanFlows(calls, sources, sinks, sanitizers, unreachableLines, tainted, code, language, types) {
   const flows = [];
-  const goFnRanges = language === "go" && types ? types.flatMap((t) => t.methods.map((m) => [m.start_line, m.end_line])) : [];
-  const goFnStart = (line) => {
+  const methodRanges = (langs) => language && langs.includes(language) && types ? types.flatMap((t) => t.methods.map((m) => [m.start_line, m.end_line])) : [];
+  const enclosingStart = (ranges, line) => {
     let best = -1;
     let bestSpan = -1;
-    for (const [start2, end] of goFnRanges) {
+    for (const [start2, end] of ranges) {
       if (line >= start2 && line <= end && end - start2 > bestSpan) {
         best = start2;
         bestSpan = end - start2;
@@ -38135,6 +38547,10 @@ function detectExpressionScanFlows(calls, sources, sinks, sanitizers, unreachabl
     }
     return best;
   };
+  const goFnRanges = methodRanges(["go"]);
+  const goFnStart = (line) => enclosingStart(goFnRanges, line);
+  const csFnRanges = methodRanges(["csharp"]);
+  const csFnStart = (line) => enclosingStart(csFnRanges, line);
   const sourcesWithVar = sources.filter(
     (s) => typeof s.variable === "string" && s.variable.length > 0
   );
@@ -38436,16 +38852,47 @@ function detectExpressionScanFlows(calls, sources, sinks, sanitizers, unreachabl
         if (!m) continue;
         const [, obj, rhs] = m;
         if (known.has(obj)) continue;
-        const codePart = rhs.replace(/\$@?"(?:[^"\\]|\\.)*"/g, (lit) => " " + [...lit.matchAll(/\{([^}]*)\}/g)].map((x) => x[1]).join(" ") + " ").replace(/@?"(?:[^"\\]|\\.)*"/g, " ");
-        const rhsTainted = sourcesWithVar.some(
-          (s) => new RegExp(`(?<![\\p{L}\\p{N}_])${s.variable.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\$&")}(?![\\p{L}\\p{N}_])`, "u").test(codePart)
-        );
-        if (!rhsTainted) continue;
+        if (!argsReferenceTaintedVar(rhs, sourcesWithVar)) continue;
         sourcesWithVar.push({ ...anchor, variable: obj, line: i2 + 1 });
         added = true;
       }
     }
   }
+  const builderSeeds = /* @__PURE__ */ new Set();
+  if (language === "csharp" && typeof code === "string" && sourcesWithVar.length > 0) {
+    const lines = code.split("\n");
+    const builders = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      for (const m of line.matchAll(/\bStringBuilder\s+([\p{L}_][\p{L}\p{N}_]*)/gu)) builders.add(m[1]);
+      for (const m of line.matchAll(/\b([\p{L}_][\p{L}\p{N}_]*)\s*=\s*new\s+StringBuilder\b/gu)) builders.add(m[1]);
+    }
+    if (builders.size > 0) {
+      const appendRe = /([\p{L}_][\p{L}\p{N}_]*)\s*\.\s*(?:Append|AppendLine|AppendFormat|Insert)\s*\(([\s\S]*)/u;
+      const anchor = sourcesWithVar.reduce((a, s) => s.line < a.line ? s : a, sourcesWithVar[0]);
+      let added = true;
+      let guard = 0;
+      while (added && guard < lines.length + 2) {
+        added = false;
+        guard++;
+        const known = new Set(sourcesWithVar.map((s) => s.variable));
+        for (let i2 = 0; i2 < lines.length; i2++) {
+          const m = appendRe.exec(lines[i2]);
+          if (!m) continue;
+          const [, obj, args2] = m;
+          if (!builders.has(obj) || known.has(obj)) continue;
+          const appendFn = csFnStart(i2 + 1);
+          const reachable = sourcesWithVar.filter(
+            (sv) => appendFn === -1 || csFnStart(sv.line) === -1 || csFnStart(sv.line) === appendFn
+          );
+          if (reachable.length > 0 && argsReferenceTaintedVar(args2, reachable)) {
+            sourcesWithVar.push({ ...anchor, variable: obj, line: i2 + 1 });
+            builderSeeds.add(`${obj}@${i2 + 1}`);
+            added = true;
+          }
+        }
+      }
+    }
+  }
   const SIMPLE_IDENT = /^[\p{L}\p{N}_]+$/u;
   const reCache = /* @__PURE__ */ new Map();
   for (const s of sourcesWithVar) {
@@ -38508,6 +38955,11 @@ function detectExpressionScanFlows(calls, sources, sinks, sanitizers, unreachabl
             const sinkFn = goFnStart(sink.line);
             if (srcFn !== -1 && sinkFn !== -1 && srcFn !== sinkFn) continue;
           }
+          if (csFnRanges.length > 0 && builderSeeds.has(`${source.variable}@${source.line}`)) {
+            const srcFn = csFnStart(source.line);
+            const sinkFn = csFnStart(sink.line);
+            if (srcFn !== sinkFn) continue;
+          }
           if (complex) {
             const re = reCache.get(source.variable);
             if (!re || !re.test(expr)) continue;
@@ -40009,6 +40461,7 @@ var VariableShadowingPass = class {
             const outerEntry = declLocals[0];
             for (let i2 = 1; i2 < numDeclLocals; i2++) {
               const inner = declLocals[i2];
+              if (inner.def.line <= outerEntry.def.line) continue;
               if (!isInNestedScope(codeLines, outerEntry.def.line, inner.def.line)) continue;
               const key = `${variable}-${inner.def.line}`;
               if (reported.has(key)) continue;