agent-security-scanner-mcp 3.0.0 → 3.2.0

package/rules/python/flask/security/injection/flask-injection-sinks.yaml

@@ -0,0 +1,352 @@
+rules:
+# Flask SQL Injection - Direct Execution
+- id: flask-sql-injection-execute
+  message: >-
+    SQL Injection vulnerability detected. User input from Flask request flows
+    directly to database query execution. An attacker could manipulate the query
+    to access, modify, or delete data. Use parameterized queries instead:
+    cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))
+  metadata:
+    cwe:
+    - 'CWE-89: SQL Injection'
+    owasp:
+    - A03:2021 - Injection
+    - A05:2025 - Injection
+    category: security
+    technology:
+    - flask
+    - sqlite3
+    - mysql
+    - postgresql
+    subcategory:
+    - vuln
+    impact: HIGH
+    likelihood: HIGH
+    confidence: HIGH
+    fix: |
+      Use parameterized queries:
+      cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))
+  severity: ERROR
+  languages:
+  - python
+  mode: taint
+  pattern-sources:
+  - patterns:
+    - pattern-either:
+      - pattern: request.args.get(...)
+      - pattern: request.args[...]
+      - pattern: request.form.get(...)
+      - pattern: request.form[...]
+      - pattern: request.json
+      - pattern: request.json.get(...)
+      - pattern: request.json[...]
+      - pattern: request.data
+      - pattern: request.values.get(...)
+      - pattern: request.values[...]
+      - pattern: request.cookies.get(...)
+      - pattern: request.headers.get(...)
+      - pattern: flask.request.args.get(...)
+      - pattern: flask.request.form[...]
+      - pattern: flask.request.json
+  pattern-sinks:
+  - patterns:
+    - pattern-either:
+      - pattern: $CURSOR.execute(...)
+      - pattern: $CURSOR.executemany(...)
+      - pattern: $CONN.execute(...)
+      - pattern: $DB.execute(...)
+      - pattern: $SESSION.execute(...)
+  pattern-sanitizers:
+  - patterns:
+    - pattern-either:
+      - pattern: $CURSOR.execute($QUERY, (...))
+      - pattern: $CURSOR.execute($QUERY, [...])
+
+# Flask Command Injection - os.system
+- id: flask-command-injection-system
+  message: >-
+    Command Injection vulnerability detected. User input from Flask request flows
+    to os.system() which executes shell commands. An attacker could execute arbitrary
+    system commands. Use subprocess with shell=False and argument lists instead.
+  metadata:
+    cwe:
+    - 'CWE-78: OS Command Injection'
+    owasp:
+    - A03:2021 - Injection
+    - A05:2025 - Injection
+    category: security
+    technology:
+    - flask
+    subcategory:
+    - vuln
+    impact: CRITICAL
+    likelihood: HIGH
+    confidence: HIGH
+    fix: |
+      Use subprocess with shell=False:
+      subprocess.run(['ping', '-c', '1', host], shell=False)
+  severity: ERROR
+  languages:
+  - python
+  mode: taint
+  pattern-sources:
+  - patterns:
+    - pattern-either:
+      - pattern: request.args.get(...)
+      - pattern: request.args[...]
+      - pattern: request.form.get(...)
+      - pattern: request.form[...]
+      - pattern: request.json
+      - pattern: request.json.get(...)
+      - pattern: request.json[...]
+      - pattern: flask.request.args.get(...)
+      - pattern: flask.request.form[...]
+  pattern-sinks:
+  - patterns:
+    - pattern-either:
+      - pattern: os.system(...)
+      - pattern: os.popen(...)
+      - pattern: os.spawn(...)
+      - pattern: os.spawnl(...)
+      - pattern: os.spawnle(...)
+      - pattern: os.spawnlp(...)
+      - pattern: os.spawnlpe(...)
+      - pattern: os.spawnv(...)
+      - pattern: os.spawnve(...)
+      - pattern: os.spawnvp(...)
+      - pattern: os.spawnvpe(...)
+  pattern-sanitizers:
+  - patterns:
+    - pattern-either:
+      - pattern: shlex.quote(...)
+      - pattern: shlex.split(...)
+
+# Flask Command Injection - subprocess
+- id: flask-command-injection-subprocess
+  message: >-
+    Command Injection vulnerability detected. User input from Flask request flows
+    to subprocess with shell=True. An attacker could execute arbitrary system commands.
+    Use subprocess with shell=False and pass arguments as a list.
+  metadata:
+    cwe:
+    - 'CWE-78: OS Command Injection'
+    owasp:
+    - A03:2021 - Injection
+    - A05:2025 - Injection
+    category: security
+    technology:
+    - flask
+    subcategory:
+    - vuln
+    impact: CRITICAL
+    likelihood: HIGH
+    confidence: HIGH
+    fix: |
+      Use subprocess with shell=False:
+      subprocess.run(['command', arg1, arg2], shell=False)
+  severity: ERROR
+  languages:
+  - python
+  mode: taint
+  pattern-sources:
+  - patterns:
+    - pattern-either:
+      - pattern: request.args.get(...)
+      - pattern: request.form[...]
+      - pattern: request.json
+      - pattern: request.json[...]
+      - pattern: flask.request.args.get(...)
+  pattern-sinks:
+  - patterns:
+    - pattern-either:
+      - pattern: subprocess.call(..., shell=True, ...)
+      - pattern: subprocess.run(..., shell=True, ...)
+      - pattern: subprocess.Popen(..., shell=True, ...)
+      - pattern: subprocess.check_output(..., shell=True, ...)
+      - pattern: subprocess.check_call(..., shell=True, ...)
+  pattern-sanitizers:
+  - patterns:
+    - pattern: shlex.quote(...)
+
+# Flask Path Traversal
+- id: flask-path-traversal
+  message: >-
+    Path Traversal vulnerability detected. User input from Flask request is used
+    in file operations without validation. An attacker could access files outside
+    the intended directory using '../' sequences. Validate and sanitize file paths.
+  metadata:
+    cwe:
+    - 'CWE-22: Path Traversal'
+    owasp:
+    - A01:2021 - Broken Access Control
+    - A01:2025 - Broken Access Control
+    category: security
+    technology:
+    - flask
+    subcategory:
+    - vuln
+    impact: HIGH
+    likelihood: MEDIUM
+    confidence: HIGH
+    fix: |
+      Use secure_filename and validate paths:
+      from werkzeug.utils import secure_filename
+      filename = secure_filename(user_input)
+      safe_path = os.path.join(base_dir, filename)
+      if not safe_path.startswith(base_dir):
+          abort(403)
+  severity: ERROR
+  languages:
+  - python
+  mode: taint
+  pattern-sources:
+  - patterns:
+    - pattern-either:
+      - pattern: request.args.get(...)
+      - pattern: request.form[...]
+      - pattern: request.json[...]
+      - pattern: flask.request.args.get(...)
+  pattern-sinks:
+  - patterns:
+    - pattern-either:
+      - pattern: open(...)
+      - pattern: os.path.join(...)
+      - pattern: pathlib.Path(...)
+      - pattern: send_file(...)
+      - pattern: send_from_directory(...)
+  pattern-sanitizers:
+  - patterns:
+    - pattern-either:
+      - pattern: secure_filename(...)
+      - pattern: os.path.basename(...)
+
+# Flask XSS via Template Injection
+- id: flask-template-injection
+  message: >-
+    Server-Side Template Injection (SSTI) vulnerability detected. User input flows
+    to render_template_string() which can execute arbitrary Python code. Use
+    render_template() with separate template files and proper escaping instead.
+  metadata:
+    cwe:
+    - 'CWE-79: Cross-site Scripting'
+    - 'CWE-94: Code Injection'
+    owasp:
+    - A03:2021 - Injection
+    - A05:2025 - Injection
+    category: security
+    technology:
+    - flask
+    - jinja2
+    subcategory:
+    - vuln
+    impact: CRITICAL
+    likelihood: HIGH
+    confidence: HIGH
+    fix: |
+      Use render_template with separate files:
+      return render_template('greeting.html', name=name)
+      # In greeting.html: <h1>Hello, {{ name }}!</h1>
+  severity: ERROR
+  languages:
+  - python
+  mode: taint
+  pattern-sources:
+  - patterns:
+    - pattern-either:
+      - pattern: request.args.get(...)
+      - pattern: request.form[...]
+      - pattern: request.json[...]
+      - pattern: flask.request.args.get(...)
+  pattern-sinks:
+  - patterns:
+    - pattern-either:
+      - pattern: render_template_string(...)
+      - pattern: flask.render_template_string(...)
+      - pattern: jinja2.Template(...).render(...)
+
+# Flask Insecure Deserialization
+- id: flask-insecure-deserialization
+  message: >-
+    Insecure deserialization vulnerability detected. User input flows to pickle.loads()
+    which can execute arbitrary code. Never deserialize untrusted data with pickle.
+    Use JSON or other safe serialization formats.
+  metadata:
+    cwe:
+    - 'CWE-502: Deserialization of Untrusted Data'
+    owasp:
+    - A08:2021 - Software and Data Integrity Failures
+    - A08:2025 - Software or Data Integrity Failures
+    category: security
+    technology:
+    - flask
+    subcategory:
+    - vuln
+    impact: CRITICAL
+    likelihood: MEDIUM
+    confidence: HIGH
+    fix: |
+      Use JSON instead of pickle:
+      data = json.loads(user_input)
+  severity: ERROR
+  languages:
+  - python
+  mode: taint
+  pattern-sources:
+  - patterns:
+    - pattern-either:
+      - pattern: request.data
+      - pattern: request.get_data(...)
+      - pattern: request.json
+      - pattern: flask.request.data
+  pattern-sinks:
+  - patterns:
+    - pattern-either:
+      - pattern: pickle.loads(...)
+      - pattern: pickle.load(...)
+      - pattern: yaml.load(...)
+      - pattern: yaml.unsafe_load(...)
+  pattern-sanitizers:
+  - patterns:
+    - pattern: yaml.safe_load(...)
+
+# Flask Eval Injection
+- id: flask-eval-injection
+  message: >-
+    Code injection vulnerability detected. User input flows to eval() or exec()
+    which can execute arbitrary Python code. Never use eval/exec with user input.
+  metadata:
+    cwe:
+    - 'CWE-94: Code Injection'
+    owasp:
+    - A03:2021 - Injection
+    - A05:2025 - Injection
+    category: security
+    technology:
+    - flask
+    subcategory:
+    - vuln
+    impact: CRITICAL
+    likelihood: HIGH
+    confidence: HIGH
+    fix: |
+      Avoid eval/exec entirely. Use safer alternatives like:
+      - ast.literal_eval() for simple data structures
+      - JSON parsing for data exchange
+  severity: ERROR
+  languages:
+  - python
+  mode: taint
+  pattern-sources:
+  - patterns:
+    - pattern-either:
+      - pattern: request.args.get(...)
+      - pattern: request.form[...]
+      - pattern: request.json[...]
+      - pattern: request.data
+      - pattern: flask.request.args.get(...)
+  pattern-sinks:
+  - patterns:
+    - pattern-either:
+      - pattern: eval(...)
+      - pattern: exec(...)
+      - pattern: compile(...)

