SkillSpector

Sicherheitsscanner für KI-Agenten-Skills. Erkennt Schwachstellen, bösartige Muster und Sicherheitsrisiken, bevor Agenten-Skills installiert werden.

Überblick

KI-Agenten-Skills (verwendet von Claude Code, Codex CLI, Gemini CLI usw.) werden mit implizitem Vertrauen und minimaler Prüfung ausgeführt. Die Forschung zeigt, dass 26,1 % der Skills Schwachstellen enthalten und 5,2 % wahrscheinlich bösartige Absichten aufweisen.

SkillSpector hilft Ihnen, die Frage zu beantworten: „Ist dieser Skill sicher zu installieren?"

SkillSpector ist Teil der NVIDIA Verified Skills Pipeline, die Agenten-Skills vor der Veröffentlichung scannt, bewertet und signiert. Skills, die die Prüfung bestehen, werden im NVIDIA-Skills-Katalog veröffentlicht.

Dokumentation

Agenten-Skills vor der Installation scannen — Gehosteter Leitfaden: Wann gescannt werden sollte, wie ein Bericht gelesen wird und wie Installationen abgesichert werden.
Entwicklungsleitfaden — Architektur, Paketstruktur und wie die Analyzer-Pipeline erweitert wird.
Analyse-Ressourcengrenzen — Fail-Closed-Bundle, Parser-, verschachtelte Artefakt-, Ledger- und Befund-Obergrenzen.
Pi-Erweiterung — Installieren Sie SkillSpector als Pi-Tool zum Scannen von Skills direkt aus Agenten-Sitzungen.

Funktionen

Multi-Format-Eingabe: Scannt Git-Repos, URLs, ZIP-Dateien, Verzeichnisse oder einzelne Dateien
71 Schwachstellenmuster in 17 Kategorien: Prompt-Injection, Datenerfassung, Privilegieneskalation, Lieferkette, übermäßige Handlungsbefugnis, Ausgabeverarbeitung, System-Prompt-Leckage, Speichervergiftung, Werkzeugmissbrauch, Schurken-Agent, Anti-Verweigerung, Trigger-Missbrauch, gefährlicher Code (AST), Taint-Tracking, YARA-Signaturen, MCP-Minimalprivilegien und MCP-Werkzeugvergiftung
Zweistufige Analyse: Schnelle statische Analyse + optionale LLM-semantische Bewertung
Live-Schwachstellenabfragen: SC4 fragt OSV.dev für Echtzeit-CVE-Daten mit automatischem Offline-Fallback ab
Mehrere Ausgabeformate: Terminal-, JSON-, Markdown- und SARIF-Berichte
Risikobewertung: 0-100-Punkte-Score mit Schweregradkennzeichnungen und klaren Empfehlungen
Basislinien-/Fehlalarm-Unterdrückung: Bekannte Befunde über eine Glob-Regel- oder Fingerprint-Basislinie akzeptieren, sodass erneute Scans nur neue Probleme aufzeigen (Dokumentation)

Schnellstart

Installation

Hinweis zu Open-Source-Software: Dieses Projekt lädt zusätzliche Open-Source-Softwareprojekte von Drittanbietern herunter und installiert sie. Überprüfen Sie die Lizenzbedingungen dieser Open-Source-Projekte vor der Verwendung.

Erstellen und aktivieren Sie zuerst eine virtuelle Umgebung (alle make-Ziele setzen voraus, dass die venv aktiv ist). Verwenden Sie uv oder pip; das Makefile verwendet uv, falls verfügbar, andernfalls pip.

Schnellinstallation mit uv (nur CLI):```bash uv tool install git+https://github.com/NVIDIA/skillspector.git

Update later: uv tool update skillspector

Wenn du `skillspector mcp` ausführen möchtest, installiere das MCP-Extra bei der Installation:```bash
uv tool install 'skillspector[mcp] @ git+https://github.com/NVIDIA/skillspector.git'

From source:```bash

Clone the repository

git clone https://github.com/NVIDIA/skillspector.git cd skillspector

Create and activate virtual environment

uv venv .venv && source .venv/bin/activate

or: python3 -m venv .venv && source .venv/bin/activate

Install for production use

make install

Or install with development dependencies

make install-dev

### Docker (kein Python erforderlich)

Führen Sie SkillSpector aus, ohne Python zu installieren, indem Sie es lokal aus dem enthaltenen [Dockerfile](https://github.com/nvidia/skillspector/blob/main/Dockerfile) erstellen. Das Image basiert auf dem offiziellen Docker-Python-Image `3.12-slim-bookworm`.

**Image erstellen:**```bash
make docker-build
# or: docker build -t skillspector .

Lokales Verzeichnis scannen, indem Sie Ihr aktuelles Verzeichnis in /scan, das Arbeitsverzeichnis des Containers, einbinden:```bash docker run --rm -v "$PWD:/scan" skillspector scan ./my-skill/ --no-llm

**Scan mit LLM-Analyse** durch Übergabe von Anmeldedaten mit einer lokalen `.env`-Datei:```bash
cat > .env <<'EOF'
SKILLSPECTOR_PROVIDER=anthropic
ANTHROPIC_API_KEY=sk-ant-...
EOF

Hier ist die Übersetzung von Chunk 13/47 ins Deutsche:

Hinweis: Da der Eingabetext (INPUT) leer ist, gibt es keinen Inhalt zu übersetzen. Bitte stellen Sie den tatsächlichen Markdown-Inhalt von Chunk 13 bereit, damit ich ihn gemäß den Regeln übersetzen kann.```bash docker run --rm
-v "$PWD:/scan"
--env-file .env
skillspector scan ./my-skill/

Oder übergebe die Anmeldedaten direkt aus deiner Shell-Umgebung:```bash
docker run --rm \
  -v "$PWD:/scan" \
  -e SKILLSPECTOR_PROVIDER=anthropic \
  -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
  skillspector scan ./my-skill/

Schreiben Sie einen Bericht in das Host-Dateisystem, indem Sie in das eingebundene Verzeichnis schreiben:```bash docker run --rm
-v "$PWD:/scan"
skillspector scan ./my-skill/ --no-llm --format json --output report.json

**Optionaler Alias** für wiederholte statische Scans:```bash
alias skillspector-docker='docker run --rm -v "$PWD:/scan" skillspector'
skillspector-docker scan ./my-skill/ --no-llm

