OreWatch

Multi-Ökosystem-Erkennung bösartiger Pakete und Supply-Chain-Sicherheitsscanner

Ein produktionsreifes Sicherheitstool zur Erkennung bösartiger Pakete und Supply-Chain-Bedrohungen in den Ökosystemen npm, PyPI, Maven, RubyGems, Go und Cargo. Nutzt automatisierte Bedrohungsinformationssammlung von vertrauenswürdigen Sicherheitsquellen, um kompromittierte Abhängigkeiten in Ihren Projekten zu identifizieren.

OreWatch ist der Produkt- und PyPI-Paketname. Der aktuelle Quellrepository-Pfad verwendet noch ore-mal-pkg-inspector.

Videos

Installation

https://github.com/rapticore/ore-mal-pkg-inspector/issues/2#issue-4215016110

OreWatch und Cursor

https://github.com/rapticore/ore-mal-pkg-inspector/issues/3#issue-4215017945

OreWatch und CodeX

https://github.com/rapticore/ore-mal-pkg-inspector/issues/4#issue-4215019385

OreWatch und Claude-Code

https://github.com/rapticore/ore-mal-pkg-inspector/issues/5#issue-4215021599

Inhaltsverzeichnis

• Das Problem
• Die Lösung
• Hauptfunktionen
• Warum OreWatch?
• Hier starten
• Schnellstart
  • Voraussetzungen
  • Installation
  • Erster Scan
• Verwendung
  • Grundlegende Befehle
  • Erweiterte Verwendung
  • Kommandozeilen-Referenz
  • Hintergrundüberwachung
• Einführungsleitfaden
• Verteilung
  • Verwaltetes macOS-Rollout
• Protokollierung & Debugging
• Ausgabe & Berichte
• CI/CD-Integration
• Fehlerbehebung
• FAQ
• Mitwirken
• Sicherheitsrichtlinie
• Fahrplan
• Lizenz
• Unterstützung
• Danksagungen

Das Problem

Angriffe auf die Lieferkette sind heute der primäre Bedrohungsvektor für Software-Kompromittierungen. Allein im Jahr 2024 wurden tausende bösartige Pakete auf npm, PyPI und anderen Paketregistern veröffentlicht, die Entwickler mit Typosquatting, Dependency Confusion und ausgeklügelten Malware-Kampagnen wie Shai-Hulud angriffen.

Die Herausforderung: Organisationen und Entwickler müssen:

• Abhängigkeiten über mehrere Programmier-Ökosysteme scannen
• Mit sich schnell entwickelnden Bedrohungsinformationen aus mehreren Quellen auf dem Laufenden bleiben
• Nicht nur bekannte bösartige Pakete erkennen, sondern auch Indikatoren für Kompromittierungen (IoCs)
• Sicherheits-Scans in bestehende Entwicklungsworkflows integrieren
• Schnell auf neu entdeckte Bedrohungen reagieren

Die Lücke: Bestehende Lösungen sind oft:

• Auf ein einzelnes Ökosystem beschränkt (nur npm, nur PyPI usw.)
• Abhängig von manueller Wartung der Bedrohungsliste
• Fehlende IoC-Erkennungsfähigkeiten
• Schwer in automatisierte Pipelines integrierbar
• Proprietäre Black-Box-Tools ohne Transparenz

Die Lösung

OreWatch adressiert diese Herausforderungen, indem es Folgendes bietet:

Umfassende Multi-Ökosystem-Abdeckung: Ein einzelnes Tool für npm-, PyPI-, Maven-, RubyGems-, Go- und Cargo-Pakete

Automatisierte Bedrohungsinformationen: Sammelt und führt dynamisch Daten von vertrauenswürdigen Sicherheitsforschungsquellen zusammen

Aktive IoC-Erkennung: Identifiziert Shai-Hulud-Angriffsmuster und andere Indikatoren für bösartigen Code über die Paketnamen-Übereinstimmung hinaus

CI/CD-bereit: Entwickelt für nahtlose Integration in GitHub Actions, GitLab CI, Jenkins und andere Automatisierungsplattformen

Open Source und transparent: Vollständige Transparenz der Erkennungslogik, Datenquellen und Scan-Methodik

Hauptfunktionen

Multi-Ökosystem-Unterstützung Scannt npm-, PyPI-, Maven-, RubyGems-, Go- und Cargo-Pakete mit automatischer Ökosystemerkennung anhand der Projektstruktur.

Vereinheitlichte Bedrohungsinformationsdatenbank Prüft gegen dynamisch gesammelte Datenbanken bösartiger Pakete von vertrauenswürdigen Sicherheitsforschungsquellen.

Automatische Ökosystemerkennung Erkennt intelligent Ökosysteme aus Verzeichnisstruktur, Dateinamen und kann mehrere Ökosysteme in einem Durchlauf scannen.

Erkennung von Indikatoren für Kompromittierungen (IoC) Scannt nach Shai-Hulud-Angriffsmustern (Original und 2.0-Varianten), bösartigen Hooks, verdächtigen Workflows und bekannten Payload-Dateien.

Shai-Hulud-Integration Querverweist npm-Pakete mit der umfassenden Liste der von Shai-Hulud betroffenen Pakete von OreNPMGuard.

Strukturierte JSON-Berichterstattung Erzeugt maschinenlesbare JSON-Berichte mit expliziten Metadaten zu Bedrohungsdaten und SARIF-ähnlichen Dateipositionen für Funde.

Flexible Eingabeformate Unterstützt Standard-Abhängigkeitsdateien (package.json, requirements.txt usw.) und generische Paketlisten (Text, JSON, YAML).

Produktionsreife Protokollierung Konfigurierbare Ausführlichkeitsstufen mit den Flags --verbose und --debug für Fehlerbehebung und Prüfpfade.

Sicher und schnell Nur-Lese-Operationen ohne Änderungen an Ihrem Code, optimiert für effizientes Scannen großer Codebasen.

Warum OreWatch?

vs. Ein-Ökosystem-Tools Die meisten Sicherheitsscanner konzentrieren sich auf einen Paketmanager. OreWatch bietet einheitlichen Schutz über sechs große Ökosysteme, wesentlich für moderne polyglotte Entwicklungsumgebungen.

vs. manuelle Bedrohungslisten Statische Listen bösartiger Pakete werden schnell veraltet. Unsere automatischen Sammler holen täglich frische Bedrohungsinformationen von mehreren autoritativen Quellen.

vs. reine Paketnamen-Erkennung Die alleinige Prüfung von Paketnamen übersieht ausgeklügelte Angriffe. Die IoC-Erkennung identifiziert bösartige Codermuster sogar in Paketen, die noch nicht auf Blocklisten stehen.

vs. manuelle Sicherheitsaudits Manuelle Überprüfungen von Abhängigkeiten sind zeitaufwändig und fehleranfällig. Automatisiertes Scannen ermöglicht kontinuierliche Sicherheitsvalidierung in jedem Build.

vs. kommerzielle Black-Box-Tools Proprietäre Tools mangeln an Transparenz in der Erkennungslogik. Als Open-Source-Projekt ist jede Erkennungsregel und Datenquelle prüfbar.

Entstehungsgeschichte OreWatch entstand aus der Entwicklung von OreNPMGuard, einem spezialisierten Scanner für Shai-Hulud-npm-Angriffe. Während dieses Projekts erkannten wir den Bedarf an einer breiteren Multi-Ökosystem-Abdeckung über npm hinaus. Im Dezember 2025 extrahierten und verbesserten wir die Multi-Ökosystem-Erkennungsfähigkeiten in dieses eigenständige Tool, wobei wir den Fokus von OreNPMGuard auf npm beibehielten und OreWatch gleichzeitig der breiteren Entwicklergemeinschaft in allen wichtigen Paket-Ökosystemen dienen lassen.

Hier starten

Wenn Sie OreWatch zum ersten Mal einführen, wählen Sie den kleinsten Pfad, der zu Ihrem Workflow passt:

Empfohlene Erstausführungssequenz für die meisten Entwickler:

1. Installieren Sie OreWatch mit pip install . oder dem veröffentlichten Paket.
2. Führen Sie orewatch monitor quickstart /path/to/project --client <your-client> aus.
3. Überprüfen Sie den Daemon mit orewatch monitor status.
4. Wenn Sie auf macOS sind, starten Sie orewatch monitor menubar für Benachrichtigungen und eine lokale Benutzeroberfläche.

Wenn Sie eine kürzere Installationsanleitung mit kopierbaren Befehlen wünschen, verwenden Sie docs/adoption-guide.md.

Schnellstart

Voraussetzungen

• Python 3.14 oder höher
• pip zum Installieren von Abhängigkeiten
• Git zum Klonen des Repositorys
• Internetverbindung für die anfängliche Einrichtung der Bedrohungsinformationen
• OpenSSL für die signierte Snapshot-Schlüsselerstellung, Veröffentlichung und Verifizierung in Monitor-Snapshot-Workflows

Installation

OreWatch kann über pipx (empfohlen), Homebrew (macOS), pip oder aus dem Quellcode installiert werden. Alle Methoden erzeugen den CLI-Befehl orewatch.

Option 1 — pipx (Empfohlen)

pipx installiert OreWatch in seiner eigenen isolierten Umgebung und macht den Befehl orewatch global verfügbar. Dies ist die beste Option für die meisten Entwickler.```bash

Install pipx if you don't have it

python3.14 -m pip install --user pipx python3.14 -m pipx ensurepath

Install OreWatch

pipx install --python python3.14 orewatch

If you want the macOS menu bar app on a fresh install, use this instead:

pipx install --python python3.14 'orewatch[mac-menubar]'

Verify

orewatch --help

Optional macOS menu bar app

orewatch monitor menubar

Wenn Sie `orewatch` bereits mit pipx installiert haben und später die macOS-Menüleisten-App hinzufügen möchten, injizieren Sie die Cocoa bindings in dieselbe pipx-Umgebung:```bash
pipx inject orewatch pyobjc-framework-Cocoa