package/src/analyzer.py

@@ -0,0 +1,119 @@
+import sys
+import json
+import re
+import os
+
+# Add the directory containing this script to the path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from rules import get_rules, get_rules_for_language, get_rule_stats
+
+# File extension to language mapping
+EXTENSION_MAP = {
+    '.py': 'python',
+    '.js': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.jsx': 'javascript',
+    '.java': 'java',
+    '.go': 'go',
+    '.rb': 'ruby',
+    '.php': 'php',
+    '.cs': 'csharp',
+    '.rs': 'rust',
+    '.c': 'c',
+    '.cpp': 'cpp',
+    '.h': 'c',
+    '.hpp': 'cpp',
+    '.sql': 'sql',
+    '.dockerfile': 'dockerfile',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.json': 'json',
+    '.tf': 'terraform',
+    '.hcl': 'terraform',
+}
+
+def detect_language(file_path):
+    """Detect the programming language from file extension or name"""
+    basename = os.path.basename(file_path).lower()
+    
+    if basename == 'dockerfile' or basename.startswith('dockerfile.') or basename.startswith('dockerfile_'):
+        return 'dockerfile'
+    
+    _, ext = os.path.splitext(file_path.lower())
+    return EXTENSION_MAP.get(ext, 'generic')
+
+def analyze_file(file_path):
+    """Analyze a single file for security vulnerabilities"""
+    issues = []
+    
+    try:
+        language = detect_language(file_path)
+        rules = get_rules_for_language(language)
+        
+        with open(file_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+            content = ''.join(lines)
+        
+        for line_index, line in enumerate(lines):
+            original_line = line
+            line = line.strip()
+            if not line:
+                continue
+            
+            # Skip comment-only lines (basic detection)
+            if line.startswith('#') or line.startswith('//') or line.startswith('*'):
+                continue
+                
+            for rule_id, rule in rules.items():
+                for pattern in rule['patterns']:
+                    try:
+                        # Use IGNORECASE for better detection (API_KEY vs api_key)
+                        matches = re.finditer(pattern, line, re.IGNORECASE)
+                        for match in matches:
+                            # Calculate column based on original line (preserve indentation)
+                            col_offset = len(original_line) - len(original_line.lstrip())
+                            issues.append({
+                                'ruleId': rule['id'],
+                                'message': f"[{rule['name']}] {rule['message']}",
+                                'line': line_index,
+                                'column': match.start() + col_offset,
+                                'length': match.end() - match.start(),
+                                'severity': rule['severity'],
+                                'metadata': rule.get('metadata', {})
+                            })
+                    except re.error:
+                        # Skip invalid regex patterns
+                        continue
+                        
+    except Exception as e:
+        return {'error': str(e)}
+    
+    # Deduplicate issues (same rule, same line)
+    seen = set()
+    unique_issues = []
+    for issue in issues:
+        key = (issue['ruleId'], issue['line'], issue['column'])
+        if key not in seen:
+            seen.add(key)
+            unique_issues.append(issue)
+        
+    return unique_issues
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({'error': 'No file path provided'}))
+        sys.exit(1)
+        
+    file_path = sys.argv[1]
+    
+    if not os.path.exists(file_path):
+        print(json.dumps({'error': f'File not found: {file_path}'}))
+        sys.exit(1)
+        
+    results = analyze_file(file_path)
+    print(json.dumps(results))
+
+if __name__ == '__main__':
+    main()