Grundlegende Verwendung```bash

Scan a local skill directory

skillspector scan ./my-skill/

Scan a single SKILL.md file

skillspector scan ./SKILL.md

Scan a Git repository

skillspector scan https://github.com/user/my-skill

Scan a zip file

skillspector scan ./my-skill.zip

#### Größenlimits

SkillSpector erzwingt zwei unabhängige Obergrenzen für Remote- und Archiv-Eingaben, um die Auswirkungen übermäßig großer Downloads und Zip-Bomben zu begrenzen:

- **Pro-Ingest-Obergrenze**: `INGEST_MAX_BYTES` (100 MiB) — angewendet auf gestreamte URL-Downloads, die gesamte unkomprimierte Größe von Zip-Archiven und die Festplattennutzung nach dem Klonen von Git-Repos.
- **Zip-Element-Obergrenze**: `INGEST_MAX_ZIP_MEMBERS` (10.000) — begrenzt die Anzahl der Einträge in einer einzelnen Zip-Datei.

Beachten Sie, dass die Analyse-Obergrenze von 1 MB pro Datei (`MAX_FILE_BYTES`) eine separate, nachgelagerte Grenze ist: Sie begrenzt, was einzelne Analyzer aus einem bereits ingestierten Verzeichnis auslesen. Die oben genannten Ingest-Obergrenzen begrenzen, wie viel Inhalt überhaupt auf der Festplatte landen kann. Eine Verletzung einer der Ingest-Obergrenzen schlägt mit einem `IngestLimitExceededError` fehl (Fail-Closed-Prinzip).

### Ausgabeformate```bash
# Terminal output (default) - pretty formatted
skillspector scan ./my-skill/

# JSON output - machine readable
skillspector scan ./my-skill/ --format json --output report.json

# Markdown output - for documentation
skillspector scan ./my-skill/ --format markdown --output report.md

# SARIF output - for CI/CD integration and IDE tooling
skillspector scan ./my-skill/ --format sarif --output report.sarif

Batch-Scanning

Scannen Sie ganze Skill-Verzeichnisse parallel aus contrib/batch_scan/:```bash python -m contrib.batch_scan.batch_scan ./my-skills/ --no-llm python -m contrib.batch_scan.batch_scan ./my-skills/ --workers 20 -f json -o report.json python -m contrib.batch_scan.batch_scan ./tests/fixtures/ -f terminal --workers 20

Unterstützt mehrsprachige Erkennung (zh/ja/ko) sowie Terminal-/JSON-/Markdown-Ausgabe.

Für LLM-Scans mit höherer Parallelität konfigurieren Sie mehrere API-Schlüssel gemäß
[`.env.example`](https://github.com/nvidia/skillspector/blob/main/contrib/batch_scan/.env.example) — der Pool verbessert Durchsatz
und Ausfallsicherheit, sofern die Schlüssel kein Konto-weites Rate-Limit teilen.

Siehe den [Contrib-Guide](https://github.com/nvidia/skillspector/blob/main/contrib/batch_scan/docs) für Details.

> **Hinweis zur LLM-Unterstützung:** Die Standardkonfiguration zielt auf DeepSeek als
> günstigste öffentliche Option ab. DeepSeek-Chat wird
> [voraussichtlich eingestellt](https://api-docs.deepseek.com/), und der Beitragende
> hat keine Hardware, um gegen lokale Modelle zu testen. Der Batch-Scanner wurde
> ursprünglich mit OpenAI-kompatiblen Endpunkten getestet — DeepSeeks fehlende
> Unterstützung für strukturierte Ausgaben erforderte manuelle JSON-Parsing-Patches.
> Wenn Sie ein universelleres Backend beitragen können (Ollama, vLLM oder einen
> anderen Anbieter), sind PRs sehr willkommen.

### Unterdrücken falsch positiver Ergebnisse (Baseline)

Unterdrücken Sie bekannte/akzeptierte Befunde, sodass der Risikoscore nur nicht
bearbeitete Probleme widerspiegelt und erneute Scans nur *neue* Befunde anzeigen.
Siehe den [Suppressions-Guide](https://github.com/nvidia/skillspector/blob/main/docs/SUPPRESSION.md) für die vollständige Referenz.```bash
# Accept all current findings into a baseline (run once), then commit it.
skillspector baseline ./my-skill/ -o .skillspector-baseline.yaml

# Scan against the baseline — only NEW findings are reported and scored.
skillspector scan ./my-skill/ --baseline .skillspector-baseline.yaml

# Review what was suppressed (still excluded from the score).
skillspector scan ./my-skill/ --baseline .skillspector-baseline.yaml --show-suppressed

Eine Baseline kann auch drift-tolerante Glob-Regeln verwenden (nach Regel-ID, Dateipfad oder Nachricht) – siehe .skillspector-baseline.example.yaml. Exakte Fingerprint-Baselines sind evidenzgebunden: Eine Änderung der gescannten Quelle oder der SkillSpector-Version hält den Befund aktiv, bis er erneut überprüft wird. Wenn eine ausgewählte Baseline oder Baseline-Ausgabe im Skill-Verzeichnis gespeichert ist, schließt SkillSpector genau diese Datei von der Inhaltsanalyse aus, sodass ihr Unterdrückungstext keine Befunde erzeugen oder in regenerierte Fingerprints gelangen kann; Geschwisterdateien bleiben im normalen Scan-Umfang.

LLM-Analyse

Für die besten Ergebnisse konfigurieren Sie einen OpenAI-kompatiblen LLM-Endpunkt für die semantische Analyse. Wählen Sie einen Anbieter mit SKILLSPECTOR_PROVIDER; gehostete Anbieter liefern gebündelte Standardmodelle, während CLI-Anbieter auf das Standardmodell der lokalen Laufzeitumgebung zurückfallen, sofern SKILLSPECTOR_MODEL nicht gesetzt ist. SkillSpector funktioniert auch mit lokalen OpenAI-kompatiblen Servern (Ollama, vLLM, llama.cpp) und verwalteten Inferenz-Gateways.

Anbieter (`SKILLSPECTOR_PROVIDER`)	Umgebungsvariable für Anmeldedaten	Endpunkt	Standardmodell
`openai`	`OPENAI_API_KEY` (+ optional `OPENAI_BASE_URL`)	api.openai.com (oder jede OpenAI-kompatible URL)	`gpt-5.4`
`anthropic`	`ANTHROPIC_API_KEY`	api.anthropic.com	`claude-opus-4-6`
`anthropic_proxy`	`ANTHROPIC_PROXY_API_KEY` + `ANTHROPIC_PROXY_ENDPOINT_URL`	Jeder Vertex-artige Raw-Predict-Proxy	`claude-sonnet-4-6`
`bedrock`	`AWS_PROFILE` (optional) + `AWS_REGION` — SigV4 über boto3	AWS Bedrock Runtime	`us.anthropic.claude-sonnet-4-6-20250915-v1:0`
`nv_build`	`NVIDIA_INFERENCE_KEY`	build.nvidia.com	`deepseek-ai/deepseek-v4-flash`
`claude_cli`	(keine – verwendet lokale CLI-Authentifizierung)	lokale `claude`-Binärdatei	lokale Claude-Laufzeitumgebung als Fallback, oder `SKILLSPECTOR_MODEL`
`codex_cli`	(keine – verwendet lokale CLI-Authentifizierung)	lokale `codex`-Binärdatei	lokale Codex-Laufzeitumgebung als Fallback, oder `SKILLSPECTOR_MODEL`

