mason-keller/vulnforge-mcp

🇺🇸 English · 🇰🇷 한국어 · 🇨🇳 中文 · 🇪🇸 Español · 🇮🇳 हिन्दी
🇸🇦 العربية · 🇧🇷 Português · 🇷🇺 Русский · 🇫🇷 Français · 🇮🇩 Bahasa Indonesia

🛡️ VulnForge MCP

Universal AI-Native Web, API, Database, CI/CD, Container/K8s, eBPF & Dynamic API Fuzzing Vulnerability Auditing with Automated Patch Injection MCP Server

_{Architected & Licensed under Proprietary (All Rights Reserved) · Autonomous Security Engineering}

---

⚡ Quickstart & 1-Line Execution

⚡ Quickstart & 1-Line Execution (Click to toggle / 접기·펼치기)

Run VulnForge MCP directly with zero prior installation:

# 1. Start MCP Server over stdio
npx vulnforge-mcp

# 2. Run Built-in Security Audit Demonstration
npx vulnforge-mcp --test-demo

# 3. Direct GraphQL Security Audit CLI Execution
npx vulnforge-mcp --audit-graphql --query "{ users { id posts { comments { author { posts { id } } } } } }"

# 4. Direct Container & Kubernetes Manifest Audit CLI Execution
npx vulnforge-mcp --audit-container --file k8s/deployment.yaml

# 5. Direct eBPF & Runtime Security Policy Audit CLI Execution
npx vulnforge-mcp --audit-ebpf --file policies/tetragon.yaml

# 6. Direct Dynamic API Fuzzing & Mutation Resilience CLI Execution
npx vulnforge-mcp --fuzz-api --file routes/api.ts

# 7. Direct Cloud-Native IAM & Zero Trust Policy Audit CLI Execution
npx vulnforge-mcp --audit-iam --file iam/policy.json

Adding to Claude Desktop / Antigravity (claude_desktop_config.json)

{
  "mcpServers": {
    "vulnforge": {
      "command": "node",
      "args": ["C:/github_nvcxzopgo/vulnforge-mcp/dist/index.js"]
    }
  }
}

---

🏛️ The 11 Vulnerability Auditing Pillars

🏛️ View Architecture Pipeline Diagram (Click to toggle / 접기·펼치기)

#	Pillar Domain	Scope & Target Checks	Automated Patch Output
01	Web & Headers	Content-Security-Policy, HSTS, CORS Wildcards, X-Frame-Options, Cookie Flags	Express/Fastify/Koa security header injection middleware
02	Frontend & DOM	DOM XSS sinks (innerHTML, document.write, eval), Tabnabbing (target="_blank"), SRI hashes	Safe textContent rewriter & rel="noopener noreferrer" attributes
03	API & Endpoints	Broken Object Level Auth (BOLA/IDOR), Unauthenticated mutation routes, Mass assignment	Tenant ownership validators, auth middlewares, Zod DTO parsers
04	Database & SQLi	Raw template string queries, SQL concatenation, MongoDB $where, Credential leaks	Parameterized statements ($1, $2), NoSQL sanitizers, env configs
05	GraphQL & Schemas	Introspection query exposure (__schema, __type), Cyclic query DoS (depth > 5), Batching complexity, Sensitive resolver fields (passwordHash, ssn, apiKey), Debug stack trace disclosure	Disabling introspection in prod (process.env.NODE_ENV !== 'production'), depthLimit(5) validator, error masking, field auth checks
06	CI/CD & Pipelines	Untrusted PR checkouts (pull_request_target), Missing/wildcard permissions, Unpinned action SHAs, Script injection in run:, Leaked tokens & OIDC claims	Minimal permissions: read-all, Safe env bindings, Immutable SHA pinning, Hardened triggers
07	Container & Kubernetes	Dockerfile multi-stage builds, root execution (USER), PodSecurity Standards (restricted), Linux capabilities (drop: [ALL]), read-only root filesystems, privilege escalation, and RBAC wildcard permissions (*)	Multi-stage Dockerfile rewriters, USER 10001:10001 injection, securityContext PSS hardening, and least-privilege RBAC Role bindings
08	eBPF & Runtime Security	Kernel verifier rejection vectors, unbounded loops, NULL map lookup pointers, dangerous write helpers (bpf_probe_write_user), Falco container shell execution rules, and Tetragon Sigkill action policies	#pragma unroll loops, map lookup NULL checks, Falco alert rules, and Tetragon action: Sigkill policy enforcement
09	Dynamic API Fuzzing	Genetic mutation resilience, schema boundary stress, prototype pollution sinks (__proto__), unhandled async errors, and unrestricted request body parser limits	Zod schema validation middlewares, prototype pollution sanitizers, body parser limits, and async error boundaries
10	Cloud-Native IAM & Zero Trust	AWS/GCP/Azure IAM policy wildcards (*, s3:*), resource over-scoping, privilege escalation (iam:PassRole), public trust relationships (Principal: "*"), confused deputy (aws:SourceAccount), and missing TLS/MFA Zero Trust condition guards	Least-privilege action scoping, resource ARN constraints, Zero Trust TLS (aws:SecureTransport: true) enforcement conditions, and role trust boundary hardening