package/src/cli/demo.js

@@ -0,0 +1,238 @@
+import { execFileSync } from "child_process";
+import { writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { createInterface } from "readline";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+
+// Handle both ESM and CJS bundling (Smithery bundles to CJS)
+let __dirname;
+try {
+  __dirname = dirname(fileURLToPath(import.meta.url));
+} catch {
+  __dirname = process.cwd();
+}
+
+const DEMO_TEMPLATES = {
+  js: {
+    ext: 'js',
+    name: 'JavaScript',
+    code: `const express = require("express");
+const child_process = require("child_process");
+const app = express();
+
+// SQL Injection vulnerability
+app.get("/user", (req, res) => {
+  const userId = req.query.id;
+  db.query("SELECT * FROM users WHERE id = " + userId, (err, result) => {
+    res.send(result);
+  });
+});
+
+// XSS vulnerability
+app.get("/profile", (req, res) => {
+  const name = req.query.name;
+  document.getElementById("welcome").innerHTML = name;
+});
+
+// Command Injection vulnerability
+app.get("/run", (req, res) => {
+  const cmd = req.query.cmd;
+  child_process.exec("ls " + cmd, (err, stdout) => {
+    res.send(stdout);
+  });
+});
+`
+  },
+  py: {
+    ext: 'py',
+    name: 'Python',
+    code: `import pickle
+import subprocess
+import hashlib
+
+API_SECRET = "stripe_test_FAKEFAKEFAKEFAKE1234"
+
+def get_user(user_id):
+    query = f"SELECT * FROM users WHERE id = {user_id}"
+    cursor.execute(query)
+    return cursor.fetchone()
+
+def load_data(data):
+    return pickle.loads(data)
+
+def run_command(cmd):
+    return subprocess.call(cmd, shell=True)
+
+def hash_password(password):
+    return hashlib.md5(password.encode()).hexdigest()
+`
+  },
+  go: {
+    ext: 'go',
+    name: 'Go',
+    code: `package main
+
+import (
+\t"crypto/md5"
+\t"database/sql"
+\t"fmt"
+\t"net/http"
+\t"os/exec"
+)
+
+var dbPassword = "super_secret_password_123"
+
+func getUser(w http.ResponseWriter, r *http.Request) {
+\tid := r.URL.Query().Get("id")
+\tquery := fmt.Sprintf("SELECT * FROM users WHERE id = %s", id)
+\tdb.Query(query)
+}
+
+func runCmd(w http.ResponseWriter, r *http.Request) {
+\tcmd := r.URL.Query().Get("cmd")
+\tout, _ := exec.Command("sh", "-c", cmd).Output()
+\tw.Write(out)
+}
+
+func hashData(data string) string {
+\th := md5.Sum([]byte(data))
+\treturn fmt.Sprintf("%x", h)
+}
+`
+  },
+  java: {
+    ext: 'java',
+    name: 'Java',
+    code: `import java.sql.*;
+import java.io.*;
+import java.security.MessageDigest;
+
+public class VulnDemo {
+    private static final String DB_PASSWORD = "admin123";
+
+    public ResultSet getUser(String userId) throws SQLException {
+        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/db");
+        Statement stmt = conn.createStatement();
+        return stmt.executeQuery("SELECT * FROM users WHERE id = " + userId);
+    }
+
+    public String runCommand(String cmd) throws IOException {
+        Runtime rt = Runtime.getRuntime();
+        Process proc = rt.exec(cmd);
+        BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
+        return reader.readLine();
+    }
+
+    public String hashPassword(String password) throws Exception {
+        MessageDigest md = MessageDigest.getInstance("MD5");
+        byte[] hash = md.digest(password.getBytes());
+        return new String(hash);
+    }
+}
+`
+  }
+};
+
+function parseDemoFlags(args) {
+  const flags = { lang: 'js' };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if ((arg === '--lang' || arg === '-l') && i + 1 < args.length) {
+      flags.lang = args[++i].toLowerCase();
+    } else if (!arg.startsWith('-')) {
+      flags.lang = arg.toLowerCase();
+    }
+    i++;
+  }
+  return flags;
+}
+
+function checkCommand(cmd, args) {
+  try {
+    const out = execFileSync(cmd, args, { timeout: 10000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+    return { ok: true, output: out.trim() };
+  } catch {
+    return { ok: false, output: null };
+  }
+}
+
+export async function runDemo(args) {
+  const flags = parseDemoFlags(args);
+  const template = DEMO_TEMPLATES[flags.lang];
+  if (!template) {
+    console.log(`\n  Unknown language: "${flags.lang}"`);
+    console.log(`  Available: ${Object.keys(DEMO_TEMPLATES).join(', ')}\n`);
+    process.exit(1);
+  }
+
+  const filename = `vuln-demo.${template.ext}`;
+  const filepath = join(process.cwd(), filename);
+
+  console.log(`\n  agent-security-scanner-mcp demo\n`);
+  console.log(`  Creating ${filename} with 3 intentional vulnerabilities...\n`);
+
+  // Write the vulnerable file
+  writeFileSync(filepath, template.code);
+
+  // Run the analyzer
+  const analyzerPath = join(__dirname, '..', '..', 'analyzer.py');
+  let pythonCmd = 'python3';
+  const py3 = checkCommand('python3', ['--version']);
+  if (!py3.ok) {
+    const py = checkCommand('python', ['--version']);
+    if (py.ok && py.output.includes('3.')) {
+      pythonCmd = 'python';
+    } else {
+      console.log(`  Error: Python 3 not found. Run "npx agent-security-scanner-mcp doctor" to diagnose.\n`);
+      unlinkSync(filepath);
+      process.exit(1);
+    }
+  }
+
+  let results;
+  try {
+    const output = execFileSync(pythonCmd, [analyzerPath, filepath], { timeout: 30000, encoding: 'utf-8' });
+    results = JSON.parse(output);
+  } catch (e) {
+    console.log(`  Error running analyzer: ${e.message}\n`);
+    unlinkSync(filepath);
+    process.exit(1);
+  }
+
+  // Display results
+  console.log(`  Scanning...\n`);
+
+  if (results.length === 0) {
+    console.log(`  No issues found (unexpected for demo file).\n`);
+  } else {
+    console.log(`  Found ${results.length} issue(s):\n`);
+    for (const issue of results) {
+      const severity = (issue.severity || 'error').toUpperCase();
+      const icon = severity === 'ERROR' ? '\u2717' : severity === 'WARNING' ? '\u2717' : '\u2022';
+      console.log(`    ${icon} ${severity.padEnd(8)} Line ${String(issue.line).padEnd(4)} ${issue.message}`);
+      if (issue.metadata) {
+        const refs = [issue.metadata.cwe, issue.metadata.owasp].filter(Boolean).join(' | ');
+        if (refs) console.log(`      ${refs}`);
+      }
+    }
+    console.log(`\n  ${results.length} vulnerabilities detected.\n`);
+  }
+
+  // Ask to keep or delete
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question(`  Keep ${filename} for testing? (y/N): `, (a) => { rl.close(); resolve(a); });
+  });
+
+  if (answer.toLowerCase() === 'y') {
+    console.log(`\n  Kept: ${filepath}`);
+  } else {
+    unlinkSync(filepath);
+    console.log(`\n  Deleted: ${filename}`);
+  }
+
+  console.log(`\n  Next: Connect to your AI coding tool and ask it to`);
+  console.log(`  "scan ${filename} for security issues"\n`);
+}