node9-proxy v1.65.1
Die Ausführungssicherheitsschicht für das agentenbasierte Zeitalter. Bietet deterministische 'Sudo'-Governance und Prüfprotokolle für autonome KI-Agenten.
🛡️ Node9
Was hat dein KI-Agent tatsächlich getan? Finde es heraus.
Node9 sitzt zwischen deinem KI-Agenten und den Tools, die er nutzen kann — entdecke, was er bereits getan hat, schütze dich in Echtzeit vor riskanten Aktionen und überprüfe, was in einem beliebigen Zeitfenster passiert ist.
Funktioniert mit Claude Code · Codex CLI · Antigravity (agy) · GitHub Copilot CLI · Gemini CLI · Cursor · Windsurf · VSCode · Claude Desktop · Opencode · Pi · Hermes Agent · jedem MCP-Server.
Was Node9 tut
- 🔍 Entdecken — scanne jede vergangene KI-Sitzung auf Credential-Leaks, Agentenschleifen, blockierte Operationen und jedes Geheimnis auf der Festplatte, das ein Agent gerade erreichen könnte
- 🛡 Schützen — riskante Befehle überprüfen oder blockieren, bevor sie ausgeführt werden —
rm -rf,git push --force,DROP TABLE, Credential-Lesezugriffe,curl | bash, AWS/GitHub/Stripe-Key-Leaks - 📊 Überprüfen — Bericht mit Zeitfenster (heute / Woche / Monat / 90 Tage) — Kosten pro Agent, Top-Tools, ausgelöste Schutzmechanismen, Schadensradius
Retrospektiver Scan
Das ist mein eigener Rechner — 90 Tage während der Entwicklung von Node9. Punktzahl 25/100, 5 Credential-Dateien, die ein KI-Agent gerade erreichen könnte.```bash npx node9-ai scan # before installation, runs in ~10s, nothing uploads node9 scan # after installation, same output
<p align="center">
Node9-Scan-Scorecard
</p>
## Sicherheitslage-Scorecard
`node9 posture` bewertet, wie exponiert diese Maschine gegenüber einem kompromittierten Agenten ist – Isolation, ausgehender Datenverkehr, Geheimnisse auf der Festplatte, Lieferkette, Privilegien – und liefert dir den genauen Befehl zur Behebung jedes Befunds.```bash
node9 posture # scorecard with the #1 risk and a fix for every finding
node9 posture --ship # send a redacted snapshot to your node9 dashboard (fleet view)
Findings sind nach wer sie beheben kann gruppiert: 🔒 diejenigen, die node9 reduziert (einfach den Befehl ausführen) und 🧱 diejenigen, die nur du beheben kannst. Jede enthält ein verständliches Was / Warum / Wer und eine echte Abhilfe – z. B. verweist das Finding „Agent läuft unsandboxed auf dem Host“ direkt auf node9 sandbox run (unten).```text
🛡️ Node9 Posture — agent on this host Score: 100/100 (Good)
2 advisories below don't affect the score — OS-level exposure, yours to weigh.
🟢 node9 is already protecting you ✅ Secrets node9 DLP is blocking this ✅ Egress node9 egress is approval-gating this ✅ Approval gate node9 is blocking this ✅ Privilege node9 is approval-gating this
🔒 node9 reduces these — run the command, the rest is yours ⚠️ Isolation Running directly on the host — no container The agent runs loose on your whole machine, not in a sandbox. → node9 sandbox run — jail it: kernel egress + scoped mounts + node9 inside → node9 shield enable project-jail — or shrink the blast radius, keep host access ⚠️ Network exposure 4 services on 0.0.0.0 (node :3000/:4000, PostgreSQL :5432, Redis :6379) Reachable from your whole network, not just this laptop. → node9 shield enable postgres|redis — node9 blocks DROP TABLE / FLUSHALL → bind to 127.0.0.1 / firewall the port (your part)
✅ Supply chain no issues found ✅ Coverage no issues found
Track this across your fleet & keep it green → node9.ai
## Ein Repository scannen — agent-CI-Sicherheit
`node9 scan-repo` prüft jedes Repository (oder einen lokalen Ordner) darauf, ob ein KI-Agent, der in GitHub Actions eingebunden ist, von einem Außenstehenden **gekapert werden könnte** — injizierbare Workflows, für Agenten erreichbare Secrets, nicht gepinnte MCP-Server, zu weit gefasste Agent-Konfigurationen und manipulierte Anweisungsdateien. Rein statisch und nur parse-basiert: Es liest ausschließlich committete Konfigurationen und führt niemals Repository-Code aus. Für öffentliche Repositories sind weder Installation noch Token erforderlich.```bash
npx node9-ai scan-repo <owner/repo> # any public repo, no install
node9 scan-repo . # a local checkout — no network
node9 scan-repo <owner/repo> --json # machine-readable
No Markdown content provided for translation.```text 🛡️ node9 scan-repo · node9-ai/agent-security-demo · ⚠️ agent-security risk found inspected 2 config file(s), 2 finding(s)
🔴 CRITICAL Injectable agent workflow — untrusted input reaches a tool-using agent with secrets .github/workflows/vulnerable-example.yml · CI-2 • runs with base-repo secrets (pull_request_target) • checks out the untrusted PR head into the workspace root • allowed_non_write_users: "*" — any user can trigger the agent • no effective actor gate
🔴 CRITICAL Exfiltratable secrets reachable by an injectable agent .github/workflows/vulnerable-example.yml · CI-4 • agent has arbitrary shell (bare Bash) → can read env and exfiltrate
| Prüfung | Kennzeichen |
| ------- | --------------------------------------------------------------------------- |
| **CI-1** | Committete Agent-Konfiguration, die breite Tools vorab autorisiert oder Remote-Hooks ausführt |
| **CI-2** | Injizierbare Agent-Workflows — ein Außenstehender kann den Agenten auslösen und kapern |
| **CI-3** | Nicht gepinnte / `@latest` MCP-Server oder Inline-Anmeldedaten (Supply Chain) |
| **CI-4** | Geheimnisse, die ein injizierter Agent exfiltrieren könnte |
| **CI-6** | Vergiftete oder gefährliche Anweisungen in `CLAUDE.md` / `AGENTS.md` / Skills |
**Jeden PR absichern** — dieselbe Engine wie eine GitHub Action, damit eine kaperbare Konfiguration nicht gemerged werden kann:```yaml
# .github/workflows/agent-security.yml
- uses: node9-ai/node9-proxy@v2
with:
fail-on: high # or 'never' to just comment
Marketplace: node9 Agent Security
Läuft es bei dir? Füge das scanned by node9-Abzeichen zu deiner README hinzu.
Live-Überwachung
Node9-Monitor-Dashboard
node9 monitor öffnet ein interaktives Terminal-Dashboard mit zwei Ansichten:
[1]Echtzeit — Live-Aktivität, Genehmigungen, Sicherheitswarnungen, aktueller Risikowert[2]Bericht — Zeitraum-Zusammenfassung: Kosten, Top-Tools, ausgelöste Schutzschilde, Auswirkungsradius
Bericht
Drücke [2] im Monitor für eine Zeitraum-Zusammenfassung. Wechsle den Zeitraum mit [T]ag · [W]oche · [M]onat · [N]eunzig — dieselben Panels wie beim Scan oben, gesteuert durch dein Post-Installations-Auditprotokoll.
Node9-Monitor [2] Bericht
```bash node9 monitor # press [2] for Report view node9 report --period 7d # CLI form, no TUI ``` ## Installation```bash # macOS / Linux brew tap node9-ai/node9 && brew install node9or via npm (any platform)
npm install -g node9-ai
Installation
To install the tool, clone the repository and run the setup script:
git clone https://github.com/example/tool.git
cd tool
./setup.sh
Requirements
- Python 3.8 or higher
- pip package manager
- Internet connection for downloading dependencies
Quick Start
After installation, you can run the tool with the following command:
python main.py --target example.com
For a full list of options, use the --help flag:
python main.py --help
Usage Examples
Basic Scan
To perform a basic scan against a target, use:
python main.py --target example.com
This will output the results to the console. To save the output to a file, use the -o option:
python main.py --target example.com -o results.txt
Advanced Options
The tool supports several advanced options for fine-tuning your scans:
--threads N: Set the number of concurrent threads (default: 10)--timeout SECONDS: Set the request timeout in seconds (default: 30)--verbose: Enable verbose output for debugging purposes
Example with advanced options:
python main.py --target example.com --threads 20 --timeout 60 --verbose
Output Formats
The tool can generate reports in multiple formats. Use the --format option to specify the desired output format:
json: Output results in JSON formatcsv: Output results in CSV formathtml: Output results in an HTML report
python main.py --target example.com --format json
Configuration
The tool reads configuration from a config.yaml file located in the same directory as the script. Below is an example configuration:
# Configuration file for the tool
scan:
threads: 10
timeout: 30
retries: 3
output:
format: json
directory: ./reports
logging:
level: info
file: ./logs/tool.log
Environment Variables
The following environment variables can be used to override configuration settings:
TOOL_THREADS: Override the number of threadsTOOL_TIMEOUT: Override the request timeoutTOOL_OUTPUT_DIR: Override the output directory
Troubleshooting
Common Issues
Issue: Permission denied when running the setup script
Ensure the script has execute permissions:
chmod +x setup.sh
Issue: Module not found errors
Make sure all dependencies are installed:
pip install -r requirements.txt
Getting Help
If you encounter issues not covered here, please open an issue on the GitHub repository or consult the documentation in the docs/ directory.
node9 init # auto-wires all detected agents + MCP servers
node9 login # connect this machine to your workspace (approve it in the browser)
node9 doctor # verify everything is wired and reporting
```
Erfordert Node.js 18+.
`init` allein gibt dir vollständige lokale Durchsetzung: Regeln, Shields, DLP und
Genehmigungen funktionieren alle offline, auf dieser Maschine.
`login` ist das, was die Maschine auf dein Dashboard bringt. Es gibt einen Code aus, öffnet
den Browser, und du genehmigst die Maschine dort; wenn du noch kein Konto
hast, bringt dich die Registrierung mitten im Ablauf zurück zur gleichen Genehmigung mit dem Code
intakt. Bis du es ausführst, wird alles lokal durchgesetzt, aber nichts erreicht
Mission Control, also bleibt das Dashboard leer.
`node9 logout` trennt eine Maschine wieder. Es widerruft den Schlüssel dieser Maschine;
die lokale Durchsetzung läuft weiter.
## Shields — kuratierte Regelpakete
Jedes Shield ist ein kuratiertes Regelset für einen Dienst oder eine Domäne. Aktiviere nur, was du brauchst.
| Shield | Was es abfängt | Aktivieren |
| ----------------- | ------------------------------------------------------------------------------ | ------------------------------------- |
| `project-jail` | Blockiert Lesezugriffe auf `~/.ssh`, `~/.aws`, `.env`, Anmeldedaten über Bash- und Read-Tool | `node9 shield enable project-jail` |
| `bash-safe` | `curl \| bash`, `rm -rf /`, Festplatten-Überschreiben, `eval` von Remote-Inhalten | `node9 shield enable bash-safe` |
| `postgres` | `DROP TABLE`, `TRUNCATE`, `DROP COLUMN`, `DELETE` ohne `WHERE` | `node9 shield enable postgres` |
| `mongodb` | `dropDatabase`, `drop()`, `deleteMany({})`, Index-Löschungen | `node9 shield enable mongodb` |
| `redis` | `FLUSHALL`, `FLUSHDB`, `CONFIG SET` auf einem Live-Server | `node9 shield enable redis` |
| `aws` | S3-Löschung, EC2-Beendigung, IAM-Änderungen, RDS-Zerstörung | `node9 shield enable aws` |
| `k8s` | Namespace-Löschung, `helm uninstall`, Cluster-Rollen-Löschungen | `node9 shield enable k8s` |
| `docker` | `system prune`, `volume prune`, `rm -f` von Containern | `node9 shield enable docker` |
| `github` | `gh repo delete`, Löschung entfernter Branches, Einstellungsänderungen | `node9 shield enable github` |
| `filesystem` | `chmod 777`, Schreibzugriffe unter `/etc/`, `/boot/`, `/usr/` | `node9 shield enable filesystem` |
| `mcp-tool-gating` | Nicht genehmigte MCP-Tools, die stillschweigend neue Fähigkeiten aktivieren | `node9 shield enable mcp-tool-gating` |```bash
node9 shield list # show all shields + status
```
## Immer aktiv — keine Konfiguration nötig
- **Git** — erkennt `git push --force`, `git reset --hard`, `git clean -fd`
- **SQL** — erkennt `DELETE` / `UPDATE` ohne `WHERE`, `DROP TABLE`, `TRUNCATE`
- **Shell** — erkennt `curl | bash`, unbefugtes `sudo`
- **DLP** — kennzeichnet AWS-Schlüssel, GitHub-Tokens, Stripe-Schlüssel, PEM-Private-Keys in beliebigen Tool-Argumenten, Dateiinhalten oder Shell-Konfigurationen (`~/.zshrc`, `~/.bashrc`)
- **Response-DLP** — ein Hintergrund-Scanner liest Claudes Konversationsverlauf und warnt dich, wenn Claude in seinem Antworttext ein Geheimnis _geschrieben_ hat
- **Skills-Pinning** — SHA-256-Verifizierung installierter Claude-Skills / Plugins zwischen Sitzungen
## Review-Prompts — direkt im Agenten genehmigen
Wenn node9 eine Aktion zur **Überprüfung** kennzeichnet (z. B. `git push --force`, ein `DROP TABLE`), wird der Genehmigen/Ablehnen-Prompt **inline in der Agenten-Konversation** angezeigt — keine eingefrorene Sitzung, kein separates Terminal, kein Hook-Timeout-Wettlauf. node9 führt weiterhin den vollständigen Evaluator aus und trifft die Entscheidung; nur die Prompt-_Oberfläche_ wechselt zum Agenten.
- **Standardmäßig aktiviert** für **Claude Code** und **GitHub Copilot CLI** — die Agenten, deren Hook-Vertrag ein natives `ask` unterstützt. Jeder andere Agent (Codex, Gemini, Antigravity, Hermes, Cursor, OpenCode, Pi) verwendet node9s eigenen Genehmiger.
- **Steuere es** mit `reviewChannel` in `~/.node9/config.json` (oder `--no-ask` am Hook):```jsonc
{
"settings": {
"reviewChannel": "ask", // "ask" = inline agent prompt (default) | "approver" = node9's own approver
},
}
```
- **Team-Setups:** Wenn ein Cloud-/Team-Genehmiger konfiguriert ist (`approvers.cloud: true`), werden Reviews an diesen Genehmiger weitergeleitet — node9 lässt nicht zu, dass eine Inline-Selbstgenehmigung eine weitergeleitete/Genehmigung durch eine zweite Partei umgeht.
## Sandbox — einen Agenten in einem Gefängnis ausführen
Wenn Beobachten nicht ausreicht, führt **`node9 sandbox`** den Agenten in einem Wegwerf-Container mit einer **kernel-erzwungenen Egress-Allowlist** und **eingeschränkten Mounts** aus — während node9s Hooks jeden Tool-Aufruf _innerhalb_ der Box steuern und auditieren. Die harte Version des Schutzes: Der Agent kann nur den Ordner berühren, den du mountest, und die Hosts erreichen, die du erlaubst; alles andere wird am Kernel verworfen.```bash
cd ~/my-project
node9 sandbox new # write node9.sandbox.yaml — what to mount + which hosts to allow
node9 sandbox run # build + boot the jailed agent (your project at /workspace)
node9 sandbox tail # watch the agent's actions live, from the host
```
- **Disposable** — der Container wird beim Beenden zerstört; Ihre Projektänderungen landen auf Ihrer echten Festplatte, nichts anderes überlebt.
- **Gleiche Richtlinie** — Ihre bestehenden Shields / Egress-Regeln / Genehmigungen gelten innerhalb der Box, gestreamt in dasselbe Audit-Log und Dashboard.
- **Schließt die Posture-Schleife** — das Ausführen schaltet die Isolation / Egress-Findings auf grün.
Ehrlicher Umfang (Phase 1): einzelner Container, **zuerst Claude** (Codex als Nächstes); der Agent hält weiterhin seine _eigenen_ Anmeldedaten in der Box (die Egress-Wand beschränkt sie auf die erlaubten Hosts) — _„der Agent hält nie ein Geheimnis“_ ist die Credential-Broker-Phase auf der Roadmap. Erfordert Docker.
## MCP-Gateway
Wickeln Sie jeden MCP-Server transparent ab. Der Agent sieht denselben Server — Node9 fängt jeden Tool-Aufruf ab.```json
{
"mcpServers": {
"postgres": {
"command": "node9",
"args": ["mcp", "--upstream", "npx -y @modelcontextprotocol/server-postgres postgresql://..."]
}
}
}
```
Oder einfach `node9 init` ausführen — es umschließt deine vorhandenen MCP-Server automatisch.
<details>
<summary><strong>🔐 MCP-Tool-Pinning — Schutz vor Rug-Pull-Angriffen</strong></summary>
MCP-Server können ihre Tool-Definitionen zwischen Sitzungen ändern. Ein kompromittierter oder bösartiger Server könnte nach deinem ersten Vertrauen stillschweigend Tools hinzufügen, entfernen oder modifizieren — ein **Rug-Pull**-Angriff.
Node9 pinnt Tool-Definitionen bei der ersten Verwendung:
1. **Erste Verbindung** — Das Gateway zeichnet einen SHA-256-Hash von Name, Beschreibung und Schema jedes Tools auf
2. **Nachfolgende Verbindungen** — Der Hash wird verglichen; wenn sich Tools geändert haben, wird die Sitzung **unter Quarantäne gestellt** und jeder Tool-Aufruf wird blockiert, bis ein Mensch die Änderung prüft und genehmigt
3. **Beschädigter Pin-Zustand** — Schließt sicher ab (blockiert), vertraut niemals stillschweigend erneut```bash
node9 mcp pin list # show all pinned servers and hashes
node9 mcp pin update <serverKey> # remove pin, re-pin on next connection
node9 mcp pin reset # clear all pins
```
</details>
## Weitere Befehle
Über die drei Flow-Befehle oben hinaus (`scan` / `monitor` / `report`):
| Befehl | Was angezeigt wird | Wann verwenden |
| ---------------- | ----------------------------------------------------------- | --------------------------------------- |
| `node9 blast` | Was ein KI-Agent gerade erreichen kann — Dateien, Creds, Env | Als Erstes auf jeder Maschine ausführen |
| `node9 tail` | Live-Stream jedes Tool-Aufrufs (nur Text, keine TUI) | Zum Weiterleiten an andere Tools, CI, Logs |
| `node9 sessions` | Sitzungsverlauf mit Prompt, Tool-Trace und Kosten | Zum Prüfen einer Übergabe oder früherer Arbeit |
| `node9 dlp` | Erkenntnisse zu Credential-Leaks im Claude-Antworttext | Immer wenn ein DLP-Desktop-Alarm ausgelöst wird |
| `node9 mask` | Schwärzt Klartext-Secrets aus lokalen Sitzungsverlaufsdateien | Nach einem DLP-Fund — bereinigt die lokale Festplatte |
Plus ein **Live-HUD** in deiner Claude-Code-Statuszeile:```
🛡 node9 | standard | [bash-safe] | ✅ 12 allowed 🛑 2 blocked 🚨 0 dlp | ~$0.43
📊 claude-opus-4-7 | ctx [████████░░░] 54% | 5h [██░░░░░░░░] 12% | 7d [█░░░░░░░] 7%
🗂 2 CLAUDE.md | 8 rules | 3 MCPs | 4 hooks
```
## Die Daten lesen — was die Zahlen bedeuten
Node9 macht das Signal sichtbar. Hier sind die Muster, die es zu kennen lohnt:
| Signal | Wahrscheinliche Bedeutung |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| `Would have blocked` ≥ 5 in einer Woche | Agent versucht Operationen mit hoher Wirkung; Shields sind eine Überprüfung wert |
| Einzelne `review-git-push`-Regel >50% der Befunde | Deine eigene Regel greift wie vorgesehen — kein Risiko, nur Überwachung |
| DLP-Befund im `user-prompt`-Tool | Du hast ein Geheimnis in deinen eigenen Prompt eingefügt — Schlüssel rotieren |
| Agent Loop ×50+ auf derselben Datei | Agent steckt in einem Edit/Test/Fix-Zyklus fest — Kontext prüfen oder verlangsamen |
| MCP-Tool-Pin-Konflikt | Server hat seine Tools geändert — vor erneutem Vertrauen prüfen |
| Warnung zu großer MCP-Antwort | Dieser Server bläht dein Kontextfenster für jede weitere Runde auf |
| `Response DLP`-Alarm | Claude hat ein Geheimnis in seinen Antworttext geschrieben — nicht blockiert, sofort rotieren |
| DLP-Befund in `tool-result` | Claude hat eine Datei mit einem Geheimnis gelesen (`.env`, Zugangsdaten) — Schlüssel rotieren und `node9 mask` ausführen |
| DLP-Befund in `[Shell]` | Klartext-Geheimnis in `~/.zshrc` oder `~/.bashrc` — jede KI-Sitzung kann es sehen |
Einmalige Signale sind normal; anhaltende Muster sind das, worauf du reagierst.
## Python SDK — jeden Python-Agenten verwalten```python
from node9 import configure, protect
configure(agent_name="my-agent", policy="require_approval")
@protect("bash")
def run_command(cmd: str) -> str:
...
```
**[Python SDK →](https://github.com/node9-ai/node9-python)** · **[CI-Code-Review-Agent-Beispiel →](https://github.com/node9-ai/node9-pr-agent)**
## Unter der Haube
- **Scan** liest den rohen Agentenverlauf aus `~/.claude/projects/`, `~/.gemini/tmp/`, `~/.gemini/antigravity-*/brain/`, `~/.copilot/session-state/`, `~/.codex/sessions/` — keine API-Aufrufe, vollständig offline
- **Runtime** fängt Tool-Aufrufe über Pre-Execution-Hooks ab (Claude Code, Codex, Antigravity, GitHub Copilot CLI, Gemini CLI, Opencode, Pi) oder über das MCP-Gateway (Cursor, Windsurf, VSCode, Claude Desktop). Alle Entscheidungen landen atomar in `~/.node9/audit.log`.
- **MCP-Gateway** ist ein stdio-Proxy; fängt `tools/list` + `tools/call` JSON-RPC ab, leitet den Rest weiter
- **Policy-Engine** verwendet [mvdan-sh](https://github.com/mvdan/sh) für die Bash-AST-Analyse — umgeht Verschleierung durch Backslash-Escaping, Variablensubstitution, eval von Remote-Downloads
- **Sandbox** generiert ein Dockerfile + Entrypoint, die eine `ipset`/`iptables`-Deny-by-Default-Egress-Wand versiegeln, und wechselt dann zu einem Nicht-Root-Agenten mit node9s Daemon + Hooks im Inneren; nur die Credential-Datei des Agenten wird gemountet, niemals dein gesamtes `~/.claude`
## Vollständige Dokumentation
Konfigurationsreferenz, intelligente Regeln, zustandsbehaftete Regeln, vertrauenswürdige Hosts, Genehmigungsmodi, CLI-Referenz — unter **[node9.ai/docs](https://node9.ai/docs)**.
## Verwandte Projekte
- **[node9-python](https://github.com/node9-ai/node9-python)** — Python-SDK
- **[node9-pr-agent](https://github.com/node9-ai/node9-pr-agent)** — GitHub Action, die PRs über Node9 überprüft
## Enterprise
**Node9 Pro** fügt Governance-Sperren, SAML/SSO, zentralen Audit-Export und VPC-Bereitstellung hinzu. Siehe [node9.ai](https://node9.ai).
## Lizenz
Apache-2.0
<p align="center">
<sub>Gebaut mit ☕ und gesunder Paranoia.</sub>
</p>