praxis-sec 1.0.0

package/cli/agents/sbom-generator.js

@@ -0,0 +1,265 @@
+/**
+ * SBOM Generator
+ * ===============
+ *
+ * Generates Software Bill of Materials in CycloneDX JSON format.
+ * Parses package.json, requirements.txt, Gemfile, go.mod, etc.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+export class SBOMGenerator {
+  /**
+   * Generate a CycloneDX 1.5 SBOM from the project.
+   *
+   * @param {string} rootPath — Project root directory
+   * @returns {object} — CycloneDX JSON object
+   */
+  generate(rootPath) {
+    const components = [];
+
+    // ── npm/yarn/pnpm ─────────────────────────────────────────────────────────
+    const pkgPath = path.join(rootPath, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+        for (const [name, version] of Object.entries(allDeps)) {
+          components.push({
+            type: 'library',
+            name,
+            version: version.replace(/^[\^~>=<]/, ''),
+            purl: `pkg:npm/${name.replace('/', '%2F')}@${version.replace(/^[\^~>=<]/, '')}`,
+            scope: pkg.dependencies?.[name] ? 'required' : 'optional',
+          });
+        }
+      } catch { /* skip */ }
+    }
+
+    // ── Python requirements.txt ───────────────────────────────────────────────
+    const reqPath = path.join(rootPath, 'requirements.txt');
+    if (fs.existsSync(reqPath)) {
+      try {
+        const lines = fs.readFileSync(reqPath, 'utf-8').split('\n');
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith('#')) continue;
+          const match = trimmed.match(/^([a-zA-Z0-9_-]+)(?:==|>=|~=)?(.+)?$/);
+          if (match) {
+            components.push({
+              type: 'library',
+              name: match[1],
+              version: match[2] || 'unspecified',
+              purl: `pkg:pypi/${match[1]}@${match[2] || 'latest'}`,
+              scope: 'required',
+            });
+          }
+        }
+      } catch { /* skip */ }
+    }
+
+    // ── Go modules ────────────────────────────────────────────────────────────
+    const goModPath = path.join(rootPath, 'go.mod');
+    if (fs.existsSync(goModPath)) {
+      try {
+        const content = fs.readFileSync(goModPath, 'utf-8');
+        const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/);
+        if (requireBlock) {
+          const lines = requireBlock[1].split('\n');
+          for (const line of lines) {
+            const match = line.trim().match(/^(\S+)\s+v?(\S+)/);
+            if (match) {
+              components.push({
+                type: 'library',
+                name: match[1],
+                version: match[2],
+                purl: `pkg:golang/${match[1]}@${match[2]}`,
+                scope: 'required',
+              });
+            }
+          }
+        }
+      } catch { /* skip */ }
+    }
+
+    // ── Rust Cargo.toml ───────────────────────────────────────────────────────
+    const cargoPath = path.join(rootPath, 'Cargo.toml');
+    if (fs.existsSync(cargoPath)) {
+      try {
+        const content = fs.readFileSync(cargoPath, 'utf-8');
+        const depsSection = content.match(/\[dependencies\]([\s\S]*?)(?:\[|$)/);
+        if (depsSection) {
+          const lines = depsSection[1].split('\n');
+          for (const line of lines) {
+            const match = line.trim().match(/^([a-zA-Z0-9_-]+)\s*=\s*"([^"]+)"/);
+            if (match) {
+              components.push({
+                type: 'library',
+                name: match[1],
+                version: match[2],
+                purl: `pkg:cargo/${match[1]}@${match[2]}`,
+                scope: 'required',
+              });
+            }
+          }
+        }
+      } catch { /* skip */ }
+    }
+
+    // ── Detect licenses from lock files ─────────────────────────────────────
+    const licenses = this._detectLicenses(rootPath);
+
+    // ── Build CycloneDX BOM (CRA-enhanced) ──────────────────────────────────
+    const projectMeta = this.getProjectMetadata(rootPath);
+    const bom = {
+      bomFormat: 'CycloneDX',
+      specVersion: '1.5',
+      serialNumber: `urn:uuid:${this.uuid()}`,
+      version: 1,
+      metadata: {
+        timestamp: new Date().toISOString(),
+        tools: [{
+          vendor: 'praxis',
+          name: 'praxis',
+          version: '1.0.0',
+        }],
+        component: projectMeta,
+        // EU CRA: supplier identification
+        supplier: this._getSupplier(rootPath),
+        // EU CRA: lifecycle phase
+        lifecycles: [{ phase: 'build' }],
+      },
+      components: components.map((c, i) => {
+        const comp = {
+          'bom-ref': `component-${i}`,
+          type: c.type,
+          name: c.name,
+          version: c.version,
+          purl: c.purl,
+          scope: c.scope,
+        };
+        // EU CRA: attach license if known
+        const lic = licenses[c.name];
+        if (lic) {
+          comp.licenses = [{ license: { id: lic } }];
+        }
+        return comp;
+      }),
+      // EU CRA: vulnerability disclosure info
+      vulnerabilities: [],
+    };
+
+    return bom;
+  }
+
+  /**
+   * Attach known vulnerabilities to the SBOM (CRA requirement).
+   */
+  attachVulnerabilities(bom, depVulns = []) {
+    bom.vulnerabilities = depVulns.map((v, i) => ({
+      'bom-ref': `vuln-${i}`,
+      id: v.id || v.package || `VULN-${i}`,
+      source: { name: 'praxis' },
+      ratings: [{
+        severity: v.severity || 'unknown',
+        method: 'other',
+      }],
+      description: v.description || '',
+      affects: [{
+        ref: v.package || 'unknown',
+      }],
+    }));
+    return bom;
+  }
+
+  /**
+   * Generate SBOM and write to file.
+   */
+  generateToFile(rootPath, outputPath, format = 'cyclonedx') {
+    const bom = this.generate(rootPath);
+    const output = JSON.stringify(bom, null, 2);
+    fs.writeFileSync(outputPath, output);
+    return outputPath;
+  }
+
+  getProjectMetadata(rootPath) {
+    const pkgPath = path.join(rootPath, 'package.json');
+    try {
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return {
+          type: 'application',
+          name: pkg.name || path.basename(rootPath),
+          version: pkg.version || '0.0.0',
+        };
+      }
+    } catch { /* skip */ }
+    return {
+      type: 'application',
+      name: path.basename(rootPath),
+      version: '0.0.0',
+    };
+  }
+
+  /**
+   * EU CRA: Extract supplier info from package.json.
+   */
+  _getSupplier(rootPath) {
+    const pkgPath = path.join(rootPath, 'package.json');
+    try {
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        const author = typeof pkg.author === 'string' ? pkg.author
+          : pkg.author?.name || pkg.author?.email || null;
+        if (author) {
+          return { name: author, url: [pkg.homepage || pkg.repository?.url || ''].filter(Boolean) };
+        }
+      }
+    } catch { /* skip */ }
+    return { name: 'Unknown' };
+  }
+
+  /**
+   * Detect licenses from node_modules (best-effort).
+   * Returns { packageName: 'MIT' | 'ISC' | ... }
+   */
+  _detectLicenses(rootPath) {
+    const licenses = {};
+    const nodeModules = path.join(rootPath, 'node_modules');
+    const pkgPath = path.join(rootPath, 'package.json');
+
+    if (!fs.existsSync(pkgPath)) return licenses;
+
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+
+      for (const name of Object.keys(allDeps)) {
+        const depPkgPath = path.join(nodeModules, name, 'package.json');
+        try {
+          if (fs.existsSync(depPkgPath)) {
+            const depPkg = JSON.parse(fs.readFileSync(depPkgPath, 'utf-8'));
+            if (depPkg.license) {
+              licenses[name] = typeof depPkg.license === 'string'
+                ? depPkg.license
+                : depPkg.license.type || 'UNKNOWN';
+            }
+          }
+        } catch { /* skip */ }
+      }
+    } catch { /* skip */ }
+
+    return licenses;
+  }
+
+  uuid() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+      const r = Math.random() * 16 | 0;
+      return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+  }
+}
+
+export default SBOMGenerator;