Aktualisierung:```bash pipx upgrade orewatch

**Deinstallation:**```bash
pipx uninstall orewatch

Option 2 — Homebrew (macOS)

Für macOS-Benutzer, die von Homebrew verwaltete Installationen bevorzugen:```bash

Add the OreWatch tap

brew tap rapticore/tap

Install

brew install rapticore/tap/orewatch

Verify

orewatch --help

Optional macOS menu bar app

orewatch monitor menubar

**Upgrade:**```bash
brew update && brew upgrade orewatch

Deinstallieren:```bash brew uninstall orewatch brew untap rapticore/tap # optional — removes the tap

> **Note:** Die Homebrew-Formel enthält die Cocoa-Bindungen, die für
> `orewatch monitor menubar` erforderlich sind. Falls eine ältere Homebrew-Installation
> `ModuleNotFoundError: No module named 'AppKit'` meldet, führen Sie
> `brew update && brew reinstall rapticore/tap/orewatch` aus, damit die Formel
> ihre isolierte Python-Umgebung mit Menüleisten-Unterstützung neu aufbaut.

#### Option 3 — pip

Verwenden Sie `pip` für CI-Pipelines, Docker-Images oder wenn Sie Ihre eigenen
virtualenvs verwalten:```bash
# Install into an active Python 3.14 virtualenv or user site
python3.14 -m pip install orewatch

# Pin a version for reproducible CI builds
python3.14 -m pip install orewatch==1.3.0

# If you want the macOS menu bar app on a fresh install, use this instead:
# python3.14 -m pip install 'orewatch[mac-menubar]'

# Verify
orewatch --help

Upgrade:```bash python3.14 -m pip install --upgrade orewatch

#### Option 4 — Quellen-Checkout (Mitwirkende)```bash
# Clone the repository
git clone https://github.com/rapticore/ore-mal-pkg-inspector.git
cd ore-mal-pkg-inspector

# Create and activate a Python 3.14 virtual environment (recommended)
python3.14 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install in editable mode for development
python -m pip install -e .

# Verify
orewatch --help

Überprüfung nach der Installation

Überprüfen Sie nach der Installation mit einer beliebigen Methode, dass OreWatch funktioniert:```bash

Check the CLI is accessible

orewatch --help

List supported manifest filenames

orewatch --list-supported-files

Run a quick scan on the current directory

orewatch .

#### Plattform-Hinweise

| Plattform | Python-Quelle | Hinweise |
|---|---|---|
| **macOS** (Homebrew Python) | `brew install [email protected]` | Empfohlen für Homebrew-Benutzer |
| **macOS** (pyenv) | `pyenv install 3.14` | Am besten für Multi-Version-Setups |
| **Ubuntu / Debian** | `sudo apt install python3.14` oder pyenv | Überprüfen Sie, ob Ihre Distribution 3.14+ ausliefert |
| **Fedora / RHEL** | `sudo dnf install python3.14` oder pyenv | — |
| **Windows (WSL)** | pyenv oder Systempaket | Native Windows ist ungetestet |

> **Python 3.14 ist erforderlich.** OreWatch verwendet Sprachfunktionen, die in
> Python 3.14 eingeführt wurden. Ältere Versionen werden beim Import fehlschlagen.

#### Fehlerbehebung bei der Installation

| Symptom | Lösung |
|---|---|
| `command not found: orewatch` | Stellen Sie sicher, dass der Installationsort in Ihrem `PATH` ist. Für pipx: führen Sie `pipx ensurepath` aus und starten Sie Ihre Shell neu. |
| `ModuleNotFoundError` beim Import | Sie haben möglicherweise mehrere Python-Versionen. Bestätigen Sie, dass die Laufzeit hinter `orewatch` Python 3.14+ ist, und installieren Sie es mit dem passenden Interpreter neu. |
| pipx-Installation schlägt mit Resolver-Fehlern fehl | Aktualisieren Sie pipx: `python3.14 -m pip install --upgrade pipx` |
| Homebrew `orewatch` nach der Installation nicht gefunden | Führen Sie zuerst `brew tap rapticore/tap` aus, und wiederholen Sie dann die Installation. |
| Zugriff verweigert bei pip install | Verwenden Sie `pip install --user orewatch` oder installieren Sie in einer virtualenv. |

_Hinweis: Wenn lokale Bedrohungsdaten fehlen oder veraltet sind, bereiten Paketscans einen Live-Update-Kandidaten vor und fördern ihn erst nach erfolgreicher Anomalieprüfung. Wenn der Kandidat verdächtig aussieht, behält OreWatch den zuletzt bekannten guten Datensatz aktiv._

_Installiertes CLI:_ `orewatch`
_Kompatibilitätsalias:_ `ore-mal-pkg-inspector`

### Erster Scan

**Ein Projektverzeichnis scannen:**```bash
# Auto-detect ecosystem and scan current directory
orewatch .

# Scan specific project path
orewatch /path/to/your/project

# With verbose output to see progress
orewatch /path/to/your/project --verbose

Erwartete Ausgabe:``` Detected multiple ecosystems: npm, pypi Scanning all detected ecosystems...

Scanning npm... Found 2 dependency file(s) for npm Parsing: package.json Parsing: package-lock.json

Scanning pypi... Found 1 dependency file(s) for pypi Parsing: requirements.txt

Extracted 45 unique package(s) across 2 ecosystem(s)

Checking 45 package(s) against malicious databases... Checking 30 npm package(s)... Checking 15 pypi package(s)...

Scanning for Indicators of Compromise...

Generating report...

============================================================ SCAN REPORT SUMMARY

Ecosystem: npm, pypi Total Packages Scanned: 45 Malicious Packages Found: 0 IoCs Found: 0

✅ No malicious packages or IoCs detected

HTML report saved to: scan-output/malicious_packages_report_20251231_120000.html JSON report saved to: scan-output/malicious_packages_report_20251231_120000.json

Wenn Sie möchten, dass OreWatch das Projekt nach diesem ersten Scan weiter überwacht, fahren Sie mit [Background Monitoring](#background-monitoring) fort oder springen Sie direkt zu [docs/adoption-guide.md](https://github.com/rapticore/ore-mal-pkg-inspector/blob/HEAD/docs/adoption-guide.md).

---

## Verwendung

### Grundlegende Befehle

**Verzeichnis scannen (Ökosystem automatisch erkennen):**```bash
# Current directory
orewatch .

# Specific directory
orewatch /home/user/projects/my-app

# With an absolute path
orewatch /home/user/projects/backend-api

Bestimmte Abhängigkeitsdateien scannen:```bash

Ecosystem auto-detected from filename

orewatch --file package.json orewatch --file requirements.txt orewatch --file pom.xml orewatch --file Gemfile orewatch --file go.mod orewatch --file Cargo.toml

**Bestimmtes Ökosystem erzwingen:**```bash
# Override auto-detection
orewatch /path/to/project --ecosystem npm
orewatch /path/to/project --ecosystem pypi
orewatch /path/to/project --ecosystem maven
orewatch /path/to/project --ecosystem rubygems
orewatch /path/to/project --ecosystem go
orewatch /path/to/project --ecosystem cargo

Generische Paketlisten scannen:```bash

Text file (one package per line) - must specify ecosystem

orewatch --file packages.txt --ecosystem pypi

JSON file with package array

orewatch --file packages.json --ecosystem npm

YAML file

orewatch --file packages.yaml --ecosystem npm

### Erweiterte Nutzung

**Benutzerdefinierter Ausgabepfad:**```bash
# Save to custom location
orewatch /path/to/project --output /tmp/scan_report.json

# Save to specific subdirectory
orewatch /path/to/project --output reports/security/$(date +%Y%m%d).json

IoC Scanning-Kontrolle:```bash

Full scan (packages + IoCs) - default behavior

orewatch /path/to/project

Skip IoC scanning for faster package-only checks

orewatch /path/to/project --no-ioc

Only scan for IoCs, skip package database checking

orewatch /path/to/project --ioc-only

**Stiller Modus:**```bash
# Generate report without console summary (useful for scripts)
orewatch /path/to/project --no-summary

