infra-guard

Ein MCP-Server, der Terraform-Konfigurationen und Dockerfiles auf echte Sicherheitsfehlkonfigurationen prüft — offene Security Groups, öffentliche S3-Buckets, Wildcard-IAM-Richtlinien, hartkodierte Secrets, Container, die als root laufen — und statt einer Vermutung strukturierte Befunde zurückliefert.

Er lässt sich als Tool in Claude Code, Claude Desktop oder Cursor einbinden. Bitten Sie Ihren KI-Assistenten, Ihren Infrastrukturcode zu überprüfen: Er ruft infra-guard auf, erhält echte Befunde von Checkov und erklärt sie Ihnen.

Im Browser ausprobieren: infra-guard-frontend-production.up.railway.app — Terraform einfügen, auf „Scan“ klicken, echte Befunde sehen. Keine Installation erforderlich.

MCP-Endpunkt: https://infra-guard-production.up.railway.app/mcp

Warum es das gibt

Ich habe bei A.P. Moller–Maersk Cloud-Infrastrukturarbeit gemacht — Terraform, Docker, AWS-Provisionierung in echtem Umfang. Die meisten Portfolio-Projekte sind generische Web-Apps; dieses hier ist das Werkzeug, das ich mir tatsächlich gewünscht habe: etwas, das „Hat meine Anwendung offensichtliche Sicherheitslücken?“ in eine echte, strukturierte Antwort verwandelt, statt in die bloße Vermutung eines KI-Assistenten.

infra-guard rät nicht. Es führt Ihre Datei durch Checkov, eine echte statische Analyse-Engine mit Hunderten eingebauten Checks, und liefert die tatsächlichen Befunde zurück — Check-ID, Titel, betroffene Ressource, Zeilenbereich, Code-Snippet. Das die Sitzung hostende Modell (Claude, oder was auch immer am anderen Ende der MCP-Verbindung sitzt) erklärt die Befunde in verständlichem Englisch. Die Aufgabe des Tools ist einfach: korrekt zu sein.

Related MCP server: MCP Security Scanner

So funktioniert es

scanner.py   → core engine: scan_terraform(...) / scan_dockerfile(...) -> structured dict
server.py    → wraps both as MCP tools, served over stdio or Streamable HTTP
api.py       → wraps both as a plain REST API (POST /api/scan, POST /api/scan-dockerfile)
frontend/    → React + Vite playground that calls api.py, with a Terraform/Dockerfile toggle

scanner.py ruft die Checkov-CLI als Unterprozess auf, parst die JSON-Ausgabe und gibt immer die gleiche Struktur zurück, unabhängig davon, welches Framework ihn aufgerufen hat:

{
  "summary": { "passed": 14, "failed": 34, "total_checks": 48 },
  "findings": [
    {
      "check_id": "CKV_AWS_24",
      "title": "Ensure no security groups allow ingress from 0.0.0.0:0 to port 22",
      "resource": "aws_security_group.app_sg",
      "start_line": 6,
      "end_line": 24,
      "code_snippet": "resource \"aws_security_group\" \"app_sg\" { ... }"
    }
  ]
}

server.py macht zwei MCP-Tools verfügbar, scan_terraform_file(file_content, filename) und scan_dockerfile_file(file_content, filename), und hat keine eigene Interpretationsebene — die strukturierten Daten fließen direkt in das Modell, das gerade die Sitzung hostet.

insecure_example.tf enthält vier absichtliche Terraform-Probleme (offene SSH-Verbindung, ein öffentlicher und unverschlüsselter S3-Bucket, eine Wildcard-IAM-Richtlinie, ein hartkodiertes RDS-Passwort) — 14 bestanden / 34 fehlgeschlagene Checks. insecure_example.Dockerfile enthält fünf (unverändertes Basis-Image, ADD statt COPY, Port 22 offen, kein HEALTHCHECK, läuft als root) — 28 bestanden / 5 fehlgeschlagene Checks.

Lokales Ausführen

Erfordert uv.

git clone https://github.com/SanjanaJanardhan/infra-guard.git
cd infra-guard
uv sync

Den Scanner direkt ausführen:

uv run python3 scanner.py

Den MCP-Server über stdio ausführen (für lokale Clients wie Claude Code/Desktop):

uv run python3 server.py

Den MCP-Server über Streamable HTTP ausführen (für Remote-Clients oder zum Reproduzieren des Deployments):

uv run python3 server.py --transport streamable-http --port 8000

Mit einem MCP-Client verbinden

Claude Code / Claude Desktop — folgenden Eintrag zur .mcp.json (Projektebene) oder zur globalen MCP-Konfiguration hinzugefügt:

{
  "mcpServers": {
    "infra-guard": {
      "command": "uv",
      "args": ["--directory", "/absolute/path/to/infra-guard", "run", "python3", "server.py"]
    }
  }
}

.NET-Circle Streamable-HTTP-Clients (inklusive des Live-Deployments oben) — Adresse auf:

https://infra-guard-production.up.railway.app/mcp

Playground lokal ausführen

# terminal 1 — API
uv run python3 api.py

# terminal 2 — frontend
cd frontend
npm install
npm run dev

Das Frontend bezieht seine API-Basis-URL aus der Datei VITE_API_URL (siehe frontend/.env.local), mit http://localhost:8001 als Standard.

Deployment

Drei Dienste auf Railway, alle aus Docker/Nixpacks erstellt, ohne manuelle Server-Konfiguration:

• MCP-Server — Dockerfile, Streamable HTTP

• REST API — Dockerfile.api, derselbe scanner.py-Kern, versorgt den Playground

• Frontend — Der Nixpacks-Builder von Railway erkennt die Vite-App in frontend/ automatisch; VITE_API_URL wird zur Build-Zeit auf die URL der bereitgestellten API gesetzt.

Beide Python-Dienste lesen die Variable PORT aus der Umgebung, sodass sie sich ohne Konfigurationsänderungen an den jeweils zugewiesenen Port anpassen.

Stack

Python · Checkov · MCP Python SDK · FastAPI · React · Docker · Railway

Roadmap

• Kern-Terraform-Scan-Engine

• lässt sich über stdio verwenden

• Streamable-HTTP-Transport

• Auf Railway deployed

• Web-Frontend mit Live-Playground

• Dockerfile-Scanning inklusive Terraform/Dockerfile-Option im Playground

• Kostenauswirkungs-Schätzung für Befunde

Lizenz

MIT