package/cli/agents/scoring-engine.js

@@ -0,0 +1,273 @@
+/**
+ * Enhanced Scoring Engine
+ * ========================
+ *
+ * Risk-based scoring with 8 categories, EPSS integration,
+ * KEV flagging, and historical trend tracking.
+ *
+ * Score = 100 - sum(category deductions)
+ * Each category has a weight and max deduction cap.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { getComplianceSummary, getAgenticSummary, enrichAgenticRisk } from '../utils/compliance-map.js';
+import { mapFindingToStandards, getStandardsSummary } from '../utils/standards/index.js';
+
+// =============================================================================
+// SCORING CONFIGURATION
+// =============================================================================
+
+// Weights aligned with OWASP Top 10 2025:
+//   A01 Broken Access Control (auth: 15), A02 Security Misconfiguration (config: 8),
+//   A03 Software Supply Chain Failures (supply-chain: 12, deps: 13),
+//   A05 Injection (injection: 15), A07 Auth Failures (secrets: 15),
+//   A10 Mishandling of Exceptional Conditions (→ injection category)
+//   + API Security (10), AI/LLM Security (12) — weights sum to 100
+const CATEGORIES = {
+  secrets:       { weight: 15, label: 'Secrets',                deductions: { critical: 25, high: 15, medium: 5 } },
+  injection:     { weight: 15, label: 'Code Vulnerabilities',   deductions: { critical: 20, high: 10, medium: 3 } },
+  deps:          { weight: 13, label: 'Dependencies',           deductions: { critical: 20, high: 10, medium: 5, moderate: 5 } },
+  auth:          { weight: 15, label: 'Auth & Access Control',  deductions: { critical: 20, high: 10, medium: 3 } },
+  config:        { weight: 8,  label: 'Configuration',          deductions: { critical: 15, high: 8,  medium: 3 } },
+  'supply-chain':{ weight: 12, label: 'Supply Chain',           deductions: { critical: 15, high: 8,  medium: 3 } },
+  api:           { weight: 10, label: 'API Security',           deductions: { critical: 15, high: 8,  medium: 3 } },
+  llm:           { weight: 12, label: 'AI/LLM Security',       deductions: { critical: 15, high: 8,  medium: 3 } },
+};
+
+// Fallback categories for findings that don't match a known category
+const FALLBACK_CATEGORY_MAP = {
+  'secret': 'secrets',
+  'vulnerability': 'injection',
+  'ssrf': 'injection',        // OWASP 2025: SSRF merged into A01 Broken Access Control
+  'history': 'secrets',
+  'cicd': 'config',
+  'mobile': 'injection',
+  'privacy': 'config',
+  'mcp': 'llm',
+  'agentic': 'llm',
+  'rag': 'llm',
+  'vibe': 'injection',        // Vibe coding findings → Code Vulnerabilities
+  'exception': 'injection',   // OWASP A10:2025 — Mishandling of Exceptional Conditions
+  'agent-config': 'llm',      // Agent config security → AI/LLM category
+  'memory-poisoning': 'llm',  // Memory poisoning → AI/LLM category
+  'recon': null,               // skip recon findings
+};
+
+const GRADES = [  { min: 90, letter: 'A', label: 'Ship it!',                    color: 'green' },
+  { min: 75, letter: 'B', label: 'Minor issues to review',       color: 'cyan' },
+  { min: 60, letter: 'C', label: 'Fix before shipping',          color: 'yellow' },
+  { min: 40, letter: 'D', label: 'Significant security risks',   color: 'red' },
+  { min: 0,  letter: 'F', label: 'Not safe to ship',             color: 'red' },
+];
+
+// =============================================================================
+// SCORING ENGINE
+// =============================================================================
+
+export class ScoringEngine {
+  /**
+   * Compute the security score from agent findings + dependency vulnerabilities.
+   *
+   * @param {object[]} findings   — Array of finding objects from agents
+   * @param {object[]} depVulns   — Array of dependency CVE objects
+   * @returns {object}            — { score, grade, categories, breakdown }
+   */
+  compute(findings = [], depVulns = []) {
+    const categoryResults = {};
+
+    // Initialize all categories
+    for (const [key, config] of Object.entries(CATEGORIES)) {
+      categoryResults[key] = {
+        label: config.label,
+        weight: config.weight,
+        counts: { critical: 0, high: 0, medium: 0, low: 0 },
+        deduction: 0,
+        maxDeduction: config.weight, // Cap at category weight
+        findings: [],
+      };
+    }
+
+    // ── Enrich findings with OWASP Agentic AI Top 10 metadata ──────────────
+    for (const finding of findings) {
+      enrichAgenticRisk(finding);
+      finding.standards = mapFindingToStandards(finding);
+    }
+
+    // ── Classify findings into categories ─────────────────────────────────────
+    for (const finding of findings) {
+      const cat = this.resolveCategory(finding.category);
+      if (!cat || !categoryResults[cat]) continue;
+
+      const sev = finding.severity || 'medium';
+      categoryResults[cat].counts[sev] = (categoryResults[cat].counts[sev] || 0) + 1;
+      categoryResults[cat].findings.push(finding);
+    }
+
+    // ── Add dependency vulnerabilities ────────────────────────────────────────
+    for (const vuln of depVulns) {
+      const sev = vuln.severity || 'medium';
+      categoryResults.deps.counts[sev] = (categoryResults.deps.counts[sev] || 0) + 1;
+    }
+
+    // ── Compute deductions per category (confidence-weighted) ─────────────────
+    const CONFIDENCE_MULTIPLIER = { high: 1.0, medium: 0.6, low: 0.3 };
+
+    for (const [key, config] of Object.entries(CATEGORIES)) {
+      const result = categoryResults[key];
+      let deduction = 0;
+
+      // Count-based deductions for deps (no per-finding confidence)
+      for (const [sev, pts] of Object.entries(config.deductions)) {
+        if (key === 'deps') {
+          deduction += (result.counts[sev] || 0) * pts;
+        }
+      }
+
+      // Per-finding confidence-weighted deductions for agent findings
+      if (key !== 'deps') {
+        for (const finding of result.findings) {
+          const sev = finding.severity || 'medium';
+          const pts = config.deductions[sev] || 0;
+          const confidence = finding.confidence || 'high';
+          const multiplier = CONFIDENCE_MULTIPLIER[confidence] || 1.0;
+          deduction += pts * multiplier;
+        }
+      }
+
+      result.deduction = Math.min(deduction, result.maxDeduction);
+    }
+
+    // ── Compute total score ───────────────────────────────────────────────────
+    const totalDeduction = Object.values(categoryResults).reduce(
+      (sum, r) => sum + r.deduction, 0
+    );
+    const score = Math.max(0, 100 - totalDeduction);
+    const grade = GRADES.find(g => score >= g.min);
+
+    // ── Compliance mapping ─────────────────────────────────────────────────
+    let compliance;
+    try {
+      compliance = getComplianceSummary(findings);
+    } catch {
+      compliance = null;
+    }
+
+    // ── OWASP Agentic AI Top 10 summary ──────────────────────────────────
+    let agenticSummary;
+    try {
+      agenticSummary = getAgenticSummary(findings);
+    } catch {
+      agenticSummary = null;
+    }
+
+    // ── AI security standards summary (OWASP LLM, ATLAS, NIST AI 600-1, ...)
+    let standardsSummary;
+    try {
+      standardsSummary = getStandardsSummary(findings);
+    } catch {
+      standardsSummary = null;
+    }
+
+    return {
+      score,
+      grade,
+      categories: categoryResults,
+      totalFindings: findings.length,
+      totalDepVulns: depVulns.length,
+      compliance,
+      agenticSummary,
+      standardsSummary,
+    };
+  }
+
+  /**
+   * Map a finding category to a scoring category.
+   */
+  resolveCategory(findingCategory) {
+    if (CATEGORIES[findingCategory]) return findingCategory;
+    if (FALLBACK_CATEGORY_MAP[findingCategory] !== undefined) {
+      return FALLBACK_CATEGORY_MAP[findingCategory];
+    }
+    return 'injection'; // default fallback
+  }
+
+  /**
+   * Save score to history file for trend tracking.
+   */
+  saveToHistory(rootPath, scoreResult, suppressions = null) {
+    const historyDir = path.join(rootPath, '.praxis');
+    const historyFile = path.join(historyDir, 'history.json');
+
+    try {
+      if (!fs.existsSync(historyDir)) {
+        fs.mkdirSync(historyDir, { recursive: true });
+      }
+
+      let history = [];
+      if (fs.existsSync(historyFile)) {
+        try {
+          history = JSON.parse(fs.readFileSync(historyFile, 'utf-8'));
+        } catch { history = []; }
+      }
+
+      const entry = {
+        timestamp: new Date().toISOString(),
+        score: scoreResult.score,
+        grade: scoreResult.grade.letter,
+        totalFindings: scoreResult.totalFindings,
+        totalDepVulns: scoreResult.totalDepVulns,
+        categoryScores: Object.fromEntries(
+          Object.entries(scoreResult.categories).map(([k, v]) => [k, {
+            deduction: v.deduction,
+            counts: v.counts,
+          }])
+        ),
+      };
+      if (suppressions) entry.suppressions = suppressions;
+      history.push(entry);
+
+      // Keep last 100 entries
+      if (history.length > 100) history = history.slice(-100);
+
+      fs.writeFileSync(historyFile, JSON.stringify(history, null, 2));
+    } catch {
+      // Don't fail if history save fails
+    }
+  }
+
+  /**
+   * Load score history for trend display.
+   */
+  loadHistory(rootPath) {
+    const historyFile = path.join(rootPath, '.praxis', 'history.json');
+    try {
+      if (fs.existsSync(historyFile)) {
+        return JSON.parse(fs.readFileSync(historyFile, 'utf-8'));
+      }
+    } catch { /* ignore */ }
+    return [];
+  }
+
+  /**
+   * Get trend summary comparing current to last scan.
+   */
+  getTrend(rootPath, currentScore) {
+    const history = this.loadHistory(rootPath);
+    if (history.length < 2) return null;
+
+    const previous = history[history.length - 2];
+    const diff = currentScore - previous.score;
+
+    return {
+      previousScore: previous.score,
+      currentScore,
+      diff,
+      direction: diff > 0 ? 'improved' : diff < 0 ? 'regressed' : 'unchanged',
+      previousDate: previous.timestamp,
+    };
+  }
+}
+
+export { GRADES, CATEGORIES, FALLBACK_CATEGORY_MAP };
+export default ScoringEngine;