---

🛠️ 13 Core MCP Security Tools

🛠️ 13 Core MCP Security Tools (Click to toggle / 접기·펼치기)

VulnForge MCP exposes 13 specialized security audit tools to your AI agent:

1. vulnforge_audit_web:
   • Analyzes HTTP response headers, cookie flags, and DOM client code.
   • Computes an automated Security Score (0 to 100) and outputs prioritized CWE findings.
2. vulnforge_audit_api:
   • Inspects route definitions (Express, Fastify, Next.js) or OpenAPI specifications.
   • Flags BOLA/IDOR patterns, missing auth middleware, and mass assignment risks.
3. vulnforge_audit_db:
   • Evaluates SQL queries and ORM calls (Sequelize, Prisma, TypeORM, Knex, Mongoose).
   • Identifies raw string concatenation, unescaped interpolations, and NoSQL injection vectors.
4. vulnforge_audit_graphql:
   • Deep inspection of GraphQL schemas, type definitions, resolvers, query payloads, and server configs (Apollo Server, Yoga, Express GraphQL).
   • Detects introspection enabled in production, cyclic nested query DoS, array batching complexity abuse, sensitive resolver fields (passwordHash, ssn, token) lacking auth, and debug stack trace leaks.
   • Produces automated defensive patch suggestions and mitigation strategies.
