agent-security-scanner-mcp 3.2.0 → 3.4.0

package/src/dedup.js

@@ -0,0 +1,129 @@
+// Cross-engine deduplication for security findings.
+// When AST and regex engines flag the same vulnerability on the same line
+// with different ruleIds, this module merges them into a single finding.
+
+// Maps ruleId substrings to vulnerability classes for cross-engine dedup.
+// Order matters: more specific patterns must come before generic ones.
+const VULN_CLASS_PATTERNS = [
+  // XSS variants
+  ['innerhtml', 'xss-innerhtml'],
+  ['outerhtml', 'xss-outerhtml'],
+  ['document-write', 'xss-document-write'],
+  ['document.write', 'xss-document-write'],
+  ['insertadjacenthtml', 'xss-insertadjacenthtml'],
+  ['dangerouslysetinnerhtml', 'xss-dangerouslysetinnerhtml'],
+  ['mustache-escape', 'xss-innerhtml'],
+  ['insecure-document-method', 'xss-document-write'],
+  ['dom-based-xss', 'xss-dom'],
+  ['xss-echo', 'xss-echo'],
+  ['xss-raw', 'xss-raw'],
+  ['xss-response-write', 'xss-response-write'],
+
+  // SQL Injection
+  ['sql-injection', 'sqli'],
+  ['nosql-injection', 'nosqli'],
+
+  // Command Injection
+  ['child-process-exec', 'cmdi-exec'],
+  ['spawn-shell', 'cmdi-spawn'],
+  ['dangerous-subprocess', 'cmdi-subprocess'],
+  ['dangerous-system-call', 'cmdi-system'],
+  ['command-injection', 'cmdi'],
+  ['backticks-exec', 'cmdi-backticks'],
+  ['libc-system-call', 'cmdi-libc'],
+
+  // Code Injection
+  ['eval-detected', 'code-eval'],
+  ['eval-usage', 'code-eval'],
+  ['exec-detected', 'code-exec'],
+  ['function-constructor', 'code-function-constructor'],
+
+  // Deserialization
+  ['pickle-load', 'deser-pickle'],
+  ['unsafe-unserialize', 'deser-unserialize'],
+  ['unsafe-yaml-load', 'deser-yaml'],
+  ['yaml-load', 'deser-yaml'],
+  ['unsafe-marshal', 'deser-marshal'],
+  ['insecure-deserialization', 'deser'],
+
+  // Crypto
+  ['md5', 'weak-hash-md5'],
+  ['sha1', 'weak-hash-sha1'],
+  ['insecure-hash', 'weak-hash'],
+  ['weak-hash', 'weak-hash'],
+  ['weak-cipher', 'weak-cipher'],
+
+  // Secrets
+  ['hardcoded-password', 'hardcoded-password'],
+  ['hardcoded-secret', 'hardcoded-secret'],
+  ['hardcoded-api-key', 'hardcoded-api-key'],
+  ['hardcoded-connection-string', 'hardcoded-connection-string'],
+
+  // Path traversal
+  ['path-traversal', 'path-traversal'],
+
+  // SSL
+  ['ssl-verify-disabled', 'ssl-verify-disabled'],
+
+  // Random
+  ['insecure-random', 'insecure-random'],
+  ['weak-random', 'weak-random'],
+];
+
+// Engine priority (higher = more trusted analysis)
+const ENGINE_PRIORITY = {
+  'taint': 3,
+  'ast': 2,
+  'regex': 1,
+  'regex-fallback': 0,
+};
+
+const SEVERITY_ORDER = { error: 3, warning: 2, info: 1 };
+
+export function classifyFinding(ruleId) {
+  const lower = ruleId.toLowerCase();
+  for (const [pattern, vulnClass] of VULN_CLASS_PATTERNS) {
+    if (lower.includes(pattern)) return vulnClass;
+  }
+  return lower;
+}
+
+export function deduplicateFindings(findings) {
+  if (!Array.isArray(findings)) return findings;
+
+  // Group by (vulnClass, line)
+  const groups = new Map();
+  for (const finding of findings) {
+    const vulnClass = classifyFinding(finding.ruleId);
+    const key = `${vulnClass}:${finding.line}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(finding);
+  }
+
+  const deduped = [];
+  for (const group of groups.values()) {
+    if (group.length === 1) {
+      deduped.push(group[0]);
+      continue;
+    }
+
+    // Sort by engine priority (highest first)
+    group.sort((a, b) =>
+      (ENGINE_PRIORITY[b.engine] || 0) - (ENGINE_PRIORITY[a.engine] || 0)
+    );
+
+    const best = { ...group[0] };
+
+    // Preserve highest severity across group
+    for (const f of group) {
+      if ((SEVERITY_ORDER[f.severity] || 0) > (SEVERITY_ORDER[best.severity] || 0)) {
+        best.severity = f.severity;
+      }
+    }
+
+    best.engines_matched = [...new Set(group.map(f => f.engine))];
+    deduped.push(best);
+  }
+
+  return deduped;
+}

package/src/fix-patterns.js

@@ -63,20 +63,56 @@ export const FIX_TEMPLATES = {
   // COMMAND INJECTION
   // ===========================================
   "child-process-exec": {
-    description: "Use execFile() or spawn() with shell: false",
-    fix: (line) => line.replace(/\bexec\s*\(/, 'execFile(')
+    description: "Use execFile() with separate command and arguments array",
+    fix: (line) => {
+      // Match: exec("cmd " + arg) -> execFile("cmd", [arg])
+      const concatMatch = line.match(/\bexec\s*\(\s*["'](\S+)\s+["']\s*\+\s*(\w+)/);
+      if (concatMatch) {
+        return line.replace(/\bexec\s*\(\s*["'](\S+)\s+["']\s*\+\s*(\w+)\s*\)/, 'execFile("$1", [$2])');
+      }
+      // Match: exec(`cmd ${arg}`) -> execFile("cmd", [arg])
+      const templateMatch = line.match(/\bexec\s*\(\s*`(\S+)\s+\$\{(\w+)\}`/);
+      if (templateMatch) {
+        return line.replace(/\bexec\s*\(\s*`(\S+)\s+\$\{(\w+)\}`\s*\)/, 'execFile("$1", [$2])');
+      }
+      // Match: exec(variable) -> execFile with guidance
+      const varMatch = line.match(/\bexec\s*\(\s*(\w+)\s*\)/);
+      if (varMatch) {
+        return line.replace(/\bexec\s*\(\s*(\w+)\s*\)/, 'execFile($1.split(" ")[0], $1.split(" ").slice(1))');
+      }
+      // Fallback: comment with guidance
+      return '// SECURITY: Use execFile(command, [args]) instead of exec() - ' + line.trim();
+    }
   },
   "spawn-shell": {
     description: "Use spawn with shell: false",
     fix: (line) => line.replace(/shell\s*:\s*true/i, 'shell: false')
   },
   "dangerous-subprocess": {
-    description: "Use subprocess.run with list arguments",
-    fix: (line) => line.replace(/subprocess\.(call|run|Popen)\s*\(\s*["'](.+?)["']\s*,\s*shell\s*=\s*True/, 'subprocess.$1(["$2".split()], shell=False')
+    description: "Use subprocess.run with list arguments and shell=False",
+    fix: (line) => {
+      // Replace shell=True with shell=False
+      let fixed = line.replace(/shell\s*=\s*True/, 'shell=False');
+      // Replace string command with shlex.split() for safe list form
+      fixed = fixed.replace(
+        /subprocess\.(call|run|Popen)\s*\(\s*["'](.+?)["']/,
+        'subprocess.$1(shlex.split("$2")'
+      );
+      return fixed;
+    }
   },
   "dangerous-system-call": {
     description: "Use subprocess.run instead of os.system",
-    fix: (line) => line.replace(/os\.system\s*\(/, 'subprocess.run([')
+    fix: (line) => {
+      const match = line.match(/os\.system\s*\(\s*(.+?)\s*\)/);
+      if (match) {
+        return line.replace(
+          /os\.system\s*\(\s*(.+?)\s*\)/,
+          'subprocess.run(shlex.split($1), shell=False)'
+        );
+      }
+      return '# SECURITY: Replace os.system() with subprocess.run(shlex.split(cmd), shell=False)\n# ' + line.trim();
+    }
   },
   "command-injection-exec": {
     description: "Use exec.Command with separate arguments",
@@ -197,8 +233,11 @@ export const FIX_TEMPLATES = {
   // INSECURE DESERIALIZATION
   // ===========================================
   "pickle": {
-    description: "Use JSON instead of pickle",
-    fix: (line) => line.replace(/pickle\.(load|loads)\s*\(/, 'json.$1(')
+    description: "Use JSON instead of pickle for untrusted data",
+    fix: (line) => {
+      const fixed = line.replace(/pickle\.(load|loads)\s*\(/, 'json.$1(');
+      return fixed + '  # NOTE: data must be JSON-formatted';
+    }
   },
   "yaml-load": {
     description: "Use yaml.safe_load()",
@@ -209,8 +248,8 @@ export const FIX_TEMPLATES = {
     fix: (line) => line.replace(/marshal\.(load|loads)\s*\(/, 'json.$1(')
   },
   "shelve": {
-    description: "Use JSON or SQLite instead of shelve",
-    fix: (line) => line.replace(/shelve\.open\s*\(/, 'json.load(open(')
+    description: "Use JSON or SQLite instead of shelve for safe storage",
+    fix: (line) => '# SECURITY: Replace shelve with json or sqlite3 for safe storage\n# ' + line.trim()
   },
   "node-serialize": {
     description: "Use JSON.parse instead of node-serialize",
@@ -257,12 +296,12 @@ export const FIX_TEMPLATES = {
   // PATH TRAVERSAL
   // ===========================================
   "path-traversal": {
-    description: "Sanitize file paths and use basename",
+    description: "Resolve real path and validate prefix to prevent traversal",
     fix: (line, lang) => {
-      if (lang === 'python') return line.replace(/open\s*\(\s*(\w+)/, 'open(os.path.basename($1)');
-      if (lang === 'go') return line.replace(/os\.Open\s*\(\s*(\w+)/, 'os.Open(filepath.Base($1)');
-      if (lang === 'java') return line.replace(/new File\s*\(\s*(\w+)/, 'new File(new File($1).getName()');
-      return line.replace(/readFileSync\s*\(\s*(\w+)/, 'readFileSync(path.basename($1)');
+      if (lang === 'python') return line.replace(/open\s*\(\s*(\w+)/, 'open(os.path.realpath($1)  # TODO: validate path prefix');
+      if (lang === 'go') return line.replace(/os\.Open\s*\(\s*(\w+)/, 'os.Open(filepath.Clean($1)  // TODO: validate path prefix');
+      if (lang === 'java') return line.replace(/new File\s*\(\s*(\w+)/, 'new File($1).getCanonicalFile(  // TODO: validate path prefix');
+      return line.replace(/readFileSync\s*\(\s*(\w+)/, 'readFileSync(path.resolve($1)  // TODO: validate path prefix');
     }
   },
 
@@ -407,7 +446,14 @@ export const FIX_TEMPLATES = {
   // ===========================================
   "prototype-pollution": {
     description: "Validate object keys before assignment",
-    fix: (line) => line.replace(/(\w+)\[(\w+)\]\s*=/, 'if (!["__proto__", "constructor", "prototype"].includes($2)) $1[$2] =')
+    fix: (line) => {
+      // Only fix simple single-line assignments like: obj[key] = value
+      // Reject lines with multiple bracket accesses or chained assignments
+      if (/^\s*\w+\[\w+\]\s*=\s*[^[=]+$/.test(line)) {
+        return line.replace(/(\w+)\[(\w+)\]\s*=/, 'if (!["__proto__", "constructor", "prototype"].includes($2)) $1[$2] =');
+      }
+      return '// SECURITY: Validate key is not __proto__/constructor/prototype before assignment\n// ' + line.trim();
+    }
   },
 
   // ===========================================
@@ -443,7 +489,7 @@ export const FIX_TEMPLATES = {
   // ===========================================
   "helmet-missing": {
     description: "Add helmet middleware for security headers",
-    fix: (line) => 'app.use(helmet()); // Add security headers\n' + line
+    fix: (line) => '// TODO: Add app.use(helmet()) after Express app initialization\n' + line
   },
 
   // ===========================================
@@ -495,7 +541,10 @@ export const FIX_TEMPLATES = {
   },
   "run-shell-form": {
     description: "Use exec form for RUN commands",
-    fix: (line) => line.replace(/RUN\s+(.+)$/, 'RUN ["/bin/sh", "-c", "$1"]')
+    fix: (line) => line.replace(/RUN\s+(.+)$/, (_, cmd) => {
+      const escaped = cmd.replace(/"/g, '\\"');
+      return `RUN ["/bin/sh", "-c", "${escaped}"]`;
+    })
   },
   "sudo-in-dockerfile": {
     description: "Avoid sudo in Dockerfile - use USER directive",

package/src/tools/fix-security.js

@@ -2,6 +2,9 @@
 import { z } from "zod";
 import { existsSync, readFileSync } from "fs";
 import { detectLanguage, runAnalyzer, generateFix } from '../utils.js';
+import { deduplicateFindings } from '../dedup.js';
+import { applyContextFilter, detectFrameworks, applyFrameworkAdjustments } from '../context.js';
+import { loadConfig, shouldExcludeFile, applyConfig } from '../config.js';
 
 export const fixSecuritySchema = {
   file_path: z.string().describe("Path to the file to fix"),
@@ -47,24 +50,48 @@ export async function fixSecurity({ file_path, verbosity }) {
     };
   }
 
-  const issues = runAnalyzer(file_path);
+  // Load project configuration
+  const config = loadConfig(file_path);
 
-  if (issues.error || !Array.isArray(issues) || issues.length === 0) {
+  // Check file exclusion
+  if (shouldExcludeFile(file_path, config)) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ file: file_path, message: "File excluded by configuration", fixes_applied: 0 }) }]
+    };
+  }
+
+  const rawIssues = runAnalyzer(file_path);
+
+  if (rawIssues.error || !Array.isArray(rawIssues) || rawIssues.length === 0) {
     return {
       content: [{
         type: "text",
         text: JSON.stringify({
-          message: issues.error ? "Error scanning file" : "No security issues found",
-          details: issues
+          message: rawIssues.error ? "Error scanning file" : "No security issues found",
+          details: rawIssues
         })
       }]
     };
   }
 
+  // Cross-engine deduplication
+  const dedupedIssues = deduplicateFindings(rawIssues);
+
   // Read and fix the file
   const content = readFileSync(file_path, 'utf-8');
   const lines = content.split('\n');
   const language = detectLanguage(file_path);
+
+  // Context-aware filtering (suppress known module imports)
+  const contextFiltered = applyContextFilter(dedupedIssues, file_path, language);
+
+  // Framework-aware severity adjustment
+  const frameworks = detectFrameworks(file_path, language);
+  const frameworkAdjusted = applyFrameworkAdjustments(contextFiltered, frameworks);
+
+  // Apply .scannerrc configuration (rule suppression, severity/confidence thresholds)
+  const issues = applyConfig(frameworkAdjusted, file_path, config);
+
   const fixes = [];
 
   // Apply fixes (process in reverse order to preserve line numbers)

package/src/tools/scan-diff.js

@@ -0,0 +1,151 @@
+// src/tools/scan-diff.js
+import { z } from "zod";
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { scanSecurity } from './scan-security.js';
+
+export const scanDiffSchema = {
+  base_ref: z.string().optional().describe("Base git ref (default: HEAD~1)"),
+  target_ref: z.string().optional().describe("Target git ref (default: HEAD)"),
+  verbosity: z.enum(['minimal', 'compact', 'full']).optional().describe("Response detail level")
+};
+
+// Parse unified diff output to extract changed files and line ranges
+function parseDiffOutput(diffOutput) {
+  const changes = new Map(); // filePath -> Set<lineNumber>
+  let currentFile = null;
+
+  for (const line of diffOutput.split('\n')) {
+    // Match diff header: +++ b/path/to/file
+    const fileMatch = line.match(/^\+\+\+ b\/(.+)$/);
+    if (fileMatch) {
+      currentFile = fileMatch[1];
+      if (!changes.has(currentFile)) {
+        changes.set(currentFile, new Set());
+      }
+      continue;
+    }
+
+    // Match hunk header: @@ -old,count +new,count @@
+    const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch && currentFile) {
+      const start = parseInt(hunkMatch[1], 10);
+      const count = parseInt(hunkMatch[2] || '1', 10);
+      const fileChanges = changes.get(currentFile);
+      for (let i = start; i < start + count; i++) {
+        fileChanges.add(i);
+      }
+    }
+  }
+
+  return changes;
+}
+
+export async function scanDiff({ base_ref, target_ref, verbosity }) {
+  const base = base_ref || 'HEAD~1';
+  const target = target_ref || 'HEAD';
+
+  // Get diff output
+  let diffOutput;
+  try {
+    diffOutput = execFileSync('git', ['diff', '--unified=0', `${base}...${target}`], {
+      encoding: 'utf-8',
+      timeout: 30000,
+      maxBuffer: 10 * 1024 * 1024
+    });
+  } catch (err) {
+    // Try without three-dot notation (for uncommitted changes)
+    try {
+      diffOutput = execFileSync('git', ['diff', '--unified=0', base, target], {
+        encoding: 'utf-8',
+        timeout: 30000,
+        maxBuffer: 10 * 1024 * 1024
+      });
+    } catch (err2) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: `Git diff failed: ${err2.message}` }) }]
+      };
+    }
+  }
+
+  if (!diffOutput.trim()) {
+    return {
+      content: [{ type: "text", text: JSON.stringify({ message: "No changes found between refs", base, target, issues_count: 0 }) }]
+    };
+  }
+
+  // Parse diff to get changed files and lines
+  const changes = parseDiffOutput(diffOutput);
+  const allIssues = [];
+  const scannedFiles = [];
+
+  // Scan each changed file
+  for (const [filePath, changedLines] of changes) {
+    if (!existsSync(filePath)) continue;
+
+    const result = await scanSecurity({ file_path: filePath, verbosity: 'full' });
+    const parsed = JSON.parse(result.content[0].text);
+
+    if (parsed.issues && Array.isArray(parsed.issues)) {
+      // Filter to only issues on changed lines
+      const diffIssues = parsed.issues.filter(issue => {
+        const issueLine = (issue.line || 0) + 1; // convert 0-indexed to 1-indexed
+        return changedLines.has(issueLine);
+      });
+
+      for (const issue of diffIssues) {
+        allIssues.push({ ...issue, file: filePath });
+      }
+    }
+    scannedFiles.push(filePath);
+  }
+
+  // Format based on verbosity
+  const level = verbosity || 'compact';
+
+  if (level === 'minimal') {
+    const bySeverity = { error: 0, warning: 0, info: 0 };
+    allIssues.forEach(i => bySeverity[i.severity] = (bySeverity[i.severity] || 0) + 1);
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        base, target,
+        files_scanned: scannedFiles.length,
+        total: allIssues.length,
+        critical: bySeverity.error,
+        warning: bySeverity.warning,
+        info: bySeverity.info,
+        message: allIssues.length > 0
+          ? `Found ${allIssues.length} new issue(s) in changed code.`
+          : "No new security issues in changed code."
+      }) }]
+    };
+  }
+
+  if (level === 'compact') {
+    return {
+      content: [{ type: "text", text: JSON.stringify({
+        base, target,
+        files_scanned: scannedFiles.length,
+        issues_count: allIssues.length,
+        issues: allIssues.map(i => ({
+          file: i.file,
+          line: (i.line || 0) + 1,
+          ruleId: i.ruleId,
+          severity: i.severity,
+          message: i.message
+        }))
+      }, null, 2) }]
+    };
+  }
+
+  // full
+  return {
+    content: [{ type: "text", text: JSON.stringify({
+      base, target,
+      files_scanned: scannedFiles.length,
+      issues_count: allIssues.length,
+      issues: allIssues,
+      changed_files: Array.from(changes.keys())
+    }, null, 2) }]
+  };
+}