@sms-florin/mcp-ssrf-scan 0.2.0 → 0.3.0

package/README.md

@@ -59,6 +59,24 @@ Exit code is `1` if any `HIGH` finding is reported, `0` otherwise:
 
 `--json` prints findings as JSON instead of the human-readable list.
 
+`--sarif` prints SARIF 2.1.0 for code-scanning UIs. Secret findings are tagged
+OWASP MCP01 (Token Mismanagement & Secret Exposure) and exec findings MCP05
+(Command Injection & Execution). The OWASP MCP Top 10 has no SSRF entry, so
+the SSRF rule carries no OWASP tag.
+
+### GitLab CI component
+
+```yaml
+include:
+  - component: gitlab.com/florin-builds/mcp-ssrf-scan/scan@~latest
+    inputs:
+      path: ./src
+```
+
+Inputs: `stage` (default `test`), `path` (default `.`), `node_image` (default
+`node:22-alpine`). The job fails on any HIGH finding and keeps
+`mcp-ssrf-scan.sarif` as an artifact.
+
 ## mcp-ssrf-scan Cloud (optional, paid)
 
 The CLI above is free and stays free. [mcp-ssrf-scan Cloud](https://mcpscan.flo-voice1.com)

package/dist/cli.js

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { toSarif } from "./sarif.js";
 import { scanDirectory } from "./scan.js";
 const COLOR = {
     high: "\x1b[31m", // red
@@ -32,6 +34,8 @@ finding as "go read this function," not as a confirmed bug.
 
 Options:
   --json              Print findings as JSON instead of the human-readable list
+  --sarif             Print findings as SARIF 2.1.0 (GitHub/GitLab code scanning,
+                      VS Code); rules carry OWASP MCP Top 10 tags where one fits
   --upload            Upload this scan to mcp-ssrf-scan Cloud (needs MCP_SSRF_SCAN_KEY)
                       and print what's new/fixed since the last scan of this repo
   --repo owner/name   Repo name for --upload (auto-detected in GitHub Actions,
@@ -121,9 +125,14 @@ async function main() {
     const valueFlags = new Set(["--repo"]);
     const target = args.find((a, i) => !a.startsWith("-") && !valueFlags.has(args[i - 1])) ?? ".";
     const asJson = args.includes("--json");
+    const asSarif = args.includes("--sarif");
     const findings = scanDirectory(target);
     const hasHigh = findings.some((f) => f.severity === "high");
-    if (asJson) {
+    if (asSarif) {
+        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        console.log(JSON.stringify(toSarif(findings, pkg.version), null, 2));
+    }
+    else if (asJson) {
         console.log(JSON.stringify({ target, findings }, null, 2));
     }
     else {

package/dist/sarif.d.ts

@@ -0,0 +1,44 @@
+import type { Finding } from "./scan.js";
+export declare function toSarif(findings: Finding[], version: string): {
+    $schema: string;
+    version: string;
+    runs: {
+        tool: {
+            driver: {
+                name: string;
+                version: string;
+                informationUri: string;
+                rules: {
+                    id: "ssrf" | "secret" | "exec-injection";
+                    name: string;
+                    shortDescription: {
+                        text: string;
+                    };
+                    properties: {
+                        tags: string[];
+                    };
+                }[];
+            };
+        };
+        results: {
+            ruleId: "ssrf" | "secret" | "exec-injection";
+            level: string;
+            message: {
+                text: string;
+            };
+            locations: {
+                physicalLocation: {
+                    artifactLocation: {
+                        uri: string;
+                    };
+                    region: {
+                        startLine: number;
+                        snippet: {
+                            text: string;
+                        };
+                    };
+                };
+            }[];
+        }[];
+    }[];
+};

package/dist/sarif.js

@@ -0,0 +1,55 @@
+// OWASP MCP Top 10 (2025) has no SSRF entry, so that rule is left unmapped
+// rather than forced into a category it doesn't belong to.
+const RULES = {
+    ssrf: {
+        name: "McpToolSsrf",
+        description: "Outbound request in a tool handler uses a caller-controlled URL with no host/IP validation.",
+    },
+    secret: {
+        name: "HardcodedSecret",
+        description: "Hardcoded credential or API key in source.",
+        owasp: "MCP01:2025 Token Mismanagement & Secret Exposure",
+    },
+    "exec-injection": {
+        name: "ExecInjection",
+        description: "exec()/Function() call next to a template literal, possible command injection.",
+        owasp: "MCP05:2025 Command Injection & Execution",
+    },
+};
+const LEVEL = { high: "error", medium: "warning", info: "note" };
+export function toSarif(findings, version) {
+    return {
+        $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+        version: "2.1.0",
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: "mcp-ssrf-scan",
+                        version,
+                        informationUri: "https://gitlab.com/florin-builds/mcp-ssrf-scan",
+                        rules: Object.keys(RULES).map((id) => ({
+                            id,
+                            name: RULES[id].name,
+                            shortDescription: { text: RULES[id].description },
+                            properties: RULES[id].owasp ? { tags: ["security", RULES[id].owasp] } : { tags: ["security"] },
+                        })),
+                    },
+                },
+                results: findings.map((f) => ({
+                    ruleId: f.rule,
+                    level: LEVEL[f.severity],
+                    message: { text: f.message },
+                    locations: [
+                        {
+                            physicalLocation: {
+                                artifactLocation: { uri: f.file },
+                                region: { startLine: f.line, snippet: { text: f.snippet } },
+                            },
+                        },
+                    ],
+                })),
+            },
+        ],
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sms-florin/mcp-ssrf-scan",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A static scanner for MCP servers that catches the exact bug class behind most real MCP SSRF reports: a tool handler making an outbound request to a caller-controlled URL with no host validation.",
   "type": "module",
   "bin": {