Stock OpenAI

export SKILLSPECTOR_PROVIDER=openai export OPENAI_API_KEY=sk-... skillspector scan ./my-skill/

Anthropic

export SKILLSPECTOR_PROVIDER=anthropic export ANTHROPIC_API_KEY=sk-ant-... skillspector scan ./my-skill/

Anthropic via Vertex-style proxy (corporate gateways, GCP Vertex AI)

export SKILLSPECTOR_PROVIDER=anthropic_proxy export ANTHROPIC_PROXY_ENDPOINT_URL=https://my-gateway.example.com/models/claude-sonnet-4-6:streamRawPredict export ANTHROPIC_PROXY_API_KEY=your-bearer-token export SKILLSPECTOR_MODEL=claude-sonnet-4-6 skillspector scan ./my-skill/

AWS Bedrock (Claude via SigV4)

export SKILLSPECTOR_PROVIDER=bedrock

Optional: select an AWS named profile. When unset, the standard

boto3 credential chain (env vars, instance metadata, SSO, etc.) resolves.

export AWS_PROFILE=my-profile

export AWS_REGION=us-west-2 # default if unset

Default model: us.anthropic.claude-sonnet-4-6-20250915-v1:0

Override with any Bedrock model ID, cross-region inference-profile

ID, or your own application-inference-profile ARN:

export SKILLSPECTOR_MODEL=us.anthropic.claude-opus-4-6-20250915-v1:0

skillspector scan ./my-skill/

NVIDIA build.nvidia.com

export SKILLSPECTOR_PROVIDER=nv_build export NVIDIA_INFERENCE_KEY=nvapi-... skillspector scan ./my-skill/

Local Claude CLI — no API key; uses your existing `claude auth login` session

export SKILLSPECTOR_PROVIDER=claude_cli

Uses the local Claude CLI runtime fallback unless SKILLSPECTOR_MODEL is set.

export SKILLSPECTOR_MODEL=claude-sonnet-4-6

skillspector scan ./my-skill/

Local Codex CLI — no API key; uses your existing `codex login` session

Requires: codex CLI installed and authenticated

export SKILLSPECTOR_PROVIDER=codex_cli skillspector scan ./my-skill/

Local Ollama or any OpenAI-compatible endpoint

export SKILLSPECTOR_PROVIDER=openai export OPENAI_API_KEY=ollama export OPENAI_BASE_URL=http://localhost:11434/v1 export SKILLSPECTOR_MODEL=llama3.1:8b skillspector scan ./my-skill/

Override the provider's default model

export SKILLSPECTOR_MODEL=gpt-5.2 skillspector scan ./my-skill/

Skip LLM analysis (faster, static analysis only)

skillspector scan ./my-skill/ --no-llm

### MCP-Server