Kontrollen für Bedrohungsdaten:```bash

Force a staged live refresh of the default core sources before scanning

orewatch /path/to/project --latest-data

Fail if any requested ecosystem only has partial or missing threat data

orewatch /path/to/project --strict-data

Include experimental sources during collection

orewatch /path/to/project --latest-data --include-experimental-sources

Print the exact dependency filenames the scanner recognizes

orewatch --list-supported-files

**Stapelscanning:**```bash
# Scan multiple projects
for dir in ~/projects/*/; do
    echo "Scanning $dir"
    orewatch "$dir" --output "reports/$(basename $dir).json"
done

Befehlszeilen-Referenz

Scanner-Optionen

Hintergrundüberwachung

Das Repository enthält nun einen lokalen Hintergrundmonitor, der Bedrohungsdaten aktuell hält, Änderungen an Manifesten und Workflows in angemeldeten Projekten überwacht, verzögerte Scans durchführt und Benachrichtigungen für neue oder hochgestufte Ergebnisse aufzeichnet. Die dem Monitor gehörenden Konfigurations- und Zustandsdaten werden außerhalb des Repositorys in benutzereigenen Verzeichnissen gespeichert, sodass ein geklontes Repository das Monitorverhalten nicht vorherbestimmen kann.

OreWatch behandelt den Monitor nun als pro-Benutzer-Singleton. Ein Daemon kann viele Projekte an beliebigen Orten auf der Festplatte überwachen und viele gleichzeitige Claude Code-, Codex-, Cursor-, VS Code-, JetBrains- / PyCharm- und Xcode-Clients bedienen.

End-to-End-Monitor-Setup

1. Installieren und Bootstrappen des Singleton-Monitors```bash

First project + first client

orewatch monitor quickstart /path/to/project --client claude_code

`monitor quickstart` ist der empfohlene Ablauf für den ersten Start. Er:

- installiert oder aktualisiert den Singleton-Monitor-Dienst
- startet den Monitor bei Bedarf
- fügt das Zielprojekt zur Überwachungsliste hinzu
- gibt den Bootstrap-Block für den ausgewählten Client aus

Wenn Sie den Monitor zuerst installieren und Clients später verbinden möchten:```bash
orewatch monitor install
orewatch monitor install --ide-bootstrap
orewatch monitor install --service-manager launchd --no-start

2. Überprüfen Sie, ob der Monitor einwandfrei ist```bash orewatch monitor status orewatch monitor connection-info orewatch monitor doctor

Verwenden Sie diese Befehle für leicht unterschiedliche Aufgaben:

- `monitor status` zeigt an, ob der Singleton-Daemon und die API ausgeführt werden
- `monitor connection-info` gibt die Loopback-API-URL, den Token-Pfad, das Monitor-Verzeichnis und die unterstützten Bootstrap-Clients aus
- `monitor doctor` gibt die genauen Pfade für Konfiguration, Status-Datenbank, Protokoll und gemeinsame Bedrohungsdaten aus

**3. Fügen Sie jedes Projekt hinzu, das der Singleton überwachen soll**```bash
orewatch monitor watch add /path/to/project-a
orewatch monitor watch add /path/to/project-b
orewatch monitor watch list
orewatch monitor watch remove /path/to/project-b

Ein OreWatch-Daemon kann all diese Projekte gleichzeitig überwachen. Sie benötigen keinen separaten Monitor pro Repository oder pro IDE-Arbeitsbereich.

Client-Integrationsrezepte

OreWatch unterstützt zwei Integrations-Transports:

Die Bootstrap-Befehle geben eine dieser Formen aus:```json { "mcpServers": { "orewatch": { "command": "/absolute/path/to/orewatch", "args": [ "monitor", "mcp" ] } } }

Wenn `orewatch monitor ide-bootstrap --client <client>` das lokale Konsolenskript auflösen kann, gibt es nun den absoluten Pfad anstelle von nacktem `orewatch` aus. Falls Sie eine ältere MCP-Konfiguration haben, die noch `"command": "orewatch"` enthält, generieren Sie sie neu und ersetzen Sie den alten Eintrag.```json
{
  "orewatch": {
    "baseUrl": "http://127.0.0.1:48736",
    "tokenPath": "/path/to/api.token"
  }
}

Cursor, Claude Code und Codex

Diese Clients verwenden alle die gleiche lokale MCP-Brücke:```bash orewatch monitor mcp

Recommended setup:

1. Führen Sie `orewatch monitor quickstart /path/to/project --client <cursor|claude_code|codex>` einmal aus.
2. Kopieren Sie den ausgegebenen MCP-Block in den passenden MCP-Client.
3. Öffnen Sie ein überwachtes Projekt in diesem Client.
4. Lassen Sie den Client OreWatch über MCP aufrufen für:
   - `orewatch_health`
   - `orewatch_check_dependency_add`
   - `orewatch_check_manifest`
   - `orewatch_override_dependency_add`
   - `orewatch_list_active_findings`
   - `orewatch_list_notifications`

Hinweise:

- `monitor mcp` ist ein stdio-Server. Wenn Sie ihn manuell starten, scheint er im Leerlauf zu sein, während er auf einen MCP-Client wartet.
- Die MCP-Bridge prüft beim Start die lokale API und kann den Singleton-Monitor einmal automatisch starten, wenn `auto_start_on_client` aktiviert ist.
- Für einen zuverlässigen IDE-Start installieren Sie den Hintergrundmonitor einmal mit `monitor install`, sodass der Daemon bereits verfügbar ist, bevor die MCP-Bridge startet.

##### VS Code

VS Code-Integrationen sollten die Singleton-localhost-API anstelle der MCP-Bridge verwenden.

Recommended setup:

1. Führen Sie `orewatch monitor quickstart /path/to/project --client vscode` aus.
2. Kopieren Sie die `baseUrl` und den `tokenPath` aus `orewatch monitor ide-bootstrap --client vscode`.
3. Integrieren Sie diese Werte in Ihre lokale VS Code-Erweiterung, -Aufgabe oder Ihren Helfer.
4. Rufen Sie die API bei Dependency-Add-, Manifest-Save- und Alert-Refresh-Ereignissen auf.

Recommended API usage for a VS code integration:

- Rufen Sie `POST /v1/check/dependency-add` vor package-manager install/add flows auf
- Rufen Sie `POST /v1/check/manifest` auf, wenn ein unterstütztes Manifest gespeichert oder explizit erneut geprüft wird
- Fragen Sie `GET /v1/findings/active` und `GET /v1/notifications` ab, um Hintergrunderkennungen anzuzeigen

##### JetBrains / PyCharm

JetBrains und PyCharm verwenden denselben localhost-API-Vertrag wie VS Code.

Recommended setup:

1. Führen Sie `orewatch monitor quickstart /path/to/project --client jetbrains` aus.
2. Kopieren Sie den API-Block aus `orewatch monitor ide-bootstrap --client jetbrains`.
3. Verwenden Sie die zurückgegebenen `baseUrl` und den `tokenPath` in einem JetBrains-Plugin, einem externen Tool oder einem lokalen Helfer.
4. Zeigen Sie sowohl synchrone Abhängigkeitsentscheidungen als auch gespeicherte Hintergrundalarme innerhalb der IDE an.

Recommended API usage for a JetBrains integration:

- Prüfen Sie Abhängigkeitshinzufügungen mit `POST /v1/check/dependency-add`
- Überprüfen Sie `package.json`, `requirements.txt`, `pyproject.toml`, `pom.xml`, `Gemfile`, `go.mod`, `Cargo.toml` und verwandte unterstützte Manifeste mit `POST /v1/check/manifest`
- Rufen Sie `GET /v1/findings/active` und `GET /v1/notifications` für dauerhafte Alarm-Panels oder Tool-Fenster ab

##### Xcode

Xcode-Integrationen sollten ebenfalls die Singleton-localhost-API verwenden, jedoch gibt es eine wichtige Scope-Begrenzung: OreWatch parst noch keine nativen Apple-Abhängigkeitsmanifeste wie `Package.resolved`, `Podfile.lock` oder `Cartfile`. Derzeit eignet sich die Xcode-Integration am besten für:

- Anzeigen von Hintergrundergebnissen und Benachrichtigungen in einem Helfer, Skript oder einer Begleit-App
- gemischte Sprach-Repositories, die in Xcode geöffnet sind und ebenfalls unterstützte Manifeste wie `package.json`, `pyproject.toml` oder `Cargo.toml` enthalten
- Teams, die die macOS-Menüleisten-App und Notification Center-Benachrichtigungen nutzen möchten, während sie in Xcode arbeiten

Recommended setup:

1. Führen Sie `orewatch monitor quickstart /path/to/project --client xcode` aus.
2. Kopieren Sie den API-Block aus `orewatch monitor ide-bootstrap --client xcode`.
3. Verwenden Sie die zurückgegebenen `baseUrl` und den `tokenPath` aus einem Build-Phase-Skript, einem Hilfsprozess oder einer benutzerdefinierten Xcode-Integration.
4. Fragen Sie `GET /v1/findings/active` und `GET /v1/notifications` für sichtbare Benachrichtigungen ab.
5. Wenn der Xcode-Arbeitsbereich unterstützte Nicht-Apple-Manifeste enthält, rufen Sie `POST /v1/check/manifest` für diese Dateien als Teil Ihres Workflows auf.

Current integration status:

- Claude Code, Codex und Cursor: erstklassige MCP-Bridge in diesem Repository enthalten
- VS Code: lokaler API-Vertrag dokumentiert, aber noch keine Erstanbieter-Erweiterung gebündelt
- JetBrains / PyCharm: lokaler API-Vertrag dokumentiert, aber noch kein Erstanbieter-Plugin gebündelt
- Xcode: lokale API- und Menüleistenintegration dokumentiert, aber noch keine Erstanbieter-Xcode-Erweiterung und kein nativer Apple-Manifest-Parser

#### When OreWatch Finds Something

Wenn der Hintergrundmonitor ein kompromittiertes Paket oder einen IoC in einem überwachten Projekt erkennt, führt OreWatch Folgendes aus:

- Schreibt von der Monitorverwaltung erstellte JSON- und HTML-Berichte im `reports/`-Verzeichnis des Singleton-Monitors
- Speichert den aktiven Fund in der Monitor-Status-DB
- Speichert einen Benachrichtigungseintrag mit einer umsetzbaren Nachricht
- Gibt eine Terminalwarnung aus, wenn Terminalbenachrichtigungen aktiviert sind
- Bevorzugt auf macOS die Singleton-Menüleisten-App als Popup-Kanal, wenn diese läuft
- Hält die neueste aufmerksamkeitswürdige Warnung ganz oben im Dropdown der Menüleiste für eine schnelle Überprüfung
- Fällt andernfalls auf eine Desktop-Benachrichtigung nach bestem Bemühen zurück, wenn Desktop-Benachrichtigungen aktiviert sind
- Kann eine optionale Webhook-Benachrichtigung für entfernte oder headless Umgebungen senden

Nutzen Sie die integrierte CLI-Prüfoberfläche, um diese Warnungen zu untersuchen:```bash
orewatch monitor findings
orewatch monitor findings --project /path/to/project --min-severity high
orewatch monitor notifications
orewatch monitor notifications --project /path/to/project
orewatch monitor package-updates
orewatch monitor package-updates --check

Die lokale API und MCP-Brücke stellen dieselben Daten für IDEs und Agenten bereit:

• API:
  • GET /v1/findings/active
  • GET /v1/notifications
  • GET /v1/package-updates
  • POST /v1/package-updates/check
• MCP:
  • orewatch_list_active_findings
  • orewatch_list_notifications
  • orewatch_list_package_updates
  • orewatch_check_package_updates

Dies ist der unterstützte Pfad für IDEs, MCP-Clients und Code-Agenten, um Hintergrunderkennungen anzuzeigen, nachdem der ursprüngliche Scan abgeschlossen ist.

Paketaktualisierungshinweise sind rein informativ. OreWatch meldet neuere Versionen für überwachte Projektabhängigkeiten und OreWatch selbst, ändert jedoch keine Manifeste, Lockfiles oder installierten Pakete.

Native macOS Menu Bar App

OreWatch enthält jetzt eine native macOS-Menüleisten-App für Benutzer, die eine sichtbare lokale Benutzeroberfläche wünschen, anstatt sich nur auf CLI-Befehle, MCP-Abfragen oder Best-Effort-Benachrichtigungen des Notification Centers zu verlassen.

Installieren Sie die optionalen Cocoa-Bindungen in dieselbe Laufzeit, die den Befehl orewatch bereitstellt. Wählen Sie den Befehl, der Ihrer Installationsmethode entspricht:```bash

pip / source-checkout install

python3.14 -m pip install 'orewatch[mac-menubar]'

existing pipx install

pipx inject orewatch pyobjc-framework-Cocoa

Homebrew install

brew install rapticore/tap/orewatch

Starten Sie dann die Menüleisten-App:```bash
orewatch monitor menubar

Standardmäßig startet monitor menubar die App im Hintergrund neu und gibt sofort die Shell-Eingabeaufforderung zurück. Verwenden Sie orewatch monitor menubar --foreground nur, wenn Sie sie explizit für Debugging-Zwecke an das Terminal gebunden halten möchten.

Die Menüleisten-App verbindet sich mit dem gleichen Singleton-Monitor. Es wird keine zweite Monitorinstanz gestartet. Wenn der Monitor noch nicht installiert und ausgeführt wird, installiert/startet die App ihn beim ersten Start.

Homebrew installiert die Cocoa-Bindungen in die isolierte libexec-Umgebung von OreWatch. Wenn orewatch monitor menubar No module named 'AppKit' meldet, aktualisieren Sie das Formular mit brew update && brew reinstall rapticore/tap/orewatch. Bei pip-, pipx- und Quellinstallationen müssen die optionalen Bindungen weiterhin zur selben Python-Umgebung hinzugefügt werden, die den Befehl orewatch bereitstellt.

Wenn Desktop-Benachrichtigungen unter macOS aktiviert sind, hält der Singleton-Watcher jetzt eine Singleton-Menüleisten-App am Leben und verwendet sie als primäre Popup-Oberfläche. Dadurch wird vermieden, sich nur auf einen abgetrennten osascript-Aufruf des Dämons zu verlassen, und Sie erhalten eine dauerhafte native Benutzeroberfläche für neue Erkenntnisse.

Der aktuelle Menüleisten-Build ist icon-zentriert. Die alte Kurzform OW und frühere OreWatch-Icon-Text sollten als Legacy-Verweise betrachtet werden; die App bevorzugt jetzt das gebündelte Marken-Icon und greift nur auf kompakten Text oder Badges zurück, wenn macOS das Bild nicht rendern kann oder eine Alarmzahl benötigt.

Was die macOS-Menüleisten-App bietet:

• ein dauerhaftes Menüleisten-Status-Symbol, das das gebündelte Marken-Icon bevorzugt, mit kompaktem Text-Fallback oder Alarm-Badges bei Bedarf
• einen kompakten roten/fetten Alarmzustand für neu erkannte Alarme, der sichtbar bleibt, bis Sie das Menü öffnen
• eine Live-Zusammenfassung aktiver Funde und der höchsten Schwere
• einen erstklassigen Bereich für Paketaktualisierungen mit Projektabhängigkeitsaktualisierungen, OreWatch-Selbstaktualisierungsstatus, letztem Prüfstatus und kopierbaren Befehlsvorschlägen
• aktuelle Benachrichtigungen in einem nativen Dropdown-Menü
• native Popups im Benachrichtigungszentrum für neu gespeicherte Monitoralarme
• eine Aktion Arbeitsbereichsordner hinzufügen..., die ein Projekt in den Singleton-Watcher aufnimmt und einen ersten schnellen Scan ausführt
• integrierte Konfigurationsumschalter für Desktop-Benachrichtigungen, Terminal-Benachrichtigungen, Menüleisten-Keepalive und menüleistengesteuerte Popups
• Ein-Klick-Aktionen zum Öffnen von Berichten, Monitor-Startseite und Monitor-Protokoll
• Ein-Klick-Aktionen zum Öffnen der Monitor-Konfigurationsdatei und des Konfigurationsordners
• Menüaktionen zum Überprüfen von Paketaktualisierungen, Aktualisieren der Bedrohungsdaten, Ausführen von schnellen/vollständigen Scans und Starten/Neustarten/Stoppen des Singleton-Monitors

Empfohlener Mac-Ablauf:

1. Führen Sie einmal orewatch monitor quickstart /path/to/project --client claude_code aus.
2. Installieren Sie die optionalen Bindungen in derselben Umgebung wie orewatch.
3. Starten Sie orewatch monitor menubar.
4. Lassen Sie die Menüleisten-App laufen, um eine dauerhafte native Prüfoberfläche zu erhalten, während Ihre IDEs und Coding-Agenten weiterhin MCP oder die lokale API verwenden.

Adoptionsleitfaden

Für eine einfachere Einführung verwenden Sie die fokussierten Dokumente anstatt das gesamte README von Anfang bis Ende zu lesen:

• docs/adoption-guide.md: kürzester Weg für die lokale Entwicklerübernahme
• docs/local-api.md: genauer localhost-API- und MCP-Vertrag
• docs/e2e-testing.md: Workflow für Mitwirkende und Validierung

Empfohlene Adoptionsreihenfolge:

1. Beginnen Sie mit einem Repository und einem Benutzer.
2. Aktivieren Sie den Singleton-Monitor mit monitor quickstart.
3. Verbinden Sie einen Client: Cursor, Claude Code, Codex, VS Code, PyCharm oder Xcode.
4. Bestätigen Sie, dass Funde in orewatch monitor findings und orewatch monitor notifications erscheinen.
5. Fügen Sie unter macOS monitor menubar hinzu, damit Benutzer eine dauerhafte Prüfoberfläche und Popup-Zustellung erhalten.
6. Nachdem die lokale Adoption stabil ist, fügen Sie CI-Scans und optionale Webhooks hinzu.

Tägliche Vorgänge

Häufige Betriebsbefehle:```bash

Background service lifecycle

orewatch monitor start orewatch monitor restart orewatch monitor stop orewatch monitor uninstall

Run the daemon in the foreground

orewatch monitor run

Launch the native macOS menu bar UI

orewatch monitor menubar

Trigger immediate scans

orewatch monitor scan-now orewatch monitor scan-now /path/to/project

Review detections and alerts

orewatch monitor findings orewatch monitor notifications

Reclaim disk space — prune accumulated backup manifests and orphaned staging

orewatch monitor cleanup orewatch monitor cleanup --keep-backups 5 --staging-max-age-seconds 3600

**Manuelle Snapshot- und Signierungsaktionen:**```bash
# Generate a signing keypair
orewatch monitor snapshot keygen /tmp/ore-keys

# Build and apply local threat-data snapshots
orewatch monitor snapshot build /tmp/ore-snapshot \
  --private-key /tmp/ore-keys/snapshot_signing_private.pem \
  --public-key /tmp/ore-keys/snapshot_signing_public.pem
orewatch monitor snapshot apply /tmp/ore-snapshot/manifest.json \
  --public-key /tmp/ore-keys/snapshot_signing_public.pem

# Publish a hosted snapshot channel
orewatch monitor snapshot publish /tmp/ore-snapshots \
  --base-url https://example.com/ore-snapshots \
  --channel stable \
  --private-key /tmp/ore-keys/snapshot_signing_private.pem \
  --public-key /tmp/ore-keys/snapshot_signing_public.pem

Monitorverhalten:

• Schnelle Scans sind paketorientiert und laufen nach einem Zeitplan sowie nach generischen Manifeständerungen.
• Vollständige Scans beinhalten IoC-Erkennung und laufen nachts, auf manuelle Anfrage sowie nach Workflow- oder Payload-Dateiänderungen.
• Unter Linux ist der Konfigurationsstandard ~/.config/orewatch/singleton/ und der Zustandsstandard ~/.local/state/orewatch/singleton/.
• Unter macOS ist der Konfigurationsstandard ~/Library/Application Support/OreWatch/singleton/ und der Zustandsstandard ~/Library/Application Support/OreWatch/State/singleton/.
• Gemeinsame Bedrohungsdaten befinden sich nun im Singleton-Zustandsverzeichnis unter threat-data/final-data/.
• monitor doctor gibt den genauen config_path, state_db, log_file, final_data_dir und das Service-Template-Verzeichnis für den Singleton-Monitor aus.
• Projektbezogene Richtlinienüberschreibungen können in .ore-monitor.yml im Projektstammverzeichnis gespeichert werden.

Lokale Integrationsoberfläche:

• OreWatch stellt jetzt standardmäßig eine nur auf Localhost beschränkte API unter 127.0.0.1:48736 bereit, wenn der Monitor-Daemon läuft.
• Die API verwendet einen benutzerspezifischen Bearer-Token, der im Monitor-Konfigurationsverzeichnis unter api.token mit Nur-Besitzer-Berechtigungen gespeichert ist.
• Direkte Anfragen an 127.0.0.1:48736 ohne Authorization: Bearer <token> geben korrekt 401 Unauthorized zurück.
• Agent- und IDE-Clients sollten den Monitor über orewatch monitor connection-info ermitteln, anstatt Pfade zu erraten, und sollten den tatsächlichen project_path, mit dem sie arbeiten, in Abhängigkeitsprüfanfragen senden.
• Claude Code, Codex und Cursor können die gebündelte MCP-Brücke verwenden, die orewatch_health, orewatch_check_dependency_add, orewatch_check_manifest, orewatch_override_dependency_add, , , und bereitstellt.

Optionale anomaliegesteuerte Live-Update-Konfiguration:```yaml live_updates: enabled: true mode: gated bootstrap_from_live: true block_on_core_source_failure: false max_drop_ratio: 0.40 max_drop_absolute: 200 max_removal_ratio: 0.25 max_removal_absolute: 100 warn_growth_ratio: 5.0 warn_growth_absolute: 2000

- Live-Kandidaten werden zuerst in einem Staging-Bereich aufgebaut; sie überschreiben während der Sammlung nicht die aktiven Datenbanken.
- Große Rückgänge, Ökosystem-Rückschritte, leere Ökosysteme und Massenentfernungen blockieren die Promotion.
- Ausfälle von Kernquellen sind standardmäßig nur Warnungen für Open-Source-Live-Aktualisierungen; Rückgänge und Entfernungen auf Ökosystemebene blockieren weiterhin schlechte Promotionen.
- Nur-Warnungs-Anomalien werden im Status und in Berichten aufgezeichnet, verhindern jedoch keine Promotion.
- Abgelehnte Kandidaten behalten den zuletzt bekannten guten Datensatz aktiv, wenn bereits einer vorhanden ist.
- Der Erststart-Bootstrap aus Live-Feeds ist erlaubt, wenn mindestens eine Kernquelle erfolgreich ist und der Kandidat nutzbare Ökosystemdaten erzeugt.

**Optionale Benachrichtigungs-Webhook-Konfiguration:**```yaml
notifications:
  desktop: true
  terminal: true
  webhook_url: https://hooks.example.com/orewatch
  webhook_format: generic
  webhook_timeout_ms: 5000
  webhook_headers:
    Authorization: Bearer change-me

Set webhook_format: slack bei Verwendung eines eingehenden Slack-Webhooks. In diesem Modus sendet OreWatch eine einfache text-Nutzlast.

Verteilung

Das Projekt hat nun zwei unterschiedliche Verteilungswege:

1. Der CLI- und Monitor-Code
2. Die vom Monitor verbrauchten Bedrohungsdaten-Snapshots

Sie sollten getrennt verteilt werden.

Empfohlene Paketverteilung

Beste Voreinstellung für Entwickler: Veröffentlichen Sie den Scanner als normales Python-Paket auf PyPI und empfehlen Sie die Installation mit pipx.

Warum dies die beste Wahl ist:

• Das Projekt ist ein Python-CLI und Hintergrundmonitor, daher ist ein universelles Wheel plus Source-Distribution das direkteste Release-Artefakt.
• pipx bietet Entwicklern eine isolierte Installation auf Benutzerebene, ohne die virtualenvs des Projekts zu beeinträchtigen.
• CI kann dieselbe Version weiterhin mit python3.14 -m pip install orewatch==<version> installieren.
• Dies hält den CLI-Upgradepfad einfach, während Bedrohungsdatenaktualisierungen dem signierten Snapshot-Kanal überlassen bleiben.

Empfohlene Release-Form:

• Veröffentlichen Sie sdist und universelle Wheel-Artefakte auf PyPI.
• Stellen Sie den Konsoleneinstiegspunkt orewatch bereit.
• Behalten Sie ore-mal-pkg-inspector als temporären Kompatibilitätsalias bei.
• Dokumentieren Sie pipx install --python python3.14 orewatch für lokale Entwicklerinstallationen.
• Dokumentieren Sie python3.14 -m pip install orewatch==<version> für CI und festgelegte Automatisierung.

Verfügbarer sekundärer Kanal: Der Homebrew-Tap ist jetzt für macOS-Benutzer live, die Brew-verwaltete Installationen bevorzugen:```bash brew install rapticore/tap/orewatch

Homebrew bleibt eine bequeme Schicht über der veröffentlichten PyPI-Veröffentlichung, nicht das primäre Veröffentlichungsartefakt.

**Beste Option für Mitwirkende:** Behalten Sie den aktuellen Quellcode-Checkout-Workflow bei:```bash
git clone https://github.com/rapticore/ore-mal-pkg-inspector.git
cd ore-mal-pkg-inspector
python3.14 -m venv .venv
source .venv/bin/activate
python -m pip install -e .

Verwaltetes macOS-Rollout

Wenn Sie OreWatch mit Kandji, Jamf Pro, Intune, Munki oder einem anderen macOS-Softwareverteilungssystem ausrollen, unterscheidet sich das empfohlene Modell vom Entwickler-pipx-Pfad.

Aktuelle Produktrealität:

• heute liefert das Repository ein Python-Paket, kein offizielles notariertes macOS-Installationspaket
• für verwaltete Flotten ist das empfohlene Artefakt ein signiertes flaches .pkg, das um das veröffentlichte OreWatch-Wheel herum gebaut ist
• Bedrohungsdaten-Snapshots sollten weiterhin getrennt vom App-/Laufzeitpaket verteilt werden

Empfohlenes Enterprise-Rollout-Modell:

1. Geräteinstallation
   • Bereitstellen eines signierten .pkg, das die OreWatch-Laufzeitumgebung und einen stabilen orewatch-CLI-Shim installiert
   • optional die mac-menubar-Erweiterung einschließen, wenn Sie die native Menüleisten-App auf verwalteten Macs wünschen
2. Benutzeraktivierung
   • Führen Sie orewatch monitor quickstart /path/to/project --client <client> oder einen äquivalenten Bootstrap im Benutzerkontext aus
   • Dieser Schritt ist getrennt, da der Monitor von OreWatch absichtlich pro Benutzer ausgelegt ist und einen Benutzer-LaunchAgent sowie benutzereigene Konfiguration/Token/Status verwendet
3. Fortlaufende Aktualisierungen
   • Aktualisieren Sie das Laufzeitpaket gemäß Ihrem üblichen Software-Lebenszyklus
   • Aktualisieren Sie Bedrohungsdaten-Snapshots unabhängig über den signierten Snapshot-Kanal oder den Live-Update-Pfad

Warum diese Trennung wichtig ist:

• MDM-Tools sind gut darin, Code auf dem Rechner zu installieren
• OreWatchs Monitor, API-Token und launchd-Dienst sind benutzerspezifisch, daher sollten sie im Kontext des angemeldeten Benutzers erstellt werden, anstatt aus einer maschinenweiten Paketinstallation erzwungen zu werden

Empfohlene Paketform für verwaltetes macOS:

• Eine dedizierte Laufzeitumgebung unter einem stabilen Pfad wie /Library/Application Support/OreWatch/runtime
• Ein stabiler Shim wie /usr/local/bin/orewatch
• Versionierte Paketmetadaten, damit MDM-Plattformen Aktualisierungen sauber erkennen können
• Codesignierung und Notarisierung, wo Ihre Fleet-Richtlinie dies erwartet

Anbieterspezifische Anleitung:

• Kandji
  • Verwenden Sie eine benutzerdefinierte App mit einem Installationspaket (.pkg)
  • Bevorzugen Sie .pkg gegenüber .dmg oder .zip für OreWatch, da die Laufzeitumgebung keine Drag-and-Drop-App ist
  • Nutzen Sie Self Service oder einen benutzerseitigen Onboarding-Schritt für die erstmalige Monitoraktivierung
• Jamf Pro
  • Laden Sie das .pkg als Paket hoch und stellen Sie es mit einer Richtlinie oder über Self Service bereit
  • Halten Sie die Benutzeraktivierung getrennt von der maschinenweiten Paketbereitstellung, es sei denn, Sie haben einen bewussten Bootstrap-Schritt im Benutzerkontext
• Microsoft Intune
  • Verwenden Sie eine macOS-LOB-App mit einem signierten .pkg
  • Intune ist strenger als die anderen Kanäle: Es erwartet ein echtes .pkg, signiert mit einem Developer ID Installer-Zertifikat, und das Paket muss eine Nutzlast enthalten
• Munki
  • Veröffentlichen Sie das .pkg plus Paketmetadaten und behandeln Sie OreWatch wie andere verwaltete macOS-Software
  • Munki ist geeignet, wenn Sie ein Paket-Repository und optionale Self-Service-ähnliche Einführung wünschen

Ein umfassenderes Rollout-Playbook finden Sie unter docs/managed-rollout.md.

Empfohlene Snapshot-Verteilung

Bedrohungsdaten-Snapshots sollten nicht im Python-Paket gebündelt werden. Sie ändern sich in einem anderen Rhythmus und werden bereits als signierte gehostete Artefakte unterstützt.

Open-Source/Community-Standard: openssf und osv direkt über den anomaliegesteuerten Live-Update-Pfad beziehen. Enterprise-Standard: Veröffentlichte versionierte signierte Snapshots auf statischem HTTPS-Hosting und lassen Sie Clients diese unabhängig aktualisieren.

Empfohlene Hosting-Ziele:

• GitHub Releases-Assets
• S3 oder Cloudflare R2 hinter HTTPS
• Jeder statische CDN-gestützte Bucket, der unveränderliche versionierte Dateien bereitstellt

Empfohlenes Snapshot-Layout:

• versions/<version>/manifest.json
• versions/<version>/*.db
• channels/stable.json

Empfohlenes Vertrauensmodell:

• Halten Sie den privaten Signierschlüssel offline
• Liefern Sie nur den öffentlichen Verifizierungsschlüssel mit der Client-Konfiguration oder dem Paket aus
• Überprüfen Sie jeden Kanaldeskriptor und jedes Manifest vor dem Herunterladen/Anwenden

Empfohlenes Gesamtmodell

Für eine Produktionsversion ist die sauberste Einrichtung:

• Die Anwendung als PyPI-Paket verteilen
• Lokal mit pipx installieren
• In CI mit pip installieren
• Bedrohungsdaten als signierte Snapshot-Kanäle über HTTPS verteilen
• Source-Checkout als Entwicklungsweg behandeln, nicht als primäre Endbenutzerinstallation

Protokollierung und Fehlersuche

Standardmäßig zeigt der Scanner nur Warnungen, Fehler und die endgültige Zusammenfassung an. Verwenden Sie für die Fehlerbehebung oder detaillierte Fortschrittsverfolgung die Protokollierungsflags:

Ausführlicher Modus

Fortschrittsmeldungen und Sammlungsstatistiken anzeigen:```bash orewatch /path/to/project --verbose

**Ausgabe umfasst:**
- Ergebnisse der Ökosystemerkennung
- Fortschritt des Dateiparsings
- Anzahl der Paketextraktionen
- Details der Datenbankabfragen
- Fortschritt des IoC-Scans

**Beispiel:**```
INFO: Detected ecosystems: npm, pypi
INFO: Loaded database for npm: 15234 malicious packages
INFO: Loaded database for pypi: 8421 malicious packages
INFO: Extracted 45 packages from 3 files
INFO: Checking 30 npm packages against database...
INFO: Checking 15 pypi packages against database...
INFO: IoC scan complete: 0 indicators found

Debug-Modus

Siehe detaillierte Diagnoseinformationen zur Fehlerbehebung:```bash orewatch /path/to/project --debug

**Ausgabe umfasst:**
- Alle INFO-Level-Nachrichten
- Zu scannende Dateipfade
- Details zur SQL-Abfrageausführung
- Hash-Berechnungen
- Ergebnisse des Mustervergleichs
- Informationen zum internen Zustand

**Anwendungsfälle:**
- Untersuchen, warum ein Paket nicht erkannt wurde
- Debuggen von Problemen mit der automatischen Erkennung von Ökosystemen
- Melden von Problemen mit ausführlichem Kontext
- Überprüfen des Scanner-Verhaltens

### Protokollierung für Collectoren

Die Bedrohungsanalyse-Collectoren unterstützen auch den ausführlichen und den Debug-Modus:```bash
cd collectors

# See collection progress
python3 orchestrator.py --verbose

# Debug data source issues
python3 orchestrator.py --debug

Hinweis: Alle Logs gehen nach stderr, sodass stdout für die JSON-Berichtsausgabe sauber bleibt. Dies ermöglicht das Weiterleiten von Scannerergebnissen an andere Tools ohne Störung durch Logmeldungen.

Ausgabe & Berichte

Berichtsstruktur

Berichte werden standardmäßig im Verzeichnis scan-output/ gespeichert (oder einem benutzerdefinierten Pfad mit --output). OreWatch schreibt einen maschinenlesbaren JSON-Bericht und einen gestalteten HTML-Begleitbericht mit demselben Basisnamen. Das JSON-Artefakt enthält Metadaten zur Verfügbarkeit von Bedrohungsdaten und verwendet SARIF-artige physicalLocation-Objekte für Paketfunde, ist aber kein vollständiges SARIF-2.1.0-Dokument.

Beispielbericht:```json { "scan_timestamp": "2025-12-31T12:00:00Z", "ecosystem": "npm", "scanned_path": "/path/to/project", "total_packages_scanned": 150, "data_status": "complete", "sources_used": ["openssf", "osv"], "experimental_sources_used": [], "missing_ecosystems": [], "malicious_packages_found": 2, "iocs_found": 3, "malicious_packages": [ { "name": "malicious-pkg", "version": "1.0.0", "severity": "critical", "sources": ["threat-intel-db", "research-community"], "description": "Malicious code executes unauthorized operations", "detected_behaviors": ["malicious_code", "data_exfiltration"] } ], "iocs": [ { "type": "malicious_bundle_js", "path": "node_modules/suspect-pkg/bundle.js", "hash": "46faab8ab153fae6e80e7cca38eab363075bb524edd79e42269217a083628f09", "severity": "CRITICAL", "variant": "original", "description": "Known malicious payload file from Shai-Hulud attack" }, { "type": "malicious_postinstall", "path": "package.json", "pattern": "node bundle.js", "severity": "CRITICAL", "variant": "original", "description": "Malicious postinstall hook executes payload" } ] }

**Bedrohungsdatenfelder:**
- `data_status`: `complete`, `partial`, `failed` oder `not_applicable`
- `sources_used`: Quellen, die nutzbare Bedrohungsdaten für die angeforderten Ökosysteme beigetragen haben
- `experimental_sources_used`: experimentelle Quellen, die in den Scandaten enthalten sind
- `missing_ecosystems`: angeforderte Ökosysteme, für die keine nutzbare Paket-Bedrohungsdatenbank existierte
- `promotion_decision`: leer für Scans mit vorhandenen Daten, ansonsten `promoted`, `bootstrapped` oder `rejected`
- `kept_last_known_good`: `true`, wenn ein Live-Kandidat abgelehnt wurde, der vorherige aktive Datensatz aber weiterhin verwendbar war
- `anomalies`: Warn-/Block-Anomalien, die während eines Live-Aktualisierungsversuchs ausgelöst wurden

### Ergebnisse verstehen

**Schweregrade:**
- **KRITISCH:** Bekannter bösartiger Code mit aktiven Exploits oder Datenexfiltration
- **HOCH:** Starke Indikatoren für böswillige Absicht oder Typosquatting
- **MITTEL:** Verdächtige Muster oder potenzielle Schwachstellen
- **NIEDRIG:** Geringe Bedenken oder informative Erkenntnisse

**Empfohlene Maßnahmen:**
1. **Kritische/hohe Ergebnisse:** Entfernen Sie betroffene Pakete sofort und untersuchen Sie die Auswirkungen
2. **IoCs überprüfen:** Prüfen Sie, ob bösartiger Code ausgeführt wurde (Logs, Netzwerkaktivität)
3. **Abhängigkeiten aktualisieren:** Ersetzen Sie bösartige Pakete durch legitime Alternativen
4. **Erneut scannen:** Überprüfen Sie die Behebung mit einem Folge-Scan
5. **Melden:** Erwägen Sie eine Meldung an die Paketregistrierungsbetreuer

---

## CI/CD-Integration

### GitHub Actions

**Grundlegender Sicherheitsscan:**```yaml
name: Security Scan - Malicious Packages
on: [push, pull_request]

jobs:
  malicious-package-scan:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.14'

      - name: Install OreWatch
        run: |
          git clone https://github.com/rapticore/ore-mal-pkg-inspector.git scanner
          cd scanner
          pip install .

      - name: Scan for malicious packages
        run: |
          cd scanner
          orewatch ${{ github.workspace }} --latest-data

      - name: Upload scan report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: security-scan-report
          path: scanner/scan-output/

Fortgeschritten mit Erkennungsfehler:```yaml - name: Scan and fail on malicious packages run: | cd scanner orewatch ${{ github.workspace }} --latest-data --output report.json

      # Check if malicious packages were found
      MALICIOUS_COUNT=$(jq '.malicious_packages_found' report.json)
      IOC_COUNT=$(jq '.iocs_found' report.json)

      if [ "$MALICIOUS_COUNT" -gt 0 ] || [ "$IOC_COUNT" -gt 0 ]; then
        echo "🚨 SECURITY ALERT: Malicious packages or IoCs detected!"
        echo "Malicious packages: $MALICIOUS_COUNT"
        echo "IoCs found: $IOC_COUNT"
        exit 1
      fi

### GitLab CI```yaml
malicious-package-scan:
  image: python:3.14
  stage: security
  before_script:
    - git clone https://github.com/rapticore/ore-mal-pkg-inspector.git scanner
    - cd scanner && pip install .
  script:
    - orewatch $CI_PROJECT_DIR --latest-data --strict-data --output scan-report.json
  artifacts:
    paths:
      - scan-report.json
    when: always
  allow_failure: false

Jenkins Pipeline```groovy

pipeline { agent any

stages {
    stage('Setup Scanner') {
        steps {
            sh '''
                git clone https://github.com/rapticore/ore-mal-pkg-inspector.git scanner
                cd scanner
                python3.14 -m pip install .
            '''
        }
    }

    stage('Security Scan') {
        steps {
            sh '''
                cd scanner
                orewatch ${WORKSPACE} --latest-data
            '''
        }
    }
}

post {
    always {
        archiveArtifacts artifacts: 'scanner/scan-output/*.json', fingerprint: true
    }
}

}

### Pre-commit Hook

Hinzufügen zu `.git/hooks/pre-commit`:```bash
#!/bin/bash

echo "Running malicious package scan..."

cd /path/to/ore-mal-pkg-inspector
orewatch $PROJECT_DIR --no-summary

if [ $? -ne 0 ]; then
    echo "❌ Malicious packages or IoCs detected! Commit blocked."
    echo "Review the scan report in scan-output/"
    exit 1
fi

echo "✅ Security scan passed"

Fehlerbehebung

Häufige Probleme

Fehler "Datenbank nicht gefunden"

Symptom:``` ERROR: No usable threat data available for requested ecosystems: npm

**Ursache:** Erfassung von Bedrohungsdaten fehlgeschlagen, Metadaten sind unvollständig, oder die angeforderten Ökosysteme haben noch keine nutzbaren lokalen Datenbanken.

**Lösung:**```bash
# Force recollection and require a complete result for the requested ecosystems
orewatch /path/to/project --latest-data --strict-data

Hinweis: Falls dies weiterhin besteht, überprüfen Sie die Netzwerkverbindung, die Dateisystemberechtigungen und ob Sie absichtlich experimentelle Quellen angefordert haben.

Warnung „Keine Pakete erkannt“

Symptom:``` WARNING: No packages detected in /path/to/project

**Mögliche Ursachen und Lösungen:**

1. **Falsches Verzeichnis:** Stellen Sie sicher, dass Sie das richtige Projektverzeichnis scannen.   ```bash
   ls /path/to/project  # Verify package.json or requirements.txt exists

2. Nicht unterstütztes oder unerwartetes Manifest: Gib die genauen unterstützten Dateinamen aus. ```bash orewatch --list-supported-files
   root@kitploit:~

3. Dateiberechtigungen: Stellen Sie sicher, dass Dateien lesbar sind ```bash ls -la /path/to/project/package.json
   root@kitploit:~

Verbindungsfehler während des Updates

Symptom:``` ERROR: Error downloading npm: <urlopen error [Errno -3] Temporary failure in name resolution>

**Lösungen:**

1. **Internetverbindung prüfen:**   ```bash
   ping google.com

2. Wiederholung mit Timeout-Erhöhung: Bearbeite collectors/config.yaml: ```yaml osv: timeout: 600 # Increase from default 300
   root@kitploit:~

3. Verwende zwischengespeicherte Daten: Wenn du zuvor Daten heruntergeladen hast: ```bash python3 orchestrator.py --skip-build # Skip download, rebuild from cache
   root@kitploit:~

Berechtigungsfehler

Symptom:``` ERROR: Error creating directory collectors/raw-data: Permission denied

**Lösung:**```bash
# Ensure proper ownership
sudo chown -R $USER:$USER /path/to/ore-mal-pkg-inspector

# Or run from user-writable location
cd ~/
git clone https://github.com/rapticore/ore-mal-pkg-inspector.git
cd ore-mal-pkg-inspector

OreWatch verbraucht zu viel Speicherplatz

Symptom: ~/Library/Application Support/OreWatch (macOS) oder $XDG_STATE_HOME/orewatch (Linux) ist auf mehrere zehn Gigabyte angewachsen.

Ursache (vor 1.2.3): Bei jeder Live-Update-Werbung wurde eine vollständige Kopie der vorherigen Bedrohungsdatenbanken (~300 MB) ohne Aufbewahrung archiviert. Ein langlaufender Monitor sammelte so pro Zyklus einen Schnappschuss an.

Behebung: Upgrade auf 1.2.3 oder höher. Backups sind jetzt ~1 KB große SHA-256-Manifeste, die Aufbewahrung ist standardmäßig auf die letzten 30 begrenzt, und ein expliziter Bereinigungsbefehl ist verfügbar:```bash

Apply the configured retention policy now (default: keep 30 manifests,

remove staging entries older than 1 hour).

orewatch monitor cleanup

Reclaim everything except the most recent 5 backups and purge staging.

orewatch monitor cleanup --keep-backups 5 --staging-max-age-seconds 0

Tune retention in monitor config (live_updates section):

retain_backups: # how many backup manifests to keep

staging_max_age_seconds: # stale candidate-* staging cutoff

#### Falsche Positive

**Symptom:** Legitimes Paket als bösartig markiert.

**Schritte:**

1. **Überprüfen Sie den Befund:** Überprüfen Sie die Berichtdetails einschließlich Schweregrad und Beschreibung

2. **Überprüfen Sie die Version:** Die markierte Version kann spezifisch sein:   ```bash
   orewatch /path/to/project --verbose

3. Falschmeldung melden: Falls als Fehlalarm bestätigt:
   • Problem unter https://github.com/rapticore/ore-mal-pkg-inspector/issues mit Details melden

Debug-Modus für Untersuchungen

Detaillierte Protokollierung aktivieren:```bash

Scanner debug mode

orewatch /path/to/project --debug 2> debug.log

Collector debug mode

cd collectors python3 orchestrator.py --debug 2> collector-debug.log

**Überprüfungsprotokolle:** Überprüfen Sie `debug.log` für detaillierte Ausführungsabläufe, einschließlich:
- Durchsuchte Dateipfade
- Ausgeführte SQL-Abfragen
- Ergebnisse des Musterabgleichs
- Fehler-Stapelverfolgungen

---

## FAQ

### Wie oft sollte ich die Bedrohungsinformationen aktualisieren?

**Empfehlung:**
- **Produktions-/CI-Umgebungen:** Tägliche automatisierte Aktualisierungen
- **Entwicklungs-Workstations:** Mindestens wöchentliche Aktualisierungen
- **Nach Sicherheitsnachrichten:** Sofortige Aktualisierung, wenn neue Bedrohungen angekündigt werden

Schädliche Pakete werden kontinuierlich veröffentlicht. Tägliche Aktualisierungen stellen sicher, dass die neuesten Schutzmaßnahmen angewendet werden.

### Wie aktualisiere ich die Bedrohungsinformationsdaten?

Führen Sie den Scanner mit dem Flag `--latest-data` aus, um eine Aktualisierung zu erzwingen:```bash
orewatch /path/to/project --latest-data

Für automatisierte Updates in CI/CD planen Sie regelmäßige Scans mit dem Flag --latest-data (z. B. täglich). Fügen Sie --include-experimental-sources nur hinzu, wenn Sie explizit Phylum-abgeleitete Daten in den Wiederaufbau einbeziehen möchten.

Hinweis: Erstmalige Scans sammeln automatisch Daten, daher sind manuelle Aktualisierungen nur erforderlich, um vorhandene Datenbanken zu aktualisieren.

Woher stammen die Bedrohungsdaten?

Die Standarddatenbanken werden aus den Kernbedrohungsquellen des Projekts erstellt:

• openssf
• osv

Der Scanner kann auch die experimentelle Quellgruppe des Projekts einbeziehen:

• phylum mit --include-experimental-sources

socketdev ist im Repository als deaktivierter Platzhalter vorhanden und ist nicht Teil des Standarderfassungspfads.

Technische Details zu Datenquellen, Sammlung und Verarbeitung finden Sie in ARCHITECTURE.md.

Ändert dieses Tool meinen Code oder meine Abhängigkeiten?

Nein. OreWatch führt schreibgeschützte Operationen durch. Es:

• ✅ Liest Abhängigkeitsdateien
• ✅ Fragt Bedrohungsdatenbanken ab
• ✅ Scannt nach Dateimustern
• ✅ Erstellt Berichte

Es niemals:

• ❌ Ändert Paketdateien
• ❌ Installiert oder entfernt Pakete
• ❌ Ändert Projektkonfiguration
• ❌ Führt Paketcode aus

Was passiert, wenn mein Paket als bösartig markiert wird?

Schritte, die Sie unternehmen sollten:

1. Überprüfen Sie den Befund: Sehen Sie sich den Bericht auf Details und Schweregrad an.
2. Überprüfen Sie die Beweise: Untersuchen Sie die Beschreibung und die erkannten Verhaltensweisen.
3. Versionen prüfen: Stellen Sie fest, ob bestimmte Versionen betroffen sind.
4. Falls legitim:
   • Melden Sie den Fehlalarm den Datenquellenbetreuern.
   • Eröffnen Sie ein Issue auf unserem GitHub mit Details.
5. Falls wirklich bösartig:
   • Entfernen Sie das Paket sofort.
   • Überprüfen Sie die letzten Code-Commits auf Schäden.
   • Überprüfen Sie die Protokolle auf verdächtige Aktivitäten.
   • Aktualisieren Sie auf eine sichere Alternative.

Kann ich dies offline verwenden?

Teilweise.

Offline-Scanning: ✅ Ja, sobald die Datenbanken initialisiert sind.```bash

Online: Initial setup (one-time - runs automatically on first scan)

orewatch /path/to/project

Offline: Subsequent scans work with local databases

orewatch /path/to/project

**Offline-Updates:** ❌ Nein, die Sammlung von Bedrohungsinformationen erfordert Internetzugang, um Daten aus Sicherheitsquellen abzurufen.

**Airgapped-Umgebungen:** Sie können:
1. Datenbanken auf einem internetverbundenen Rechner herunterladen
2. Die SQLite-Dateien in das singuläre `final_data_dir` übertragen, das von `orewatch monitor doctor` angezeigt wird
3. Scans offline mit möglicherweise veralteten Daten durchführen

### Wie schneidet dies im Vergleich zu npm audit oder pip-audit ab?

**Unterschiedliche Zwecke:**

**npm audit / pip-audit:**
- Konzentrieren sich auf bekannte CVE-Schwachstellen
- Prüfen Paketversionen anhand von Advisory-Datenbanken
- Werden von den Paketregister-Teams gewartet

**OreWatch:**
- Konzentriert sich auf bösartige Pakete (nicht nur auf anfällige)
- Erkennt Typosquatting, Malware, Supply-Chain-Angriffe
- Ökosystemübergreifende Abdeckung
- IoC-Erkennung für aktive Bedrohungen

**Best Practice:** Verwenden Sie **beide**:```bash
# Check for vulnerabilities
npm audit
pip-audit

# Check for malicious packages
orewatch /path/to/project

Funktioniert das mit privaten Paketregistern?

Abhängigkeitsscanning: ✅ Ja, der Scanner liest Ihre Abhängigkeitsdateien, unabhängig davon, woher die Pakete kommen.

Bedrohungsinformationen: ⚠️ Eingeschränkt. Unsere Datenbanken decken öffentliche Register ab (npmjs.com, pypi.org usw.). Schädliche Pakete in privaten Registern werden nicht erkannt, es sei denn, Sie fügen benutzerdefinierte Bedrohungsdaten hinzu.

Benutzerdefinierte Bedrohungsdaten: Sie können die Datenbanken mit eigenen Listen schädlicher Pakete erweitern. Kontaktieren Sie uns für eine Anleitung zu diesem fortgeschrittenen Anwendungsfall.

Wie hoch ist die Leistungsbeeinträchtigung?

Scanzeit:

• Kleine Projekte (< 50 Pakete): < 5 Sekunden
• Mittlere Projekte (50-500 Pakete): 5-30 Sekunden
• Große Projekte (500+ Pakete): 30-120 Sekunden

Faktoren:

• IoC-Scanning verursacht 10-50 % Mehraufwand (deaktivieren mit --no-ioc, falls nicht benötigt)
• Der erste Durchlauf kann langsamer sein, da Datenbanken in den Speicher geladen werden

Optimierungstipps:```bash

Scan specific files instead of entire directory

orewatch --file package.json

---

## Mitwirken

Wir freuen uns über Beiträge! Ob Sie Fehler melden, Funktionen vorschlagen oder Code beisteuern – Ihre Hilfe macht OreWatch für alle besser.

**Fehler melden oder Funktionen vorschlagen:**
- GitHub Issues: https://github.com/rapticore/ore-mal-pkg-inspector/issues

**Code beitragen:**
- Siehe [CONTRIBUTING.md](https://github.com/rapticore/ore-mal-pkg-inspector/blob/HEAD/CONTRIBUTING.md) für detaillierte Richtlinien zu Entwicklungseinrichtung, Codestil, Tests und Pull-Request-Prozess

**Fragen oder Diskussionen:**
- GitHub Discussions: https://github.com/rapticore/ore-mal-pkg-inspector/discussions

---

## Sicherheitsrichtlinie

Sicherheit hat für uns höchste Priorität. OreWatch ist ein Sicherheitstool, und wir nehmen Schwachstellen ernst.

### Melden von Sicherheitslücken

**Öffnen Sie KEINE öffentlichen GitHub Issues für Sicherheitslücken.**

Melden Sie stattdessen privat:

**E-Mail:** [email protected]

**Enthalten sein sollen:**
- Beschreibung der Schwachstelle
- Schritte zur Reproduktion
- Mögliche Auswirkungen
- Vorgeschlagener Fix (falls zutreffend)
- Ihre Kontaktdaten für Rückfragen

### Antwortzeitplan

- **Bestätigung:** Innerhalb von 48 Stunden
- **Erste Bewertung:** Innerhalb von 7 Tagen
- **Zeitplan für Fix:** Variiert je nach Schweregrad
  - Kritisch: 7–14 Tage
  - Hoch: 14–30 Tage
  - Mittel/Niedrig: 30–60 Tage

### Sicherheitsempfehlungen

Bei der Verwendung von OreWatch:

**Tun:**
- ✅ Mit geringsten Rechten ausführen (kein root/admin erforderlich)
- ✅ Bedrohungsinformationen regelmäßig aktualisieren
- ✅ Scan-Berichte zeitnah überprüfen
- ✅ In CI/CD integrieren für kontinuierlichen Schutz
- ✅ Das Tool auf dem neuesten Stand halten

**Nicht tun:**
- ❌ Scan-Ergebnisse ohne Untersuchung ignorieren
- ❌ IoC-Scanning in Produktionsumgebungen deaktivieren
- ❌ Datenbankdateien aus nicht vertrauenswürdigen Quellen teilen
- ❌ Mit erhöhten Rechten unnötig ausführen

### Offenlegung von Schwachstellen

Wir folgen einer koordinierten Offenlegung:
1. Schwachstelle privat gemeldet
2. Fix entwickelt und getestet
3. Sicherheitshinweis veröffentlicht
4. Öffentliche Offenlegung, nachdem der Fix verfügbar ist

### Security Hall of Fame

Wir würdigen Sicherheitsforscher, die Schwachstellen verantwortungsvoll offenlegen:

*Liste wird gepflegt, sobald Meldungen eingehen*

---

### Community-Anfragen

Funktionen bewerten oder vorschlagen:
- **GitHub Discussions:** https://github.com/rapticore/ore-mal-pkg-inspector/discussions
- **Feature Requests:** https://github.com/rapticore/ore-mal-pkg-inspector/issues

### Beitrag zur Roadmap

Wir priorisieren Funktionen basierend auf:
- Sicherheitsauswirkung
- Nachfrage der Community
- Nachhaltigkeit der Wartung
- Übereinstimmung mit den Projektzielen

Um die Roadmap zu beeinflussen:
1. Öffnen Sie eine Feature-Anfrage mit detailliertem Anwendungsfall
2. Beteiligen Sie sich an Diskussionen
3. Tragen Sie Implementierungen bei (PRs willkommen!)

---

## Roadmap

OreWatch ist heute nutzbar für:

- lokale CLI-Scans über npm, PyPI, Maven, RubyGems, Go und Cargo
- einen Hintergrundmonitor pro Benutzer für viele Projekte
- MCP-Integrationen für Cursor, Claude Code und Codex
- localhost-API-Integrationen für VS Code, JetBrains / PyCharm und Xcode-Helfer
- macOS-Menüleisten-Übersicht und Popup-Benachrichtigungen

Kurzfristige Prioritäten:

- first-party VS Code- und JetBrains-/PyCharm-Integrationsbeispiele oder dünne Plugins
- stärkere benutzerorientierte Benachrichtigungs-Workflows über lokale Popups hinaus
- klareres Projektrichtlinien-Management über CLI und UI
- umfangreichere Monitorberichte und Einführungsdokumentation

Mittelfristige Prioritäten:

- breitere Projekt-Scan-Workflows über Monitor- und MCP-Oberfläche
- bessere Leitfäden für die Einführung auf Organisationsebene
- robustere externe Alarmzustellung und Eskalationskanäle
- tiefere IDE-spezifische UX statt reiner API-Integrationsanleitung

Bekannte aktuelle Einschränkung:

- Die Xcode-Integration ist derzeit am besten für Alarm-Sichtbarkeit und mehrsprachige Repositories geeignet. OreWatch analysiert noch keine nativen Apple-Manifeste wie `Package.resolved`, `Podfile.lock` oder `Cartfile`.

Langfristige Richtung:

- native Unterstützung für Apple-Ökosystem-Manifeste
- stärkere first-Party-Editor-Integrationen
- breitere Betriebssystem-UX-Parität über den aktuellen macOS-Menüleisten-Pfad hinaus

Siehe [docs/roadmap.md](https://github.com/rapticore/ore-mal-pkg-inspector/blob/HEAD/docs/roadmap.md) für die eher einführungsorientierte Roadmap-Ansicht.

---

## Lizenz

MIT Lizenz

Copyright (c) 2025 Rapticore

Hiermit wird jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, kostenlos die Erlaubnis erteilt, die Software ohne Einschränkung zu nutzen, einschließlich und ohne Einschränkung der Rechte zur Verwendung, Vervielfältigung, Modifikation, Zusammenführung, Veröffentlichung, Verbreitung, Unterlizenzierung und/oder zum Verkauf von Kopien der Software, und Personen, denen die Software zur Verfügung gestellt wird, dies unter folgenden Bedingungen zu gestatten:

Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.

DIE SOFTWARE WIRD "WIE BESEHEN" ZUR VERFÜGUNG GESTELLT, OHNE JEGLICHE GEWÄHRLEISTUNG, WEDER AUSDRÜCKLICH NOCH STILLSCHWEIGEND, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNG DER MARKTGÄNGIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG VON RECHTEN. IN KEINEM FALL HAFTEN DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE HAFTUNGEN, SEI ES AUS VERTRAG, UNERLAUBTER HANDLUNG ODER ANDERWEITIG, DIE AUS DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN GESCHÄFTEN MIT DER SOFTWARE RESULTIEREN.

---

## Support

### Hilfe erhalten

**Dokumentation:** Sie lesen sie gerade! Für die meisten Fragen hier beginnen.

**GitHub Discussions:** Für Fragen, Ideen und Community-Interaktion:
- https://github.com/rapticore/ore-mal-pkg-inspector/discussions

**GitHub Issues:** Für Fehlerberichte und Funktionsanfragen:
- https://github.com/rapticore/ore-mal-pkg-inspector/issues

**E-Mail:** Für Sicherheitslücken und private Anfragen:
- [email protected]

### Professioneller Support

Für Organisationen, die Folgendes benötigen:
- Benutzerdefinierte Integrationen
- SLA-gestützten Support
- Unterstützung bei privater Bereitstellung
- Benutzerdefinierte Bedrohungsinformationsfeeds

Kontakt: [email protected]

---

## Danksagungen

### Projektursprung

Dieses Projekt wurde aus dem Repository [OreNPMGuard](https://github.com/rapticore/OreNPMGuard) extrahiert, um den klaren Projektfokus beizubehalten und gleichzeitig die Fähigkeiten zu erweitern.

**OreNPMGuard** (Dezember 2025) spezialisiert sich auf die Erkennung von Shai-Hulud npm-Angriffen mit 738+ betroffenen Paketen und tiefer IoC-Analyse. Während seiner Entwicklung erkannten wir den Bedarf an einem breiteren Multi-Ökosystem-Schutz, was zur Erstellung von OreWatch als eigenständigem Tool führte, das der breiteren Entwickler-Community über alle wichtigen Paket-Ökosysteme hinweg dient.

### Verwandte Projekte

- **[OreNPMGuard](https://github.com/rapticore/OreNPMGuard)** - Spezialisierter Shai-Hulud npm-Scanner
---

**Erstellt vom Rapticore Security Research Team**

*Software-Lieferketten schützen, einen Scan nach dem anderen.*