5. vulnforge_audit_cicd:
   • Static analysis of CI/CD pipeline definitions (GitHub Actions .github/workflows/*.yml and GitLab CI .gitlab-ci.yml).
   • Detects untrusted PR checkouts (pull_request_target with untrusted SHA), missing or wildcard permissions (permissions: write-all), unpinned third-party actions, context expression script injections in run: steps, plaintext tokens/keys, and insecure OIDC trust configurations.
   • Generates automated patch recommendations to enforce least-privilege pipeline policies.
6. vulnforge_audit_container:
   • Static analysis of Dockerfiles and Kubernetes manifests (Deployments, Pods, StatefulSets, DaemonSets, Roles, ClusterRoles).
   • Evaluates multi-stage build hygiene, missing non-root USER directives (root container execution), dangerous capabilities (CAP_SYS_ADMIN, CAP_NET_ADMIN), and mutable/unpinned image tags (:latest).
   • Evaluates Kubernetes manifests against PodSecurity Standards (PSS restricted), flagging missing securityContext, allowPrivilegeEscalation: true, missing read-only root filesystems, and unconstrained RBAC wildcards (verbs: ["*"], resources: ["*"]).
   • Synthesizes automated drop-in hardening patches (PSS-compliant securityContext blocks and least-privilege RBAC Role definitions).
7. vulnforge_audit_ebpf:
   • Deep inspection of eBPF C programs, Falco rules, Tetragon policies, and Seccomp profiles for kernel verifier safety and active process kill enforcements.
8. vulnforge_fuzz_api:
   • Dynamic feedback-guided API mutation fuzzing (boundary values, type mismatches, prototype pollution probes) to uncover unhandled crashes and input validation gaps.
9. vulnforge_audit_iam:
   • Audits AWS IAM JSON/Terraform policies, GCP IAM bindings, Azure RBAC roles, and Zero Trust access controls for wildcard actions, over-scoped resources, privilege escalation, and missing TLS/MFA conditions.
10. vulnforge_inject_patch:

• Takes vulnerable code and automatically synthesizes a secure drop-in replacement with unified git diff and optional canary verification.

11. vulnforge_verify_patch:

• Executes isolated Canary Sandbox verification on synthesized or custom defensive patches using native Node.js vm.
• Runs dual-phase validation: Phase 1 evaluates attack payload containment (confirms exploit is blocked); Phase 2 evaluates benign functional input (ensures zero regression).
• Returns structured CanaryVerificationReport (VERIFIED_SAFE, ATTACK_LEAKED, REGRESSION_DETECTED, SYNTAX_ERROR, SANDBOX_TIMEOUT).

12. vulnforge_full_scan:

• Executes an end-to-end 360-degree security audit across Web, API, Database, GraphQL, CI/CD, and Container/Kubernetes layers simultaneously with automated patch synthesis and canary verification.

📋 Sample Vulnerability Findings & CWE Classification

• [CRITICAL] Privileged Container / Privilege Escalation Allowed (CWE-250 / Execution with Unnecessary Privileges)
• [CRITICAL] Untrusted PR Checkout via pull_request_target with Head SHA (CWE-250 / Privileged Execution)
• [CRITICAL] GraphQL Introspection Enabled in Production (CWE-200 / Information Exposure)
• [HIGH] Missing runAsNonRoot & Container Running as Root User (CWE-276 / Incorrect Default Permissions)
• [HIGH] Kubernetes RBAC Wildcard Permissions Allocated (CWE-269 / Improper Privilege Management)
• [HIGH] Missing Explicit Workflow Permissions - Risk of Default Write Privileges (CWE-276 / Default Permissions)
• [HIGH] Script Injection via Context Expression in Run Step (CWE-78 / Command Injection)
• [HIGH] Hardcoded Secret / Plaintext Personal Access Token Detected (CWE-798 / Hard-coded Credentials)
• [MEDIUM] Unpinned Third-Party Action Mutable Tag @v4 - Supply Chain Attack Risk (CWE-829 / Untrusted Control Sphere)
• [MEDIUM] Container Root Filesystem Writable / Missing readOnlyRootFilesystem (CWE-732 / Incorrect Permission Assignment)

---

⚡ Automated Defensive Patch Injection Engine

⚡ Automated Defensive Patch Injection Engine (Click to toggle / 접기·펼치기)

VulnForge not only detects flaws, but actively writes defensive patches:

--- a/k8s/deployment.yaml
+++ b/k8s/deployment.yaml
@@ -10,6 +10,12 @@
     spec:
+      securityContext:
+        runAsNonRoot: true
+        seccompProfile:
+          type: RuntimeDefault
       containers:
       - name: app
+        securityContext:
+          allowPrivilegeEscalation: false
+          readOnlyRootFilesystem: true
+          capabilities:
+            drop: ["ALL"]

--- a/Dockerfile
+++ b/Dockerfile
@@ -1,3 +1,6 @@
 FROM node:20-alpine AS builder
 ...
+RUN addgroup -S -g 10001 appgroup && adduser -S -u 10001 -G appgroup appuser
+USER 10001:10001
 CMD ["node", "dist/index.js"]

--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -1,5 +1,7 @@
 name: Deploy
 on: push
+permissions: read-all
 jobs:
   build:
-   uses: actions/checkout@v4
+   uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

--- a/server.ts
+++ b/server.ts
@@ -1,5 +1,7 @@
 const server = new ApolloServer({
   typeDefs,
   resolvers,
-  introspection: true,
+  introspection: process.env.NODE_ENV !== 'production',
+  validationRules: [depthLimit(5)],
+  formatError: (err) => ({ message: err.message }),
 });

--- a/database.ts
+++ b/database.ts
@@ -1,3 +1,3 @@
- const user = await db.query(`SELECT * FROM users WHERE email = ${email}`);
+ const user = await db.query('SELECT * FROM users WHERE email = $1', [email]);

--- a/frontend.js
+++ b/frontend.js
@@ -1,2 +1,2 @@
- document.getElementById('name').innerHTML = userName;
+ document.getElementById('name').textContent = userName;

---

🧪 Automated Canary Testing & Dynamic Sandbox Verification

🧪 Automated Canary Testing & Dynamic Sandbox Verification (Click to toggle / 접기·펼치기)

VulnForge MCP features an automated Canary Sandbox to verify that synthesized defensive patches eliminate vulnerabilities without introducing functional regressions:

• Isolated Node.js VM Sandbox (node:vm): Executes code in a zero-privilege V8 context with strict execution timeouts (2000ms), restricted globals (blocking process.exit, file system, and subprocess execution), and memory confinement.
• Dual-Phase Canary Execution Matrix:
  • Phase 1: Attack Vector Containment: Simulates targeted exploit payloads (SQL injection payloads ' OR '1'='1', DOM XSS <script>/<img onerror>, unauthorized GraphQL queries, missing security headers) against both the original and patched code to verify the exploit is blocked.
  • Phase 2: Benign Non-Regression Verification: Runs normal production inputs through both original and patched implementations to guarantee business logic continuity and prevent breaking changes.
• Automated Verification Verdicts:
  • VERIFIED_SAFE: Patch completely neutralizes the attack and preserves benign execution without regressions.
  • REGRESSION_DETECTED: Patch broke standard valid inputs or failed functional contracts.
  • ATTACK_LEAKED: Patch failed to prevent exploit execution under attack vectors.
  • SYNTAX_ERROR / SANDBOX_TIMEOUT: Patch caused syntax errors or exceeded execution deadline.

import { canaryVerifyPatch } from 'vulnforge-mcp/sandbox';

const report = await canaryVerifyPatch(originalCode, patchedCode, 'SQL_INJECTION');
console.log(report.status); // 'VERIFIED_SAFE'
console.log(report.attackBlocked); // true
console.log(report.benignPreserved); // true

---

🔐 Enterprise Security & age Cryptographic Protection

🔐 Enterprise Security & age Cryptographic Protection (Click to toggle / 접기·펼치기)

All proprietary signatures and sensitive core modules are protected via modern UNIX-philosophy cryptographic tools:

• age (X25519): Fast, modern file encryption replacing legacy PGP.
• Minisign (Ed25519): Detached signature verification for high-assurance release binaries.
• Post-Quantum Cryptography (ML-KEM-768 / Kyber): Quantum-resistant hybrid key encapsulation for long-term audit trail confidentiality.
• 3-Tier Key Backup: NTFS permission isolation + Windows DPAPI hardware binding + Encrypted Cloud Mirror.

---

🪞 Multi-Platform Mirrors / 다중 플랫폼 미러

🪞 Multi-Platform Mirrors / 다중 플랫폼 미러 (Click to toggle / 접기·펼치기)

Platform	Repository URL	Status
GitHub (Primary)	github.com/mason-keller/vulnforge-mcp
GitLab	gitlab.com/keller-lab/vulnforge-mcp
Hugging Face	huggingface.co/mason-keller/vulnforge-mcp

---

📄 Proprietary Software License

📄 Proprietary Software License (Click to toggle / 접기·펼치기)

PROPRIETARY & CONFIDENTIAL SOFTWARE LICENSE
Copyright (c) 2026 The Authors & Workspace Owner. All Rights Reserved.

Publicly visible on GitHub for evaluation, reference, and educational review only.
Unauthorized copying, modification, redistribution, or commercial use is strictly prohibited.