package/cli/agents/ssrf-prober.js

@@ -0,0 +1,130 @@
+/**
+ * SSRFProber Agent
+ * =================
+ *
+ * Detects Server-Side Request Forgery vulnerabilities.
+ * The fastest-growing attack vector (452% surge in 2025).
+ *
+ * Checks: user input in URL construction, webhook validation,
+ * cloud metadata access, DNS rebinding, protocol smuggling.
+ */
+
+import path from 'path';
+import { BaseAgent } from './base-agent.js';
+
+export const PATTERNS = [
+  {
+    rule: 'SSRF_USER_URL_FETCH',
+    title: 'SSRF: User Input in fetch()',
+    regex: /fetch\s*\(\s*(?:req\.|request\.|ctx\.|query|params|body|input|url|data)/g,
+    severity: 'critical',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    description: 'User-controlled URL passed to fetch() enables SSRF. Validate against an allowlist.',
+    fix: 'Validate URL against allowlist: new URL(input).hostname must match allowed hosts',
+  },
+  {
+    rule: 'SSRF_USER_URL_AXIOS',
+    title: 'SSRF: User Input in axios/got/http',
+    regex: /(?:axios|got|http|https|request|superagent|node-fetch|undici)(?:\.get|\.post|\.put|\.delete|\.request|\s*\()\s*\(\s*(?:req\.|request\.|ctx\.|query|params|body|input|url|data)/g,
+    severity: 'critical',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    description: 'User-supplied URL in HTTP client enables SSRF. Validate and restrict to public IPs.',
+    fix: 'Parse URL, block private IPs (127.0.0.1, 10.x, 172.16-31.x, 169.254.x), block file:// protocol',
+  },
+  {
+    rule: 'SSRF_URL_TEMPLATE',
+    title: 'SSRF: Template Literal in URL',
+    regex: /(?:fetch|axios|got|http\.get|https\.get)\s*\(\s*`[^`]*\$\{(?:req\.|request\.|ctx\.|query|params|body|input)/g,
+    severity: 'critical',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    description: 'User input interpolated into URL for HTTP request enables SSRF.',
+    fix: 'Validate and sanitize the URL before making the request',
+  },
+  {
+    rule: 'SSRF_WEBHOOK_URL',
+    title: 'SSRF: Unvalidated Webhook URL',
+    regex: /webhook[_-]?url\s*[:=]\s*(?:req\.|request\.|ctx\.|body|query|params|input)/gi,
+    severity: 'high',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    description: 'Accepting user-supplied webhook URLs without validation enables SSRF.',
+    fix: 'Validate webhook URL: must be HTTPS, public IP, not cloud metadata endpoint',
+  },
+  {
+    rule: 'SSRF_CLOUD_METADATA',
+    title: 'SSRF: Cloud Metadata Endpoint Access',
+    regex: /169\.254\.169\.254|metadata\.google\.internal|100\.100\.100\.200/g,
+    severity: 'critical',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    description: 'Cloud metadata endpoint in code. If URL is user-controlled, this enables credential theft.',
+    fix: 'Block metadata IPs in URL validation. Use IMDSv2 on AWS (requires token header).',
+  },
+  {
+    rule: 'SSRF_INTERNAL_IP',
+    title: 'SSRF: Internal IP Pattern',
+    regex: /(?:127\.0\.0\.|0\.0\.0\.0|10\.\d+\.\d+\.\d+|172\.(?:1[6-9]|2\d|3[01])\.\d+\.\d+|192\.168\.)\d+/g,
+    severity: 'medium',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    confidence: 'low',
+    description: 'Internal IP address in code. Verify it is not reachable via user-controlled URLs.',
+    fix: 'Block private IP ranges in URL validation for user-supplied URLs',
+  },
+  {
+    rule: 'SSRF_REDIRECT_FOLLOW',
+    title: 'SSRF: HTTP Client Follows Redirects',
+    regex: /(?:follow|maxRedirects|redirect)\s*:\s*(?:true|\d{2,})/g,
+    severity: 'medium',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    confidence: 'low',
+    description: 'Following redirects can bypass SSRF protections (redirect to internal IP).',
+    fix: 'Disable redirect following or re-validate the redirect target URL',
+  },
+  {
+    rule: 'SSRF_PYTHON_REQUESTS',
+    title: 'SSRF: Python requests with User Input',
+    regex: /requests\.(?:get|post|put|delete|head|patch)\s*\(\s*(?:request\.|flask\.|data|args|form)/g,
+    severity: 'critical',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    description: 'User-controlled URL in Python requests enables SSRF.',
+    fix: 'Validate URL scheme (https only), resolve DNS and check against private IP ranges',
+  },
+  {
+    rule: 'SSRF_IMAGE_PROXY',
+    title: 'SSRF: Image/Proxy URL from User Input',
+    regex: /(?:imageUrl|image_url|proxyUrl|proxy_url|avatarUrl|avatar_url|iconUrl|icon_url)\s*[:=]\s*(?:req\.|request\.|query|params|body)/gi,
+    severity: 'high',
+    cwe: 'CWE-918',
+    owasp: 'A10:2021',
+    description: 'Image/proxy URLs from user input are common SSRF vectors.',
+    fix: 'Validate URL, restrict to known CDN domains, or use an image proxy service',
+  },
+];
+
+export class SSRFProber extends BaseAgent {
+  constructor() {
+    super('SSRFProber', 'Detect Server-Side Request Forgery vulnerabilities', 'ssrf');
+  }
+
+  async analyze(context) {
+    const { files } = context;
+    const codeFiles = files.filter(f => {
+      const ext = path.extname(f).toLowerCase();
+      return ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.py', '.rb', '.php', '.go'].includes(ext);
+    });
+
+    let findings = [];
+    for (const file of codeFiles) {
+      findings = findings.concat(this.scanFileWithPatterns(file, PATTERNS));
+    }
+    return findings;
+  }
+}
+
+export default SSRFProber;