Führen Sie SkillSpector als [Model Context Protocol](https://modelcontextprotocol.io)-Server aus, damit jeder MCP-fähige Agent (Claude Code, Codex CLI, Gemini CLI) oder eine entfernte Laufzeitumgebung das Scannen als Werkzeug aufrufen und **Skill-/MCP-Installationen anhand des Ergebnisses freigeben oder blockieren kann** – das macht SkillSpector zu einer Laufzeit-Schutzmaßnahme statt zu einem separaten Audit-Schritt.

`skillspector mcp` erfordert `skillspector[mcp]`.```bash
# Install, or reinstall if you already used the CLI-only path
uv tool install --force 'skillspector[mcp] @ git+https://github.com/NVIDIA/skillspector.git'

# FastMCP stdio transport for local CLI agents
skillspector mcp

# streamable HTTP/SSE transport for remote / A2A callers
skillspector mcp --transport http --host 127.0.0.1 --port 8000

Der stdio-Transport ist der aktuelle FastMCP-Pfad für lokale CLI-Agenten, und das Initialize-Hängen, das in Issue #199 gemeldet wurde, gilt dort weiterhin.

Der Server stellt ein einzelnes Tool bereit:

scan_skill(target, use_llm=true, output_format="json") — scannt eine Git- URL, Datei-URL, .zip-, .md-Datei oder ein Verzeichnis und gibt ein strukturiertes Urteil zurück: risk_score (0-100), severity, recommendation, safe_to_install und findings. Es meldet außerdem llm_used / scan_mode, sodass ein niedriger Score aus einem rein statischen Scan niemals mit einem sauberen vollständigen Scan verwechselt wird.

Registrieren Sie es bei Claude Code über:```bash claude mcp add skillspector -- skillspector mcp

> **Sicherheit — HTTP-Transport-Vertrauensmodell**
>
> Der HTTP-Transport wird **ohne Authentifizierung** ausgeliefert. Jeder Aufrufer, der
> den Port erreichen kann, kann `scan_skill` aufrufen. Über stdio oder `127.0.0.1` ist dies
> dieselbe Vertrauensgrenze wie bei der CLI. Wenn Sie an eine routbare Schnittstelle binden:
>
> - Platzieren Sie den Server hinter einem authentifizierenden Reverse-Proxy (z. B. nginx + mTLS),
>   bevor Sie ihn extern verfügbar machen.
> - Lokale Pfade und `file://`-URLs werden über HTTP **automatisch abgelehnt**, um zu
>   verhindern, dass nicht authentifizierte Aufrufer beliebige Host-Dateien lesen. Nur
>   entfernte Git- und `.zip`-URLs werden akzeptiert.

## Schwachstellenmuster

SkillSpector erkennt **71 Schwachstellenmuster** in 17 Kategorien:

### Prompt-Injection (6 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| P1 | Anweisungsüberschreibung | HOCH | Befehle, um Sicherheitsbeschränkungen zu ignorieren |
| P2 | Versteckte Anweisungen | HOCH | Bösartige Anweisungen in Kommentaren/unsichtbarem Text |
| P3 | Exfiltrationsbefehle | HOCH | Anweisungen, Kontext extern zu übertragen |
| P4 | Verhaltensmanipulation | MITTEL | Subtile Anweisungen, die Agentenentscheidungen verändern |
| P5 | Schädlicher Inhalt | KRITISCH | Anweisungen, die körperlichen Schaden verursachen könnten |
| P9 | Leerzeichen-Auffüllung | MITTEL | Große Leerzeichen-Auffüllung, die Anweisungen unterhalb/neben dem sichtbaren Bereich versteckt |

### Anti-Verweigerung (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| AR1 | Verweigerungsunterdrückung | HOCH | Anweisungen, niemals zu verweigern oder immer zu befolgen (z. B. „niemals verweigern", „immer befolgen") |
| AR2 | Haftungsausschluss-Unterdrückung | HOCH | Anweisungen, Warnungen, Haftungsausschlüsse oder ethische Kommentare wegzulassen (z. B. „keine Haftungsausschlüsse", „nicht moralisieren") |
| AR3 | Aufhebung der Sicherheitsrichtlinie | HOCH | Jailbreak-Rahmen, der Schutzmechanismen aufhebt (z. B. „Sie haben keine Einschränkungen", „ignorieren Sie Ihre Richtlinien", „tun Sie jetzt alles") |

### Datenextfiltration (4 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| E1 | Externe Übertragung | MITTEL | Senden von Daten an externe URLs |
| E2 | Umgebungsvariablen-Ernte | HOCH | Aufzählen, Kopieren oder Durchsuchen von Umgebungsdaten, um Geheimnisse zu sammeln |
| E3 | Dateisystem-Aufzählung | MITTEL | Durchsuchen von Verzeichnissen nach sensiblen Dateien |
| E4 | Kontextleck | HOCH | Externe Übertragung von Gesprächskontext |

### Privilegienerweiterung (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| PE1 | Übermäßige Berechtigungen | NIEDRIG | Anfordern von Zugriff über die angegebene Funktionalität hinaus |
| PE2 | Sudo/Root-Ausführung | MITTEL | Aufrufen erhöhter Systemprivilegien |
| PE3 | Anmeldedaten-Zugriff | HOCH | Lesen von SSH-Schlüsseln, Tokens, Passwörtern |

### Lieferkette (9+ Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| SC1 | Nicht festgepinnte Abhängigkeiten | NIEDRIG | Keine Versionsbeschränkungen für Pakete |
| SC2 | Abruf externer Skripte | HOCH | curl \| bash und Remote-Codeausführung |
| SC3 | Verschleierter Code | HOCH | Base64/hex-kodierte Ausführung |
| SC4 | Bekannte verwundbare Abhängigkeiten | HOCH | Abhängigkeiten mit bekannten CVEs (Live-OSV.dev-Abfrage) |
| SC5 | Verlassene Abhängigkeiten | MITTEL | Ungepflegte Pakete ohne Sicherheitsupdates |
| SC6 | Typosquatting | HOCH | Paketnamen, die beliebten Paketen ähneln |
| SC8 | Mitgelieferter Python-Bytecode | HOCH | `__pycache__` / `.pyc` vorhanden (Discovery überspringt; bösartiger Bytecode umgeht) |
| SC9 | Verstecktes ausführbares Artefakt | HOCH | Ausführbare Datei, die in einem Dokumentcontainer oder verstecktem/getarntem Artefakt verschachtelt ist |

### Übermäßige Handlungsbefugnis (5 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| EA1 | Uneingeschränkter Tool-Zugriff | HOCH | Uneingeschränkter Tool-Zugriff ohne Einschränkungen |
| EA2 | Autonome Entscheidungsfindung | HOCH | Entscheidungen mit hoher Auswirkung ohne menschliche Kontrolle |
| EA3 | Scope-Ausweitung | MITTEL | Fähigkeiten, die über den angegebenen Zweck hinausgehen |
| EA4 | Unbegrenzter Ressourcenzugriff | MITTEL | Keine Ratenbegrenzungen oder Kontingente für den Ressourcenverbrauch |
| EA5 | Auswahl externer Modelle oder Anbieter | MITTEL/HOCH | Modell-/Anbieter-Pins oder Coding-CLI-Shell-Aufrufe, die Abrechnungskonten wechseln können |

### Ausgabebehandlung (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| OH1 | Unvalidierte Ausgabe-Injektion | HOCH | Modellausgabe ohne Bereinigung verwendet |
| OH2 | Kontextübergreifende Ausgabe | MITTEL | Ausgabe fließt ohne Validierung über Vertrauensgrenzen |
| OH3 | Unbegrenzte Ausgabe | MITTEL | Keine Begrenzungen für Ausgabegröße oder Generierungsrate |

### System-Prompt-Leckage (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| P6 | Direktes Leck | HOCH | Anweisungen, die System-Prompts oder interne Regeln offenlegen |
| P7 | Indirekte Extraktion | MITTEL | Extraktion durch Umformulierung, Übersetzung oder Seitenkanäle |
| P8 | Tool-basierte Exfiltration | HOCH | System-Prompts, die über Dateischreibvorgänge oder Netzwerkanfragen exfiltriert werden |

### Speichervergiftung (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| MP1 | Persistente Kontext-Injektion | HOCH | Inhalte, die darauf ausgelegt sind, über Interaktionen hinweg zu bestehen |
| MP2 | Kontextfenster-Auffüllung | MITTEL | Füllinhalte, die Sicherheitsbeschränkungen verdrängen |
| MP3 | Speichermanipulation | HOCH | Manipulation des Agentenspeichers oder gespeicherter Zustände |

### Tool-Missbrauch (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| TM1 | Tool-Parameter-Missbrauch | HOCH | Präparierte Parameter für unbeabsichtigtes Verhalten (shell=True, --force) |
| TM2 | Verkettungs-Missbrauch | HOCH | Tool-Ketten, die einzelne Sicherheitsprüfungen umgehen |
| TM3 | Unsichere Standardwerte | MITTEL | Übermäßig freizügige Standardwerte (deaktiviertes TLS, keine Authentifizierung) |

### Schurken-Agent (2 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| RA1 | Selbstmodifikation | KRITISCH | Ändern des eigenen Codes oder der Konfiguration zur Laufzeit |
| RA2 | Sitzungspersistenz | HOCH | Unbefugte Persistenz über Cron-Jobs oder Startskripte |

### Trigger-Missbrauch (3 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| TR1 | Übermäßig breiter Trigger | MITTEL | Triggermuster, die auf gebräuchliche Wörter passen |
| TR2 | Schattenbefehls-Trigger | HOCH | Trigger, die eingebaute Befehle oder andere Skills überschatten |
| TR3 | Keyword-Köder-Trigger | MITTEL | Generische Trigger, die darauf ausgelegt sind, die Aktivierung zu maximieren |

### Verhaltens-AST (9 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| AST1 | exec()-Aufruf | KRITISCH | Direkter exec(), der beliebige Codeausführung ermöglicht |
| AST2 | eval()-Aufruf | HOCH | Direktes eval(), das beliebige Ausdrücke auswertet |
| AST3 | Dynamischer Import | HOCH | \_\_import\_\_(), das zur Laufzeit beliebige Module lädt |
| AST4 | subprocess-Aufruf | HOCH | Externe Befehlsausführung über subprocess |
| AST5 | os.system / exec-Familie | HOCH | Shell-Befehle über das os-Modul |
| AST6 | compile()-Aufruf | MITTEL | Erstellung von Codeobjekten aus Zeichenfolgen |
| AST7 | Dynamisches getattr() | MITTEL | Beliebiger Attributzugriff mit nicht-literalen Namen |
| AST8 | Gefährliche Ausführungskette | KRITISCH | exec/eval kombiniert mit dynamischer Quelle (Netzwerk, kodierte Daten) |
| AST9 | Reflektiver getattr()-Sink | HOCH | Reflektives exec über `getattr(os,'system')` / `getattr(builtins,'exec')`, das AST1/AST5 umgeht |

### Taint-Tracking (5 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| TT1 | Direkter Taint-Fluss | HOCH | Daten fließen direkt von einer Quelle zu einer Senke ohne Bereinigung |
| TT2 | Variablenvermittelter Taint-Fluss | MITTEL | Daten fließen über Zwischenvariablen von der Quelle zur Senke |
| TT3 | Anmeldedaten-Exfiltrationskette | KRITISCH | Anmeldedaten (Umgebungsvariablen, Geheimnisse) fließen zu Netzwerk-Ausgabesenken |
| TT4 | Dateilesen zu Netzwerk-Exfiltration | HOCH | Dateiinhalte fließen zu Netzwerk-Ausgabesenken |
| TT5 | Externe Eingabe zu Codeausführung | KRITISCH | Netzwerk- oder Benutzereingaben fließen zu exec/eval/subprocess-Senken |

### YARA-Signaturen (4 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| YR1 | Malware-Übereinstimmung | KRITISCH | YARA-Regelübereinstimmung für bekannte Malware-Signaturen |
| YR2 | Webshell-Übereinstimmung | KRITISCH | YARA-Regelübereinstimmung für Webshell-Muster |
| YR3 | Cryptominer-Übereinstimmung | HOCH | YARA-Regelübereinstimmung für Krypto-Mining-Indikatoren |
| YR4 | Hack-Tool-/Exploit-Übereinstimmung | HOCH | YARA-Regelübereinstimmung für Hack-Tools oder Exploit-Code |

### MCP Least Privilege (4 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| LP1 | Nicht deklarierte Fähigkeit | HOCH | Code verwendet Fähigkeiten, die nicht in den deklarierten Berechtigungen aufgeführt sind |
| LP2 | Wildcard-Berechtigung | MITTEL | Berechtigungsliste enthält Wildcards (\*, all, full, any) |
| LP3 | Fehlende Berechtigungsdeklaration | MITTEL | Kein Berechtigungsfeld, aber Code hat erkennbare Fähigkeiten |
| LP4 | Überdeklarierte Berechtigung | NIEDRIG | Berechtigung deklariert, aber keine entsprechende Codefähigkeit gefunden |

### MCP-Tool-Vergiftung (4 Muster)

| ID | Muster | Schweregrad | Beschreibung |
|----|---------|----------|-------------|
| TP1 | Versteckte Anweisungen | HOCH | Versteckte Anweisungen in Metadaten (HTML-Kommentare, Nullbreitenzeichen, Base64, Daten-URIs) |
| TP2 | Unicode-Täuschung | HOCH | Homoglyphen, RTL-Overrides, gemischtsprachige Bezeichner in Tool-Metadaten |
| TP3 | Parameterbeschreibungs-Injektion | MITTEL | Injektionsmuster in Parameterdefinitionen (Overrides, System-Tokens, bösartige Standardwerte) |
| TP4 | Beschreibungs-Verhaltens-Diskrepanz | MITTEL | Deklarierte Tool-Beschreibung entspricht nicht dem tatsächlichen Codeverhalten (LLM-gestützt) |

Alle erkannten Muster sind in den obigen Tabellen aufgeführt.

## Risikobewertung

### Bewertungsberechnung

- **KRITISCHE Probleme**: +50 Punkte
- **HOHE Probleme**: +25 Punkte
- **MITTEL Probleme**: +10 Punkte
- **NIEDRIGE Probleme**: +5 Punkte
- **Ausführbare Skripte**: 1,3-facher Multiplikator

### Schweregradstufen

| Punktzahl | Schweregrad | Empfehlung |
|-------|----------|----------------|
| 0-20 | NIEDRIG | SICHER |
| 21-50 | MITTEL | VORSICHT |
| 51-80 | HOCH | NICHT INSTALLIEREN |
| 81-100 | KRITISCH | NICHT INSTALLIEREN |

## Beispielausgabe

### Terminalausgabe```
 SkillSpector Security Report  v2.0.0

Skill: suspicious-skill
Source: ./suspicious-skill/
Scanned: 2026-01-29 10:30:00 UTC

        Risk Assessment
 Metric          Value
 Score           78/100
 Severity        HIGH
 Recommendation  DO NOT INSTALL

        Components (3)
 File              Type      Lines  Executable
 SKILL.md          markdown    142  No
 scripts/sync.py   python       87  Yes
 requirements.txt  text          3  No

Issues (2)

  HIGH: Env Variable Harvesting (E2)
    Location: scripts/sync.py:23
    Finding: for key, val in os.environ.items():...
    Confidence: 94%
    Explanation: This code collects environment variables containing
    API keys and secrets, then sends them to an external server.

  HIGH: External Transmission (E1)
    Location: scripts/sync.py:45
    Finding: requests.post("https://api.skill.io/env"...
    Confidence: 89%
    Explanation: Data is being sent to an external server. Combined
    with env harvesting above, this indicates credential exfiltration.

Konfiguration

Umgebungsvariablen

Variable	Beschreibung	Erforderlich
`SKILLSPECTOR_PROVIDER`	Aktiver LLM-Anbieter: `openai`, `anthropic`, `anthropic_proxy`, `bedrock`, `nv_build`, `claude_cli`, `codex_cli` oder `gemini_cli`. Gehostete Anbieter verwenden die gebündelten `model_registry.yaml`-Standardwerte; `claude_cli` und `codex_cli` greifen auf das Standardmodell der lokalen CLI-Laufzeit zurück, sofern `SKILLSPECTOR_MODEL` nicht gesetzt ist. Standardwert: `nv_build`.	Optional
`NVIDIA_INFERENCE_KEY`	Anmeldedaten für den `nv_build`-Anbieter (build.nvidia.com).	Erforderlich für LLM-Analyse, wenn `SKILLSPECTOR_PROVIDER=nv_build`
`OPENAI_API_KEY`	Anmeldedaten für den OpenAI-Anbieter (`SKILLSPECTOR_PROVIDER=openai`). Dient außerdem als Fallback der Stufe 2 im Anmeldedaten-Wasserfall, wenn der aktive Anbieter keine Anmeldedaten zurückgibt.	Erforderlich für LLM-Analyse, wenn `SKILLSPECTOR_PROVIDER=openai`
`OPENAI_BASE_URL`	Überschreibt den OpenAI-Endpunkt (z. B. für Ollama).	Optional
`SKILLSPECTOR_REASONING_EFFORT`	Optionale, anbieter- und modellabhängige Einstellung für den Reasoning-Aufwand. Nicht leere Werte werden gekürzt und unverändert durchgereicht; nicht gesetzt oder leer bleibt das anbieterspezifische Standardverhalten erhalten.	Optional
`SKILLSPECTOR_OUTPUT_LANGUAGE`	Kurze, einzeilige Sprachbezeichnung (Buchstaben, Zahlen, Leerzeichen, `_` oder `-`; maximal 64 Zeichen) für menschenlesbaren LLM-Befundtext wie Nachrichten, Erklärungen und Abhilfemaßnahmen. Regel-IDs, Schweregrade, Pfade, Code und andere maschinenlesbare Werte bleiben unverändert. Nicht gesetzt, leer oder ungültig behält die Standard-Ausgabesprache bei.	Optional
`SKILLSPECTOR_TEMPERATURE`	Optionale Sampling-Temperatur von `0` bis `1` für gehostete Anbieter. Nicht gesetzt oder leer bleibt der Anbieterstandard erhalten. Niedrigere Werte können die Lauf-zu-Lauf-Variation verringern, garantieren aber keine identische Ausgabe.	Optional
`SKILLSPECTOR_SEED`	Optionaler ganzzahliger Sampling-Seed für OpenAI-kompatible und Azure-OpenAI-Anbieter. Andere gehostete Anbieter und CLI-Anbieter erhalten ihn nicht. Die Unterstützung durch den Anbieter bleibt modellabhängig.	Optional
`ANTHROPIC_API_KEY`	Anmeldedaten für den Anthropic-Anbieter (`SKILLSPECTOR_PROVIDER=anthropic`).	Erforderlich für LLM-Analyse, wenn `SKILLSPECTOR_PROVIDER=anthropic`
`ANTHROPIC_BASE_URL`	Überschreibt den nativen Anthropic-Endpunkt (Standard: `https://api.anthropic.com`).	Optional
`ANTHROPIC_PROXY_ENDPOINT_URL`	Vollständige Endpunkt-URL für den Anthropic-Proxy-Anbieter (Vertex-Stil raw-predict).	Erforderlich, wenn `SKILLSPECTOR_PROVIDER=anthropic_proxy`
`ANTHROPIC_PROXY_API_KEY`	Bearer-Token für den Anthropic-Proxy-Anbieter.	Erforderlich, wenn `SKILLSPECTOR_PROVIDER=anthropic_proxy`
`ANTHROPIC_PROXY_API_VERSION`	`anthropic_version`-Wert, der im Anforderungstext gesendet wird (Standard: `vertex-2023-10-16`).	Optional
`AWS_PROFILE`	Benanntes AWS-Profil für den Bedrock-Anbieter – authentifiziert über SigV4 durch boto3. Wenn nicht gesetzt, greift die standardmäßige boto3-Anmeldedatenkette (Umgebungsvariablen, Instanzmetadaten, SSO usw.).	Optional (verwendet, wenn `SKILLSPECTOR_PROVIDER=bedrock`)
`AWS_REGION`	AWS-Region für den Bedrock-Runtime-Endpunkt. Standardwert: `us-west-2`.	Optional (verwendet, wenn `SKILLSPECTOR_PROVIDER=bedrock`)
`SKILLSPECTOR_MODEL`	Überschreibt das Modell des aktiven Anbieters. Für gehostete Anbieter ersetzt dies den gebündelten Standardwert aus der LLM-Analyse-Tabelle. Für `claude_cli` und `codex_cli` wird dies als `--model` weitergegeben, anstatt auf den Fallback der lokalen CLI-Laufzeit zurückzugreifen.	Optional
`SKILLSPECTOR_MODEL_REGISTRY`	Überschreibt die gebündelte anbieterspezifische YAML-Registry (`src/skillspector/providers/<provider>/model_registry.yaml`) mit einem benutzerdefinierten Pfad.	Optional
`SKILLSPECTOR_LOG_LEVEL`	Protokollebene: `DEBUG`, `INFO`, `WARNING`, `ERROR` (Standard: `WARNING`).	Optional

CLI-Anbieter (claude_cli, codex_cli): Kein API-Schlüssel erforderlich. Die Authentifizierung wird vollständig von der eigenen Anmeldesitzung der Agent-CLI verwaltet (claude auth login / codex login). SkillSpector liest oder leitet niemals API-Schlüssel weiter, wenn diese Anbieter aktiv sind. Der Unterprozess wird in einer gehärteten Sandbox ausgeführt: Tools deaktiviert, kein MCP, schreibgeschützter Sandbox-Modus (codex), und nicht vertrauenswürdige Skill-Inhalte werden nur über stdin übermittelt.

CLI-Optionen```bash

skillspector scan --help

Options: -f, --format [terminal|json|markdown|sarif] Output format [default: terminal] -o, --output PATH Output file path --no-llm Skip LLM analysis (static only) --yara-rules-dir PATH Extra YARA rules directory -b, --baseline PATH Suppress findings listed in a baseline --show-suppressed List baseline-suppressed findings -V, --verbose Show detailed progress --help Show this message and exit

Generate a baseline of all current findings (see docs/SUPPRESSION.md)

skillspector baseline [-o FILE] [--no-llm] [--reason TEXT]

## Integration von SkillSpector

SkillSpector ist darauf ausgelegt, von anderen Tools gesteuert zu werden (CI-Pipelines, Installations-Gates, Editor-Integrationen). Sein Exit-Code und die JSON-Ausgabe sind ein stabiler Vertrag.

### Exit-Codes

`skillspector scan` endet mit:

| Code | Bedeutung |
|------|-----------|
| `0` | Scan abgeschlossen, `risk_score` ≤ 50 (Empfehlung `SAFE` oder `CAUTION`) |
| `1` | Scan abgeschlossen, `risk_score` > 50 (Empfehlung `DO_NOT_INSTALL`) |
| `2` | Fehler (ungültige Eingabe, nicht lesbare Quelle, interner Fehler) |

> Der Exit-Code fasst `SAFE` und `CAUTION` zu `0` zusammen. Um unterschiedlich darauf zu reagieren (z. B. *warnen* bei `CAUTION`, aber *blockieren* bei `DO_NOT_INSTALL`), lesen Sie das Feld `recommendation` aus der JSON-Ausgabe, anstatt sich auf den Exit-Code zu verlassen.

### Maschinenlesbare Ausgabe

`--format json` erzeugt einen JSON-Bericht; ohne `--output`/`-o` wird er auf stdout geschrieben:```bash
skillspector scan ./my-skill/ --format json

The top-level shape is (this example shows a full LLM-backed scan; with --no-llm, metadata.llm_requested is false):```json { "skill": { "name": "...", "source": "...", "scanned_at": "<ISO 8601>" }, "risk_assessment": { "score": 0, "severity": "LOW", "recommendation": "SAFE" }, "components": [ { "path": "...", "type": "...", "lines": 0, "executable": false, "size_bytes": 0 } ], "issues": [ { "id": "...", "category": "...", "severity": "...", "confidence": 0.0, "location": { "file": "...", "start_line": 0 } } ], "metadata": { "has_executable_scripts": false, "skillspector_version": "...", "llm_requested": true, "llm_available": true, "inference_usage": [ { "node": "semantic_security_discovery", "request_kind": "structured_output", "provider": "nv_inference", "model": "azure/anthropic/claude-opus-4-6", "model_source": "provider_response", "usage_source": "provider_response", "prompt_tokens": 1000, "completion_tokens": 100, "cached_tokens": 400, "cache_write_tokens": 50, "total_tokens": 1100 } ] } }

- `risk_assessment.severity` ∈ `LOW | MEDIUM | HIGH | CRITICAL`.
- `risk_assessment.recommendation` ∈ `SAFE | CAUTION | DO_NOT_INSTALL`, abgeleitet aus der Schwere: `LOW → SAFE`, `MEDIUM → CAUTION`, `HIGH`/`CRITICAL → DO_NOT_INSTALL`.
- `metadata.llm_error` erscheint nur, wenn eine LLM-Analyse angefordert, aber nicht verfügbar war.
- `metadata.inference_usage` enthält einen bereinigten Datensatz pro LLM-Antwort, wenn der
  Anbieter Token-Zähler offenlegt. Es ist eine leere Liste, wenn die Nutzung nicht verfügbar ist;
  SkillSpector schätzt fehlende Token niemals. Die Prompt-Summen umfassen Cache-Lese-
  und -Schreibvorgänge, sodass die nachgelagerte Preisberechnung diese Partitionen sicher trennen kann.
  `model_source` unterscheidet ein unabhängig identifiziertes Anbietermodell von
  dem exakt angeforderten Modell, das verwendet wird, wenn die Antwortidentität fehlt oder mehrdeutig ist.
  SkillSpector sendet derzeit keine Anthropic-Prompt-Cache-Steuerungen, daher können
  seine Scan-Anfragen die separaten 5-Minuten- oder 1-Stunden-Cache-Schreibstufen nicht auswählen;
  TTL-spezifische Antwortfelder werden defensiv in den aggregierten
  Cache-Schreibzähler normalisiert.
- Siehe [Inference usage telemetry](https://github.com/nvidia/skillspector/blob/main/docs/INFERENCE_USAGE.md) für den vollständigen
  Herkunfts-, Cache-Abrechnungs-, Datenschutz-, Fail-Closed-Erfassungs- und nachgelagerten
  Preisvertrag.
- Die vollständige Form pro Problem wird durch `Finding.to_dict()` in [models.py](https://github.com/nvidia/skillspector/blob/main/src/skillspector/models.py) definiert; verlassen Sie sich auf die obigen Felder und behandeln Sie zusätzliche Felder als Best-Effort.

Für CI/IDE-Tooling gibt `--format sarif` SARIF 2.1.0 aus.

### Empfohlene Gate-Zuordnung

Wenn Sie SkillSpector als Installations-Gate verwenden, ordnen Sie die Empfehlung einer Aktion zu:

| `recommendation` | Vorgeschlagene Aktion |
|------------------|------------------|
| `SAFE` | zulassen |
| `CAUTION` | Benutzer auffordern / warnen |
| `DO_NOT_INSTALL` | blockieren |

SkillSpector berechnet die Score-Bandbreite und die Empfehlung; wie streng das Gate ist (z. B. ob `CAUTION` in CI blockiert), ist eine Richtlinienentscheidung des integrierenden Tools.

## Entwicklung

### Einrichtung

Alle `make`-Ziele setzen voraus, dass bereits eine virtuelle Umgebung erstellt und aktiviert ist. Das Makefile verwendet **uv**, falls verfügbar, sonst **pip**.```bash
# Clone, create venv, activate, install dev dependencies
git clone https://github.com/NVIDIA/skillspector.git
cd skillspector
uv venv .venv && source .venv/bin/activate
# or: python3 -m venv .venv && source .venv/bin/activate
make install-dev

# Run tests
make test

# Run tests with coverage
make test-cov

# Run linting
make lint

# Format code
make format

Funktionsweise

SkillSpector verwendet eine zweistufige Erkennungspipeline:

Stufe 1: Statische Analyse

Schneller regex-basierter Musterabgleich über 11 statische Analysatoren
AST-basierte Verhaltensanalyse zur Erkennung gefährlicher Aufrufe (exec, eval, subprocess usw.)
Live-Schwachstellenabfragen über OSV.dev für bekannte CVEs in Abhängigkeiten
Scannt alle analysierbaren Dateien im Skill
Hohe Trefferquote (erkennt die meisten Probleme)
Mittlere Präzision (einige Fehlalarme)

Eine gültige OpenSSF-Modellsignatur auf Root-Ebene (skill.oms.sig) wird im Komponenteninventar als Typ oms_signature aufbewahrt, aber von der statischen und LLM-Inhaltsanalyse ausgeschlossen. OMS-Bundles enthalten zwangsläufig lange base64-codierte Payload-, Signatur- und Zertifikatsfelder; generische Prüfungen auf verschleierten Code können diese Felder andernfalls fälschlich als versteckten ausführbaren Inhalt einstufen. Der Erkennungsmechanismus prüft die minimale OMS-DSSE/in-toto-Struktur; er verifiziert nicht die Signatur, die Zertifikatskette, den Transparenzprotokoll-Eintrag oder die Identität des Unterzeichners. Ungültige oder nicht erkannte Signaturdateien werden normal gescannt.

Stufe 2: LLM-semantische Analyse (optional)

Bewertet Kontext und Absicht
Filtert Fehlalarme heraus
Liefert für Menschen verständliche Erklärungen
Verbessert die Präzision auf ~87 %

Der LLM-Prompt enthält Anti-Jailbreak-Schutzmechanismen, um zu verhindern, dass bösartige Skills die Analyse manipulieren.

Live-Schwachstellenabfragen (SC4)

SC4 verwendet die OSV.dev-API, um Abhängigkeiten gegen die vollständige Open-Source-Schwachstellendatenbank zu prüfen – sie umfasst Zehntausende von Advisories für PyPI und npm.

Kein API-Schlüssel erforderlich – OSV.dev ist kostenlos und ohne Authentifizierung nutzbar.
Batch-Abfragen – alle Abhängigkeiten werden in einem einzigen HTTP-Aufruf geprüft.
Automatischer Fallback – wenn OSV.dev nicht erreichbar ist (abgeschottetes/offline Netzwerk), wird eine kleine integrierte Fallback-Liste verwendet.
Caching – Ergebnisse werden für 1 Stunde im Speicher zwischengespeichert, um redundante API-Aufrufe während einer Sitzung zu vermeiden.

Das Tool benötigt ausgehenden HTTPS-Zugriff auf api.osv.dev für Live-Schwachstellendaten. Wenn dieser nicht verfügbar ist, beschränken sich die Erkenntnisse auf die statische Fallback-Liste.

Vertrauensmodell und Datenabfluss

SkillSpector ist Defense-in-Depth, keine Sandbox. Wisse, was es tut und was nicht, bevor du dich darauf verlässt:

Es führt den gescannten Skill niemals aus. Die gesamte Analyse ist statisch (Regex, Python-AST, YARA) plus optionale LLM-Bewertung von Dateiinhalten – der Code des Skills wird nie ausgeführt.
Die LLM-Analyse sendet analysierbare Dateiinhalte an den konfigurierten Anbieter. Wenn die LLM-Analyse aktiviert ist (Standard), werden Dateiinhalte an den aktiven SKILLSPECTOR_PROVIDER-Endpunkt gesendet. Erkannte OMS-Signaturdateien sind ausgeschlossen. Verwende --no-llm, um Inhalte lokal zu halten (nur statische Analyse).
SC4 sendet Abhängigkeitsnamen an OSV.dev. Die Supply-Chain-Prüfung fragt OSV.dev mit den Paketnamen und -versionen ab, die der Skill deklariert, um bekannte CVEs zu ermitteln. Dies ist grundlegend für die Prüfung und läuft auch mit --no-llm. Es werden Abhängigkeitskoordinaten (keine Dateiinhalte) gesendet, kein API-Schlüssel ist erforderlich, und bei Nichterreichbarkeit von OSV.dev wird auf eine gebündelte Liste zurückgegriffen.
Es sandboxt den Host nicht. SkillSpector kennzeichnet riskante Muster bevor du einen Skill installierst; es enthält oder isoliert keinen Skill, den du trotzdem installierst.

Einschränkungen

Nicht-englische Inhalte: Muster in anderen Sprachen können übersehen werden
Bildbasierte Angriffe: Text in Bildern kann nicht analysiert werden
Verschlüsselter/Binärcode: Kompilierter oder verschlüsselter Inhalt kann nicht analysiert werden
Laufzeitverhalten: Nur statische Analyse, keine dynamische Ausführung
Offline-SC4: Ohne Netzwerkzugriff auf api.osv.dev verwendet SC4 eine kleine statische Fallback-Liste

Forschungshintergrund

Basiert auf der Forschung aus „Agent Skills in the Wild: An Empirical Study of Security Vulnerabilities at Scale" (Liu et al., 2026):

Datensatz: 42.447 Skills aus großen Marktplätzen
Verwundbar: 26,1 % enthalten mindestens eine Schwachstelle
Hoher Schweregrad: 5,2 % zeigen wahrscheinlich bösartige Absicht
Kernerkenntnis: Skills mit ausführbaren Skripten sind 2,12-mal häufiger verwundbar

Python-API-Integration```python

from skillspector import graph

Invoke the LangGraph workflow

result = graph.invoke({ "input_path": "/path/to/skill", "output_format": "json", # terminal, json, markdown, or sarif "use_llm": True, # False for static-only analysis })

Access results

print(f"Risk Score: {result['risk_score']}/100") print(f"Severity: {result['risk_severity']}") print(f"Recommendation: {result['risk_recommendation']}")

for finding in result["filtered_findings"]: print(f"[{finding['severity']}] {finding['rule_id']}: {finding['message']}")

## Lizenz

Apache License 2.0 – Details siehe [LICENSE](https://github.com/nvidia/skillspector/blob/main/LICENSE).

## Mitwirken

Beiträge sind willkommen! Bitte lesen Sie unsere Richtlinien für Mitwirkende und reichen Sie Pull Requests ein.

## Support

- **Probleme**: [GitHub Issues](https://github.com/NVIDIA/skillspector/issues)

SkillSpector v2.11.1

SkillSpector

Überblick

Dokumentation

Funktionen

Schnellstart

Installation

Update later: uv tool update skillspector

Clone the repository

Create and activate virtual environment

or: python3 -m venv .venv && source .venv/bin/activate

Install for production use

Or install with development dependencies

Grundlegende Verwendung```bash

Scan a local skill directory

Scan a single SKILL.md file

Scan a Git repository

Scan a zip file

Batch-Scanning

LLM-Analyse

Stock OpenAI

Anthropic

Anthropic via Vertex-style proxy (corporate gateways, GCP Vertex AI)

AWS Bedrock (Claude via SigV4)

Optional: select an AWS named profile. When unset, the standard

boto3 credential chain (env vars, instance metadata, SSO, etc.) resolves.

export AWS_PROFILE=my-profile

Default model: us.anthropic.claude-sonnet-4-6-20250915-v1:0

Override with any Bedrock model ID, cross-region inference-profile

ID, or your own application-inference-profile ARN:

export SKILLSPECTOR_MODEL=us.anthropic.claude-opus-4-6-20250915-v1:0

NVIDIA build.nvidia.com

Local Claude CLI — no API key; uses your existing claude auth login session

Requires: claude CLI installed and authenticated (claude auth login)

Uses the local Claude CLI runtime fallback unless SKILLSPECTOR_MODEL is set.

export SKILLSPECTOR_MODEL=claude-sonnet-4-6

Local Codex CLI — no API key; uses your existing codex login session

Requires: codex CLI installed and authenticated

Local Ollama or any OpenAI-compatible endpoint

Override the provider's default model

Skip LLM analysis (faster, static analysis only)

Konfiguration

Umgebungsvariablen

CLI-Optionen```bash

Generate a baseline of all current findings (see docs/SUPPRESSION.md)

Funktionsweise

Stufe 1: Statische Analyse

Stufe 2: LLM-semantische Analyse (optional)

Live-Schwachstellenabfragen (SC4)

Vertrauensmodell und Datenabfluss

Einschränkungen

Forschungshintergrund

Python-API-Integration```python

Invoke the LangGraph workflow

Access results

Kategorien

Local Claude CLI — no API key; uses your existing `claude auth login` session

Local Codex CLI — no API key; uses your existing `codex login` session