``` ███████╗ ██████╗ ███╗ ██╗ █████╗ ██████╗ ██╔════╝██╔═══██╗████╗ ██║██╔══██╗██╔══██╗ ███████╗██║ ██║██╔██╗ ██║███████║██████╔╝ ╚════██║██║ ██║██║╚██╗██║██╔══██║██╔══██╗ ███████║╚██████╔╝██║ ╚████║██║ ██║██║ ██║ ╚══════╝ ╚═════╝ ╚═╝ ╚═══╝╚═╝ ╚═╝╚═╝ ╚═╝ ``` Wisse, was auf deiner Maschine läuft.

Sonar zeigt alles, was auf localhost lauscht, und bringt es in eine Ordnung: Jeder Port gehört zu einer Gruppe — normalerweise dem Repository, aus dem er gestartet wurde — und innerhalb dieser Gruppe zu einem benannten Dienst. Starte deine Dev-Server mit sonar start, und das gesamte Projekt wird zu einer Sache, die du als Baum auflisten, abwarten, verfolgen und mit einem einzigen Befehl stoppen kannst. Docker-Container, Compose-Projekte und Prozesse, die du von Hand gestartet hast, werden ebenfalls erkannt — ganz ohne Konfiguration.``` $ sonar list --tree my-app (3 ports, running) ~/code/my-app ├─ 5432 db postgres:17 http://localhost:5432 ├─ 5173 frontend vite (v5.4) http://localhost:5173 └─ 8000 api uvicorn app:app http://localhost:8000 ungrouped (1 port) └─ 3000 next-server (v16.1.6) http://localhost:3000

## Install

### Homebrew (macOS / Linux)```sh
brew install raskrebs/sonar/sonar

Homebrew 6 verweigert Formeln aus Drittanbieter-Taps, bis du dem Tap einmal vertraust (Error: Refusing to load formula raskrebs/sonar/sonar from untrusted tap):```sh brew trust raskrebs/sonar

### Installationsskript```sh
curl -sfL https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.sh | bash

my-app (3 ports, running) ~/code/my-app ├─ 5432 db postgres:17 http://localhost:5432 ├─ 5173 frontend vite (v5.4) http://localhost:5173 └─ 8000 api uvicorn app:app http://localhost:8000 ``` Und wenn du fertig bist, stoppe das gesamte Projekt — Server, Watcher und Worker:```sh sonar kill -g my-app ``` Examples below marked `# check` are executed against a fresh build by `scripts/readme-check.sh` on every CI run. ## Commands ### `sonar list````sh sonar list sonar list --tree sonar list --group my-app sonar list --json # check ``` ``` ## 📦 Installation ### Option 1: Docker (Recommended) ```bash docker pull kitploit/kitploit-tool docker run -it --rm kitploit/kitploit-tool ``` ### Option 2: Manual Installation ```bash git clone https://github.com/kitploit/kitploit-tool.git cd kitploit-tool pip install -r requirements.txt python setup.py install ``` ### Option 3: pip Installation ```bash pip install kitploit-tool ``` ## 🚀 Quick Start After installation, you can start using the tool immediately: ```bash kitploit-tool --help ``` To scan a target: ```bash kitploit-tool scan example.com ``` To list all available modules: ```bash kitploit-tool list-modules ``` ## ⚙️ Configuration The tool uses a configuration file located at `~/.kitploit/config.yaml`. You can customize the following settings: ```yaml # Kitploit Tool Configuration api_key: "your-api-key-here" timeout: 30 max_threads: 10 output_format: "json" verbose: false ``` ### Environment Variables The following environment variables are supported: | Variable | Description | Default | |----------|-------------|---------| | `KITPLOIT_API_KEY` | API key for authentication | None | | `KITPLOIT_TIMEOUT` | Request timeout in seconds | 30 | | `KITPLOIT_THREADS` | Maximum number of concurrent threads | 10 | | `KITPLOIT_OUTPUT` | Output format (json, yaml, csv) | json | ``````sh sonar list --stats # CPU, memory, threads, uptime, state sonar list --health # HTTP health checks sonar list --filter docker # only Docker ports sonar list --sort name # port | pid | name | type sonar list -a # include desktop apps sonar list -c port,process,group,cpu,mem sonar list --host user@server # scan a remote machine over SSH ``` Standardspalten sind `port`, `process`, `group`, `container`, `image`, `containerport`, `url`, wobei `process` den Namen anzeigt, den du dem Port gegeben hast (`sonar rename`), dann den Dienstnamen und dann das, was erkannt wurde. Verfügbare Spalten: `port`, `process`, `pid`, `type`, `url`, `group`, `cpu`, `mem`, `threads`, `uptime`, `state`, `connections`, `health`, `latency`, `container`, `image`, `containerport`, `compose`, `project`, `user`, `bind`, `ip`. Desktop-Apps und Systemdienste, die zufällig lauschen — Figma, Discord, Spotify, ControlCenter, macOS-`.app`-Bündel, `/System/Library/`-Daemons — sind ausgeblendet, außer du übergibst `-a`. ### `sonar start` Führe einen Befehl als benannten Dienst in einer Gruppe aus:```sh sonar start -- npm run dev sonar start --group my-app --name frontend -- npm run dev sonar start --port 5173 -- npm run dev # expected port, before it binds sonar start --detach --name api -- uv run uvicorn app:app sonar start --list ``` Nichts muss übergeben werden: - **Gruppe** — `--group`, sonst der `name` in der nächstgelegenen `.sonar.yaml`, sonst der Verzeichnisname des Git-Roots (ein Worktree wird zu `repo@worktree`), sonst der Name des aktuellen Verzeichnisses. - **Name** — `--name`, sonst der `.sonar.yaml`-Service, dessen `cmd` übereinstimmt, sonst aus dem Befehl abgeleitet (`npm run dev` → `dev`, `uv run api` → `api`, `python -m uvicorn` → `uvicorn`, `./dev.sh` → `dev.sh`). - **Port** — `--port` ist ein Hinweis, keine Bindung: Der Lauf wird als `starting` angezeigt, bis der Port tatsächlich lauscht, und der Daemon verwendet ihn, um den Prozess dem Port zuzuordnen. Das Kind erbt stdin, stdout, stderr, cwd und Umgebung, zusätzlich `SONAR_GROUP`, `SONAR_NAME` und `SONAR_RUN_ID`. Es erhält seine eigene Prozessgruppe, sodass `sonar kill` den gesamten Baum beendet — einen Dev-Server mit seinen Watchern und Workern. Ctrl+C wird weitergeleitet, und sonar beendet sich mit dem Exit-Code des Kindes. `--detach` kehrt sofort zurück und schreibt die Ausgabe in `~/.config/sonar/logs/<group>/<name>.log`. `--list` zeigt, was sonar gestartet hat (`--json` für die maschinenlesbare Form):```sh sonar start --list sonar start --detach --name demo --port 8123 -- sleep 5 sonar start --list --json # check ``` ### `.sonar.yaml` Ein Projekt benennt sich selbst und seine Dienste in einer `.sonar.yaml` im Repository-Stammverzeichnis. Sie ist optional — sonar gruppiert ohne sie nach dem Git-Root — und sie ist dafür gedacht, eingecheckt zu werden:```yaml name: my-app services: - name: db cmd: docker compose up db port: 5432 health: / description: Postgres 17 icon: database color: "#4f8cc9" - name: api cmd: uv run uvicorn app:app --port 8000 cwd: backend port: 8000 health: /healthz depends_on: [db] - name: frontend cmd: npm run dev port: 5173 depends_on: [api] ports: [9229] # ports that belong to this project without a service ``` - `name` — der Gruppenname. Keine Schrägstriche, keine Leerzeichen. - `cmd`, `cwd`, `port` — wie `sonar up` den Dienst startet. `cwd` ist relativ zur Datei und darf deren Verzeichnis nicht verlassen. - `health` — ein HTTP-Pfad, den der Daemon abfragt, während der Dienst läuft, sodass ein Dienst *laufen*, aber noch nicht *gesund* sein kann. Er meldet `ok`, `fail` oder `unknown`, mit dem Grund für einen Fehler. - `description`, `icon`, `color` — freie Metadaten für die Desktop-App; sonar leitet sie nie selbst ab. - `depends_on` — Startreihenfolge. Ein Dienst, der nicht in der Datei steht, oder ein Zyklus, ist ein Fehler; eine ungültige Datei wird einmal gemeldet und stoppt nie einen Scan. `.sonar.yml` wird gelesen, wenn man es so schreibt; `sonar init` schreibt immer `.sonar.yaml`. Der Daemon überwacht die Projekte, die er kennt, und übernimmt Bearbeitungen der Datei ohne Neustart. Jede Änderung, die sonar vornimmt — von der Desktop- App, von `sonar groups add`, `rename` und `remove`, von einem Agenten — läuft über den Daemon, der die Datei aus seinem eigenen Syntaxbaum neu rendert, sodass Kommentare, Schlüsselreihenfolge und Layout eine Bearbeitung überstehen, die einen Dienst hinzufügt, umbenennt oder entfernt, ebenso wie eine Metadatenänderung. Die eine Ausnahme: zusätzliche Leerzeichen, die einen nachgestellten Kommentar ausrichten (`cmd: x # note`), werden auf eines reduziert, weil die YAML-Bibliothek den Kommentar, aber nicht seine Spalte behält. ### `sonar up````sh sonar up # the .sonar.yaml at or above this directory sonar up my-app # a group by name sonar up --only api,frontend sonar up --json ``` Startet jeden Dienst, den die `.sonar.yaml` der Gruppe deklariert, in der Reihenfolge von `depends_on`: Ein Dienst wartet auf die Ports, die seine Abhängigkeiten deklarieren, bevor er gestartet wird, und einer, der bereits lauscht, wird übersprungen. Jeder läuft getrennt in seiner eigenen Prozessgruppe, mit seiner Ausgabe in `~/.config/sonar/logs/<group>/<service>.log`.``` ✓ db pid 41022 ~/.config/sonar/logs/my-app/db.log - api already running ✓ frontend pid 41108 ~/.config/sonar/logs/my-app/frontend.log 2 started, 1 already running ``` Ein Dienst, der nicht startet, wird in einer eigenen Zeile gemeldet und führt dazu, dass der Befehl mit einem Nicht-Null-Exitcode endet, unabhängig davon, was sonst noch auftritt. Stoppen Sie sie alle erneut mit `sonar kill -g my-app`. `sonar up` benötigt den Daemon und startet ihn, falls er nicht bereits läuft. ### `sonar groups` und `sonar init````sh sonar init --dry-run sonar init --service api:8000:/healthz --service web:5173 sonar groups sonar groups --json group=$(basename "$PWD") # sonar init names the group after the directory sonar groups add "$group" worker --port 9000 --cmd 'uv run worker' --depends-on api sonar groups rename "$group" worker jobs sonar groups remove "$group" jobs # check ``` `sonar groups` listet jede Gruppe auf, die sonar sehen kann, sowie woher jeder Name stammt: `manual` (du hast ihn mit `sonar assign` angeheftet), `start` (ein `sonar start`-Lauf), `file` (eine `.sonar.yaml`) oder `auto` (das Git-Root oder das Compose-Projekt). `sonar groups <name>` zeigt die Ports und Dienste einer Gruppe sowie die Dienste, die deklariert, aber nicht ausgeführt werden. `sonar init` schreibt eine `.sonar.yaml` im Git-Root aus dem, was gerade lauscht — Desktop-Apps und Ports unter 1024 werden ausgelassen. Es weigert sich, ohne `--force` zu überschreiben, und `--dry-run` gibt die Datei aus, statt sie zu schreiben. `--merge` hängt an eine bereits vorhandene Datei an, statt sich zu weigern, und `--service name:port[:health]` — wiederholbar — schreibt die Dienste, die du benennst, statt der gefundenen, wobei der Befehl beibehalten wird, den es für einen Port erraten hat, den du behalten hast. `--force` und `--merge` schließen sich gegenseitig aus. `sonar groups add <group> <name> --port N` hängt einen Dienst an die `.sonar.yaml` dieser Gruppe an, mit `--cmd`, `--cwd`, `--health`, `--description`, `--icon`, `--color` und einem wiederholbaren `--depends-on` für den Rest. `sonar groups rename <group> <old> <new>` benennt einen überall in der Datei um, einschließlich `depends_on`-Referenzen, und `sonar groups remove <group> <name>` löscht einen und entfernt ihn aus jedem `depends_on`, das ihn genannt hat. Alle drei verweigern eine Bearbeitung, die die Datei ungültig machen würde — einen doppelten Namen, einen Port, den bereits ein anderer Dienst beansprucht, einen Dienst, der nicht vorhanden ist — und keiner von ihnen schreibt ein Byte, bis die gesamte Bearbeitung als gut bekannt ist. Der Daemon übernimmt das Schreiben, weshalb die Datei mit ihren Kommentaren und Schlüsselreihenfolge intakt zurückkommt, egal ob die Bearbeitung von der CLI, der Desktop-App oder einem Agenten stammt. `sonar groups add`, `rename` und `remove` benötigen den Daemon und starten ihn, falls er nicht bereits läuft; die drei Namen sind Unterbefehle, sodass eine Gruppe, die tatsächlich `add` heißt, mit `sonar groups --json` gelesen wird. ### `sonar kill````sh sonar kill 3000 # SIGTERM, then SIGKILL after 5s sonar kill 3000 5432 -f # SIGKILL both straight away sonar kill 3000 --tree # the listener and everything below it sonar kill --pid 12345 --tree # by process id sonar kill -g my-app # a whole group, confirms unless -y sonar kill --all --filter docker -y # every container publishing a port sonar kill --all --project my-app # one Compose project sonar kill 3000 --ip 127.0.0.1 # one bind address of several sonar kill --all --dry-run --json # the plan for the whole machine ``` `--dry-run` akzeptiert jeden Selektor und ändert nichts: Es gibt die Aktionen aus, die das Kill ausführen würde, zuerst die Kinder, und lässt alles weiterlaufen. End-to-end, gegen einen eigenen Listener:```sh sonar start --detach --name plan --port 8231 -- sonar map 3000 8231 sonar wait 8231 sonar kill 8231 --dry-run --json # the plan; the mapping keeps running sonar kill 8231 -y # and now for real # check ``` Ein Positionsargument wird als Port gelesen und nur dann als PID, wenn auf dieser Nummer nichts lauscht. `-g` gleicht die aufgelöste Gruppe, ein Legacy-Run-Tag oder eine Legacy-ID sowie das Compose-Projekt ab – ohne Beachtung der Groß-/Kleinschreibung. Ein Prozess, der SIGTERM ignoriert, erhält SIGKILL, sobald der Port nach `--grace` (5s) immer noch belegt ist; `--no-escalate` deaktiviert das. Kinder werden vor den Eltern signalisiert, sodass ein Prozessbaum in der richtigen Reihenfolge beendet wird. Docker-Container werden mit `docker stop` gestoppt und niemals signalisiert. Ein von `sonar start` gestarteter Listener wird immer zusammen mit seiner Prozessgruppe gestoppt. `--json` gibt eine Zeile pro Prozess aus: `{port, bind_address, pid, name, method, ok, error}`, wobei `method` entweder `sigterm`, `sigkill`, `docker_stop`, `map_stop` oder `none` ist. Ein leerer Durchlauf endet mit 0; eine unbekannte Gruppe mit 1. ### `sonar map````sh sonar map 6873 3002 # also serve the service on 6873 from port 3002 ``` Führt einen TCP-Proxy im Vordergrund aus, bis Sie ihn stoppen. `sonar kill` meldet ein Mapping, das es gestoppt hat, als `map_stop`. ### `sonar rename`, `sonar assign`, `sonar history````sh sonar rename 3000 storefront # a name of your own, survives restarts sonar rename 3000 --clear sonar assign 3000 my-app # pin a port to a group by hand sonar assign 3000 --clear sonar history # everything that came up, went down, restarted sonar history 3000 --since 24h --limit 20 ``` ``` ## 📦 Installation ### Option 1: Install via pip ```bash pip install kitploit ``` ### Option 2: Install from source ```bash git clone https://github.com/kitploit/kitploit.git cd kitploit pip install -r requirements.txt python setup.py install ``` ### Option 3: Use with Docker ```bash docker pull kitploit/kitploit docker run -it --rm kitploit/kitploit ``` ## 🚀 Quick Start After installation, you can start using Kitploit immediately: ```bash kitploit --help ``` To search for a specific tool: ```bash kitploit search nmap ``` To get detailed information about a tool: ```bash kitploit info metasploit ``` ## 📚 Usage Examples ### Searching for tools ```bash # Search by name kitploit search sqlmap # Search by category kitploit search --category web # Search by tag kitploit search --tag exploit ``` ### Managing your tool collection ```bash # List all installed tools kitploit list # Update the tool database kitploit update # Remove a tool kitploit remove toolname ``` ## 🔧 Configuration Kitploit can be configured via a configuration file located at `~/.kitploit/config.yaml`: ```yaml # Example configuration database: path: ~/.kitploit/tools.db auto_update: true search: default_limit: 20 fuzzy_match: true notifications: enabled: true email: [email protected] ``` ## 🛠️ Advanced Features ### Custom tool categories You can create custom categories to organize your tools: ```bash kitploit category create "Network Analysis" kitploit category add nmap --to "Network Analysis" ``` ### Automation and scripting Kitploit supports JSON output for integration with other tools: ```bash kitploit search nmap --format json ``` ### API integration Kitploit provides a REST API for programmatic access: ```bash kitploit api start --port 8080 ``` ## 🤝 Contributing We welcome contributions from the community! Here's how you can help: 1. Fork the repository 2. Create a feature branch (`git checkout -b feature/amazing-feature`) 3. Commit your changes (`git commit -m 'Add some amazing feature'`) 4. Push to the branch (`git push origin feature/amazing-feature`) 5. Open a Pull Request ## 📄 License This project is licensed under the MIT License - see the [LICENSE](https://github.com/raskrebs/sonar/blob/main/LICENSE) file for details. ## 🙏 Acknowledgments - All the amazing open-source security tools that make this project possible - The security research community for their continuous contributions - All contributors and maintainers who help improve Kitploit every day ## 📞 Contact For questions, suggestions, or support: - **GitHub Issues**: [https://github.com/kitploit/kitploit/issues](https://github.com/kitploit/kitploit/issues) - **Discord**: [Join our Discord server](https://discord.gg/kitploit) - **Email**: [email protected] --- **Happy Hacking!** 🛡️ ``````sh sonar history --since 1h sonar history --json # check ``` Namen und Pins werden in sonars Datenbank gespeichert, abgelegt nach dem spezifischsten bekannten Merkmal des Ports: dem Run (`run:<group>/<name>`), dem Container (`docker:<project>/<service>`), dem Arbeitsverzeichnis und zuletzt der Portnummer. Ein umbenannter Dev-Server behält seinen Namen über Neustarts hinweg; ein Name, der allein an Port 3000 gebunden ist, gilt für alles, was dort antwortet. Diese drei Befehle benötigen den Daemon und starten ihn, falls er nicht läuft. ### Einen Port auslesen```sh sonar info 3000 # command, user, bind, stats, health sonar logs 3000 # tail; docker logs for containers sonar wait 5432 3000 --timeout 60s # block until ready sonar wait 5432 --http=/health # wait for HTTP 200-399, not just TCP sonar next 3000 # first free port from 3000 sonar next 3000-3100 -n 3 # three consecutive free ports sonar graph # who is connected to whom sonar graph --dot # Graphviz sonar open 3000 # open in the browser sonar attach 3000 # shell into the container, or TCP sonar watch # live view sonar watch --stats --notify ``` Hier ist die Übersetzung des Chunks 59 von 107: --- **Hinweis:** Da der Eingabetext (INPUT) leer ist, gibt es keinen Inhalt zu übersetzen. Bitte stellen Sie den tatsächlichen Text des Chunks bereit, damit ich ihn gemäß den Regeln übersetzen kann.```sh sonar next 3000 sonar next 3000-3100 -n 3 --json sonar graph --json sonar info --help # check ``` `sonar wait` beendet mit `0` (bereit), `1` (Zeitüberschreitung) oder `2` (unterbrochen), was es zur idealen Ergänzung zwischen dem Starten von etwas und dem Testen macht:```sh docker compose up -d sonar wait 5432 3000 --timeout 60s && npm run migrate && npm run test ``` **Daemon oder direkter Scan.** Jeder Lese-Befehl fragt den Daemon, falls einer läuft, weil dieser die Antwort bereits hat und kein `lsof` forken muss. Wenn keiner läuft, scannen sie direkt und geben eine Notiz auf stderr aus, die dies sagt. `sonar kill` folgt derselben Regel: Ein erreichbarer Daemon übernimmt das Beenden, sodass er sofort neu scannt und seine nächste Antwort — sowie die Port-Historie — bereits weiß, dass der Port weg ist. Weder Lese- noch Kill-Vorgänge starten einen Daemon hinter deinem Rücken. `--no-daemon` erzwingt den direkten Scan still und funktioniert mit jedem Befehl:```sh sonar list --no-daemon --json # check ``` ### `sonar host````sh sonar host # cpu, load, memory and disk of the machine sonar watches sonar host --json ``` Hier ist die Übersetzung des Chunks 67 von 107: ```markdown ## Verwendung ### Grundlegende Verwendung ```bash python3 tool.py -t <Ziel> [Optionen] ``` ### Optionen | Option | Beschreibung | |--------|--------------| | `-t, --target` | Ziel-URL oder IP-Adresse (erforderlich) | | `-p, --port` | Zielport (Standard: 80) | | `-s, --ssl` | SSL/TLS aktivieren | | `-o, --output` | Ausgabedatei für Ergebnisse | | `-v, --verbose` | Ausführliche Ausgabe aktivieren | | `-h, --help` | Hilfe anzeigen | ### Beispiele **Einfacher Scan:** ```bash python3 tool.py -t example.com ``` **Scan mit benutzerdefiniertem Port und SSL:** ```bash python3 tool.py -t example.com -p 443 -s ``` **Ergebnisse in Datei speichern:** ```bash python3 tool.py -t example.com -o ergebnisse.txt ``` ## Konfiguration Die Konfigurationsdatei befindet sich unter `config/config.yaml`. Hier können Sie Standardwerte für verschiedene Parameter festlegen: ```yaml # Standardkonfiguration standard: port: 80 timeout: 10 threads: 5 # API-Schlüssel api: virustotal: "IHR_API_SCHLUESSEL" shodan: "IHR_API_SCHLUESSEL" ``` ## Module Das Tool besteht aus mehreren Modulen, die jeweils eine bestimmte Funktion erfüllen: ### 1. Recon-Modul Das Recon-Modul sammelt Informationen über das Ziel, einschließlich: - DNS-Auflösung - Subdomain-Enumeration - Offene Ports - Dienstversionen ### 2. Schwachstellen-Scanner Dieses Modul sucht nach bekannten Schwachstellen: - SQL-Injection - XSS (Cross-Site-Scripting) - Command Injection - Unsichere Konfigurationen ### 3. Berichtsmodul Das Berichtsmodul generiert detaillierte Berichte über die Scan-Ergebnisse: - HTML-Berichte - JSON-Ausgabe - Markdown-Zusammenfassungen ``` (Anmerkung: Der Originaltext enthält einen Codeblock mit YAML-Konfiguration, der unverändert bleibt. Die Übersetzung betrifft nur die natürlichen Sprachteile.)```sh sonar host # check ``` Der Daemon misst seinen eigenen Rechner im Scan-Rhythmus und veröffentlicht ihn als `localhost`-Zeile in der `hosts`-Sammlung des Snapshots: Betriebssystem und Kernel, Uptime, CPU-Prozent, Lastdurchschnitt, Speicher und das Laufwerk, das `/` enthält. Die CPU-Prozentzahl ist die Arbeit, die zwischen zwei Scans geleistet wurde, ist also null, bis der Daemon zweimal gescannt hat; ein Wert, den eine Plattform nicht liefern kann — der Lastdurchschnitt unter Windows, wo es keinen gibt — ist null statt null. Jeder Host, der mit `sonar remote add` registriert ist, tritt derselben Tabelle mit seiner eigenen Last bei. Der Befehl benötigt einen laufenden Daemon: Es ist der Daemon, der die vorherige Stichprobe hält, gegen die ein Prozentsatz gemessen wird. ### `sonar remote install````sh sonar remote install [email protected] # same version as this sonar sonar remote install hetzner --version v0.6.0 # a Host from ~/.ssh/config sonar remote install deploy@box --no-service # the binary, no daemon ``` Setzt Sonar auf einem Host ein, zu dem du bereits SSH-Zugang hast, und startet dort dessen Daemon. Das Release-Archiv wird **auf dem Remote-Host** heruntergeladen und geprüft — es wird nichts von dieser Maschine kopiert — und die Binärdatei landet in `~/.local/bin/sonar`, sodass dafür keine Root-Rechte nötig sind. Der Daemon läuft als systemd-User-Unit, sofern der Host eine solche unterstützt (`~/.config/systemd/user/sonar.service`), andernfalls abgekoppelt; `loginctl enable-linger` wird als Hinweis ausgegeben, falls die Benutzersitzung beim Abmelden enden und den Daemon mitnehmen würde. Die installierte Version entspricht der Version des Sonar, von dem aus du es ausgeführt hast, sodass beide Enden dasselbe Protokoll sprechen. Eine erneute Ausführung aktualisiert direkt vor Ort und startet den Daemon neu — genau das macht Installation und Update zum selben Befehl. Das Ziel geht unverändert an `ssh`: Ein `Host`-Alias aus `~/.ssh/config` funktioniert, ebenso wie die dort gesetzten `ProxyJump`, `IdentityFile` und `Port`. `--identity` und `--ssh-arg` sind für die Flags gedacht, die eine Konfiguration nicht abdeckt. ### `sonar remote````sh sonar remote add [email protected] # name taken from the target sonar remote add hetzner [email protected] # or given sonar remote list # status, latency, version, load sonar remote remove hetzner sonar list --host hetzner # that host's ports sonar list --host "*" # every host, with a HOST column sonar info 3000 --host hetzner ``` Ein registrierter Host läuft mit demselben Daemon, und der Daemon auf dieser Maschine hält eine SSH-Verbindung zu ihm — `ssh <target> sonar daemon stdio` — und multiplexiert das, was er meldet, in den Zustand, den jeder Client bereits liest. Nichts Neues lauscht irgendwo: Der Socket des entfernten Daemons bleibt privat für den SSH-Benutzer, und Clients sprechen selbst nie SSH. Jede Zeile trägt nun den Host, von dem sie stammt. Lokale Zeilen sagen `localhost` und behalten die Schlüssel, die sie immer hatten, sodass sich nichts ändert, was sonar heute liest; entfernte Zeilen sagen den registrierten Namen und sind mit `<host>/<port>:<bind>` verschlüsselt, was es ermöglicht, dass Port 3000 auf zwei Maschinen zwei Zeilen sind. Ein Abonnent sieht nur localhost, es sei denn, er fragt nach mehr (`state.subscribe {"hosts": ["*"]}`). Das Ziel geht unverändert an `ssh`, sodass `~/.ssh/config`-Aliase, `ProxyJump` und Identitäten alle gelten; `--ssh-arg`, `--identity` und `--port` decken ab, was eine Konfiguration nicht tut. sonar speichert kein Passwort und keinen Schlüssel. Ein Host, der verschwindet, behält seine Zeile und seinen Status, während der Daemon es erneut versucht und von einer Sekunde auf dreißig zurückgeht, solange er registriert bleibt. `--host` akzeptiert weiterhin auch ein nacktes `user@host`, von dem sonar nichts weiß: Es fällt auf den agentenlosen `ssh`- + `ss`/`lsof`-Scan zurück und gibt einen Hinweis auf `sonar remote install` aus. #### Auf einer anderen Maschine handeln Jeder Schreibvorgang akzeptiert ebenfalls `--host` und tut dort genau das, was er hier tut:```sh sonar kill 3000 --host hetzner # stop a port on that machine sonar kill -g api --host hetzner # a whole group of its services sonar kill-all --filter docker --host hetzner # its containers sonar up api --host hetzner # start a group from its .sonar.yaml sonar logs 3000 --host hetzner # tail its output here sonar rename 3000 storefront --host hetzner # its name, in its database sonar assign 3000 storefront --host hetzner ``` Der lokale Daemon leitet den Aufruf über die Brücke dieses Hosts weiter und gibt zurück, was der entfernte Daemon geantwortet hat, im selben Umschlag, in dem auch ein lokaler Aufruf zurückkehrt — jede Ergebniszeile sagt, auf welchem Host sie passiert ist, und die `affected`-Angabe eines Kills trägt die `<host>/<port>:<bind>`-Schlüssel, die der Stream für diese Zeilen verwendet. Ein Streaming-Befehl streamt: `sonar up --host` gibt jeden Dienst aus, sobald die Gegenseite ihn startet, und Strg-C stoppt die entfernte Arbeit, nicht nur dieses Terminal. Da ein Zeilenschlüssel bereits seinen Host benennt, kann ein Client einen direkt zurückreichen als Selektor — `{"key": "hetzner/3000:127.0.0.1"}` ist der gesamte Selektor, Host inklusive. Ein Aufruf wirkt auf eine Maschine; zwei zu benennen ist ein Fehler statt eines halben Kills auf jeder. Zwei Dinge bleiben lokal. `sonar attach` setzt *dieses* Terminal vor einen Prozess, daher verweigert es `--host` und sagt, man solle per SSH hinüberwechseln und dort anhängen. Und eine Agent-Sitzung ist ein Zustand, den dieser Daemon hält, daher hat `sonar kill --session` keine entfernte Form. Alles andere benötigt den hier laufenden Daemon — er ist der Ort, an dem die Verbindung zur anderen Maschine lebt — und sagt das, statt stillschweigend diese Maschine zu scannen. `sonar up --host` benötigt die benannte Gruppe: Die `.sonar.yaml` in Ihrem Arbeitsverzeichnis ist ein Pfad auf dieser Maschine, und es ist der entfernte Daemon, der die Datei liest und die Dienste startet. ### Der Daemon Ein Hintergrundprozess scannt Ports, löst Gruppen auf, pollt den Gesundheitszustand, pflegt die Datenbank und streamt Änderungen an alle, die abonniert haben — die CLI, die Desktop- App und Editoren.```sh sonar serve # in the foreground sonar serve --detach # in the background sonar daemon status # pid, uptime, subscribers, scans, intervals sonar daemon path # the socket it listens on sonar daemon log -n 50 -f # what it is doing sonar daemon restart sonar daemon stop ``` ``` ## 🛡️ Sicherheitshinweis **Wichtig:** Dieses Tool ist ausschließlich für autorisierte Sicherheitstests und Bildungszwecke gedacht. Die unbefugte Nutzung dieses Tools gegen Systeme, die Ihnen nicht gehören oder für die Sie keine ausdrückliche schriftliche Genehmigung haben, ist illegal und unethisch. Der Autor und Kitploit übernehmen keinerlei Verantwortung für Missbrauch oder Schäden, die durch die Verwendung dieses Tools entstehen. Sie sind allein für die Einhaltung aller geltenden Gesetze und Vorschriften verantwortlich. --- ## 📦 Installation ```bash git clone https://github.com/example/repo.git cd repo pip install -r requirements.txt ``` --- ## 🚀 Schnellstart ```bash python main.py --target example.com --output results.txt ``` --- ## ⚙️ Konfiguration Die Konfiguration erfolgt über eine YAML-Datei: ```yaml target: host: example.com port: 443 protocol: https scan: threads: 10 timeout: 30 verbose: true ``` --- ## 🧰 Verwendung ### Grundlegende Befehle | Befehl | Beschreibung | |--------|--------------| | `--scan` | Führt einen vollständigen Scan durch | | `--list-modules` | Listet alle verfügbaren Module auf | | `--update` | Aktualisiert die Signaturdatenbank | | `--help` | Zeigt die Hilfe an | ### Erweiterte Optionen - `--threads N`: Legt die Anzahl der gleichzeitigen Threads fest (Standard: 10) - `--timeout N`: Legt das Timeout in Sekunden fest (Standard: 30) - `--output FILE`: Gibt die Ausgabedatei an - `--verbose`: Aktiviert die ausführliche Ausgabe --- ## 📁 Projektstruktur ``` . ├── main.py # Haupteinstiegspunkt ├── config.yaml # Konfigurationsdatei ├── modules/ # Scan-Module │ ├── __init__.py │ ├── http.py # HTTP-Scan-Modul │ └── dns.py # DNS-Scan-Modul ├── utils/ # Hilfsfunktionen │ ├── logger.py # Protokollierungsmodul │ └── helpers.py # Allgemeine Hilfsfunktionen └── requirements.txt # Python-Abhängigkeiten ``` --- ## 🔧 Fehlerbehebung ### Häufige Probleme 1. **Berechtigungsfehler**: Stellen Sie sicher, dass Sie über die erforderlichen Berechtigungen verfügen, um Netzwerkscans durchzuführen. 2. **Abhängigkeitsfehler**: Führen Sie `pip install -r requirements.txt` erneut aus, um sicherzustellen, dass alle Abhängigkeiten installiert sind. 3. **Firewall-Probleme**: Konfigurieren Sie Ihre Firewall so, dass ausgehende Verbindungen zu den Zielhosts zugelassen werden. --- ## 🤝 Mitwirken Beiträge sind willkommen! Bitte befolgen Sie diese Schritte: 1. Forken Sie das Repository 2. Erstellen Sie einen Feature-Branch (`git checkout -b feature/AmazingFeature`) 3. Committen Sie Ihre Änderungen (`git commit -m 'Füge einige AmazingFeature hinzu'`) 4. Pushen Sie den Branch (`git push origin feature/AmazingFeature`) 5. Öffnen Sie einen Pull Request --- ## 📄 Lizenz Dieses Projekt ist unter der MIT-Lizenz lizenziert – siehe die Datei [LICENSE](https://github.com/raskrebs/sonar/blob/main/LICENSE) für Details. --- ## 🙏 Danksagungen - Allen Mitwirkenden, die zu diesem Projekt beigetragen haben - Der Open-Source-Community für ihre kontinuierliche Unterstützung - Kitploit für die Bereitstellung dieser Plattform ``````sh sonar daemon path sonar daemon status --json sonar daemon log -n 5 # check ``` | Was | Wo | |---|---| | Socket | `$XDG_RUNTIME_DIR/sonar/daemon.sock`, sonst `~/.config/sonar/daemon.sock`; `\\.\pipe\sonar` unter Windows | | Datenbank | `~/.config/sonar/sonar.db` (`SONAR_DB` überschreibt) | | Daemon-Log | `~/.config/sonar/daemon.log`, rotiert bei 5 MiB, drei werden behalten | | Lauf-Logs | `~/.config/sonar/logs/<gruppe>/<dienst>.log` | | Konfiguration | `~/.config/sonar/config.yaml` | `SONAR_SOCKET` überschreibt den Socket-Pfad überall, sowohl für den Daemon als auch für seine Clients — nützlich für eine zweite isolierte Instanz. Der Socket wird mit 0600 in einem 0700-Verzeichnis erstellt, sodass nur du mit ihm sprechen kannst. Es läuft nur ein Daemon gleichzeitig; ein nach einem Absturz zurückgelassener Socket wird beim nächsten Start bereinigt. Der Daemon stoppt von selbst nach 30 Minuten ohne Clients und ohne Abonnenten. Setze `daemon.idle_timeout` in der Konfigurationsdatei, um das zu ändern, oder `0`, um ihn weiterlaufen zu lassen. Ports werden alle 2 Sekunden gescannt, während sich etwas ändert; wenn nichts passiert, verlangsamt sich der Scanner auf 5 Sekunden mit einem verbundenen Abonnenten und 10 Sekunden ohne einen. `daemon.scan_interval` verschiebt diese Basis — Minimum 1s — und beide Obergrenzen skalieren damit, sodass eine Erhöhung auf `5s` auf 12,5s und 25s zurückfällt, anstatt die Kurve an den alten Grenzen festzunageln. `daemon.stats_interval` ist der separate Takt, in dem CPU, Speicher und der Host-Laststreifen aktualisiert werden, während etwas abonniert ist. Beide werden beim Start des Daemons gelesen: Bearbeite die Datei, dann `sonar daemon restart`. `sonar daemon status` gibt die geltenden Werte (`scan base`, `stats tick`) neben dem adaptiven Intervall aus, auf dem der Scanner gerade läuft. Ein Abonnent, der `include: ["health"]` anfordert, veranlasst den Daemon, **jeden lauschenden Port** in einem langsameren Takt zu prüfen, nicht nur die Dienste, die einen `health:`-Pfad deklarieren — diese werden bei jedem Tick abgefragt und erreichen jeden Abonnenten, unabhängig davon, ob Health angefordert wurde oder nicht. ### Konfiguration `~/.config/sonar/config.yaml` ist optional; Flags gewinnen immer.```sh sonar config path sonar config init # check ``` The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the tool without verifying the signature. However, it is recommended to always verify the signature to ensure the integrity of the tool. The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to quickly test the```sh sonar config edit # open it in $EDITOR ``` ``` ## 🛡️ Sicherheitshinweis **Wichtig:** Dieses Tool ist ausschließlich für autorisierte Sicherheitstests und Bildungszwecke gedacht. Der Autor übernimmt keinerlei Verantwortung für Missbrauch oder Schäden, die durch die Verwendung dieses Tools entstehen. Stelle sicher, dass du die entsprechenden Genehmigungen einholst, bevor du dieses Tool auf Systemen einsetzt, die du nicht besitzt oder für die du keine ausdrückliche Erlaubnis hast. --- ## 📜 Lizenz Dieses Projekt ist unter der [MIT-Lizenz](https://github.com/raskrebs/sonar/blob/main/LICENSE) lizenziert. --- ## ⭐ Zeig deine Unterstützung Wenn dir dieses Projekt gefällt, gib ihm bitte einen ⭐ Stern auf GitHub! Deine Unterstützung hilft, das Projekt zu verbessern und zu pflegen. --- ## 🙏 Danksagungen - Besonderer Dank geht an die Open-Source-Community für ihre kontinuierliche Unterstützung und Beiträge. - Danke an alle Mitwirkenden, die bei der Verbesserung dieses Projekts geholfen haben. --- ## 📬 Kontakt Bei Fragen, Vorschlägen oder Feedback kannst du gerne ein Issue auf GitHub eröffnen oder dich über die Projektseite an den Autor wenden. --- *Viel Spaß beim Erkunden und bleib sicher!* 🚀 ``````yaml list: columns: [port, process, group, container, image, containerport, url] sort: port # port | pid | name | type filter: "" # docker | user | system | "" (all) all: false # include desktop apps by default daemon: idle_timeout: 30m # 0 keeps the daemon running log_level: info # debug | info | warn | error scan_interval: 2s # base port-scan cadence, minimum 1s stats_interval: 1s # cpu/memory refresh while subscribed, minimum 250ms color: true services: # label custom/unknown ports 9000: php-fpm 5050: my-dashboard ``` Invalid values are mit einer Warnung ignoriert und sonar fährt mit den Standardwerten fort. Umgebungs-Overrides ohne Konfigurationsschlüssel: `SONAR_DB`, `SONAR_SOCKET`, `SONAR_NO_HINTS=1`, um die Migrationshinweise unten zu unterdrücken, und `SONAR_NO_AUTOSTART=1`, um zu verhindern, dass ein sonar-Client einen Daemon startet, den er nicht gefunden hat — nützlich in CI, wo ein Build niemals einen Prozess zurücklassen sollte. sonars eigene Testsuite setzt `SONAR_NO_AUTOSTART=1` für jede Test-Binary und prüft nach dem Lauf auf einen Daemon, der ihn überlebt hat. Diese Sperre beansprucht nur ein `serve`, das aus dem privaten Temp-Root des Laufs gestartet wurde, sodass zwei parallel auf einer Maschine laufende Suiten die Daemons des jeweils anderen in Ruhe lassen; `SONAR_TESTENV_GATE_ALL=1` erweitert sie zurück auf jedes `sonar serve` irgendwo unter dem Temp-Verzeichnis, was ein CI-Runner, der die gesamte Maschine besitzt, möchte. ### Agents: MCP, Skills und Hooks```sh sonar install mcp --claude-code # merge into <git root>/.mcp.json sonar install mcp --cursor --scope user # ~/.cursor/mcp.json sonar install mcp --codex # codex mcp add sonar install skills --claude-code # the bundled sonar skill sonar install hooks --claude-code # optional, see below ``` Hier ist die Übersetzung des Chunks 87 von 107: --- **Hinweis:** Da der Eingabetext (INPUT) leer ist, gibt es keinen Inhalt zu übersetzen. Bitte stellen Sie den tatsächlichen Text des Chunks bereit, damit ich ihn gemäß den Regeln ins Deutsche übersetzen kann.```sh sonar install mcp --generic --print sonar install skills --print sonar install hooks --print # check ``` `install mcp` registriert `{"command": "sonar", "args": ["mcp"]}` und lässt jeden anderen Server und Schlüssel in der Datei unangetastet; eine zweite Ausführung ändert nichts, und `--uninstall` entfernt genau das, was sonar geschrieben hat. `sonar mcp` ist dieser Server: ein stdio-MCP-Server, der in die Binärdatei integriert ist und einem Agenten die Sicht des Daemons auf die Maschine gibt. Er liest mit `list_ports` und `inspect_port`, wartet mit `wait_for_port`, wählt und reserviert Ports mit `next_free_port` und `claim_port` und beantwortet die übrigen Fragen eines Agenten mit `tail_logs`, `health_check`, `dependency_graph`, `port_history` und `list_sessions`; Aktionen und Ressourcen folgen als Nächstes. Er startet einen Daemon, wenn keiner läuft, und verbindet sich von selbst neu, wenn einer verschwindet; seine Logs gehen an stderr, weil stdout das Protokoll überträgt. `install skills` schreibt die gebündelte Fähigkeit, die einem Agenten beibringt, Server mit `sonar start --` zu starten, mit `sonar wait` statt zu schlafen und aufzuräumen, was er gestartet hat. `install hooks` fügt zwei Claude-Code-Hooks hinzu: einer exportiert `SONAR_SESSION`, sodass alles, was eine Sitzung startet, ihr zugeordnet wird, der andere schlägt `sonar start --` vor, wenn ein nackter Dev-Server gleich ausgeführt wird (er rät, er blockiert nie). Beide akzeptieren `--scope project|user`, `--print` und `--uninstall`. ### `sonar doctor` Ein Befehl, der alles prüft, wovon sonar abhängt, und sagt, was gegen das jeweilige Problem zu tun ist. Er ist das, was die Desktop-App während des Onboardings ausführt, und das, was man selbst ausführen sollte, wenn etwas nicht stimmt.```sh sonar doctor # the table, and a one-line verdict sonar doctor --json # {ok, checks, version, daemon_version} sonar doctor --only db_ok,tray # just these sonar doctor --only mcp_registered # a whole family sonar doctor --project ~/code/api # a project other than the working directory sonar doctor --fix --yes # apply the safe repairs, then check again ``` Hier ist die Übersetzung des Chunks 91 von 107: ```markdown ## Verwendung ### Grundlegende Verwendung ```bash python3 tool.py -t <Ziel> [Optionen] ``` ### Optionen | Option | Beschreibung | |--------|--------------| | `-t, --target` | Ziel-IP-Adresse oder Hostname (erforderlich) | | `-p, --port` | Zielport (Standard: 80) | | `-s, --ssl` | SSL/TLS für die Verbindung aktivieren | | `-o, --output` | Ausgabedatei für Ergebnisse | | `-v, --verbose` | Ausführliche Ausgabe aktivieren | | `-h, --help` | Hilfemeldung anzeigen | ### Beispiele **Einfacher Scan:** ```bash python3 tool.py -t example.com ``` **Scan mit benutzerdefiniertem Port und SSL:** ```bash python3 tool.py -t 192.168.1.1 -p 443 -s ``` **Ergebnisse in einer Datei speichern:** ```bash python3 tool.py -t example.com -o ergebnisse.txt ``` ## Konfiguration Die Konfigurationsdatei befindet sich unter `config.yaml`. Sie können die folgenden Parameter anpassen: ```yaml # Konfigurationsbeispiel timeout: 10 threads: 5 user_agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" proxy: null ``` ## Fehlerbehebung ### Häufige Probleme 1. **Verbindungsfehler**: Stellen Sie sicher, dass das Ziel erreichbar ist und der Port offen ist. 2. **Berechtigungsfehler**: Führen Sie das Tool mit ausreichenden Rechten aus (z. B. `sudo`). 3. **Abhängigkeitsfehler**: Installieren Sie alle erforderlichen Pakete mit `pip install -r requirements.txt`. ## Lizenz Dieses Projekt ist unter der MIT-Lizenz lizenziert. Weitere Informationen finden Sie in der Datei `LICENSE`. ## Haftungsausschluss Dieses Tool ist nur für Bildungs- und autorisierte Sicherheitstests gedacht. Die Nutzung auf Systemen ohne ausdrückliche Genehmigung ist illegal. Der Autor übernimmt keine Verantwortung für Missbrauch. ``````sh # check sonar doctor --only daemon_reachable,daemon_protocol,socket_permissions,db_ok sonar doctor --json --only config_parses | grep -q '"status": "ok"' sonar doctor --only mcp_registered --project . > /dev/null ``` Jede Prüfung meldet `ok`, `warn`, `fail` oder `skip`. `skip` bedeutet, dass es nichts zu prüfen gab — Cursor ist nicht installiert, die Maschine hat kein Docker, der Socket ist auf Windows eine Named Pipe — und zählt nie gegen dich. Der Exit-Code ist 0, außer etwas ist **fehlgeschlagen**, also gehört `sonar doctor` in ein Setup-Skript. | Prüfung | Bedeutung | | --- | --- | | `cli_on_path` | die Binärdatei, die du ausgeführt hast, ist die, die PATH auflöst; nennt die überlagernde Installation, falls nicht | | `cli_version_current` | verglichen mit dem neuesten Release, oder `skip`, wenn GitHub in 2s nicht erreichbar ist | | `config_parses` | deine `config.yaml` lädt; ein Syntaxfehler wird mit Zeile, Spalte und einem Caret gemeldet | | `config_dir_writable` | der Daemon kann sein Log, seine Sperrdatei und seine Datenbank schreiben | | `daemon_reachable` | etwas lauscht auf dem Socket | | `daemon_version_matches` | der laufende Daemon hat die Version der CLI, die du verwendest | | `daemon_protocol` | die Protokoll-Hauptversion des Daemons passt zu diesem Build | | `socket_permissions` | der Socket gehört dir und ist 0600, in einem 0700-Verzeichnis (`skip` auf Windows) | | `db_ok` | die Datenbank öffnet, ist auf dem neuesten Schema, und wie groß sie ist | | `mcp_registered.{claude_code,cursor,codex}` | sonars MCP-Server ist in der Konfiguration dieses Clients | | `skills_installed` | die gebündelte Skill ist installiert und aktuell | | `hooks_installed` | die optionalen Claude-Code-Hooks sind installiert | | `project_config` | dieses Projekt hat eine `.sonar.yaml`, die lädt | | `docker` | die Docker-CLI ist vorhanden und ihr Daemon antwortet | | `desktop_installed` | die Desktop-App ist installiert, und welche Version (`skip` auf Windows) | | `tray` | die überholte macOS-`sonar-tray`-Binärdatei ist noch vorhanden | `--fix` wendet nur die Reparaturen an, die sicher unbeaufsichtigt durchgeführt werden können, und fragt zuerst, außer du übergibst `--yes`: Es verschiebt eine nicht parsebare `config.yaml` zu `config.yaml.broken-<timestamp>` und schreibt eine frische Vorlage (es wird nie etwas gelöscht), startet einen Daemon neu, der nicht läuft, und führt den `sonar install mcp|skills|hooks`-Befehl aus, den die Prüfung nennt — aus dem Arbeitsverzeichnis, so wie du ihn tippen würdest, also führe `--fix` innerhalb des Projekts aus, das du reparierst, anstatt `--project` darauf zu richten. Dann prüft es erneut. Alles, was es nicht anfassen wird — eine überlagernde Binärdatei auf PATH, eine Skill, die sonar nicht geschrieben hat — bleibt dir mit dem genauen Befehl in der `fix`-Spalte überlassen. Die Desktop-App ruft dieselben Prüfungen über die `daemon.doctor`-Methode des Daemons auf, anstatt Prozesse zu starten. Der Daemon führt alles aus, was er aus seinem eigenen Prozess heraus kann; die drei Prüfungen, die sich auf die CLI-Binärdatei beziehen, die du aufgerufen hast (`cli_on_path`, `cli_version_current`, `daemon_version_matches`), kommen als `skip` zurück, mit einem Detail, das dies angibt. ### Die Desktop-App Die Sonar-App ist dasselbe Bild in einem Fenster und in der Menüleiste oder im System-Tray: Gruppen an der Seite, Ports in einem Raster mit Live-Statistiken und Gesundheit, Logs und die Schaltflächen für alles oben. Sie spricht mit demselben Daemon, sodass CLI und App nie uneins sind. `sonar install desktop` installiert sie und `sonar tray` startet sie. Bis die App ausgeliefert wird, enthalten die macOS-Release-Tarballs weiterhin die alte `sonar-tray`-Menüleisten-Binärdatei, und `sonar tray` fällt darauf zurück, wenn die App nicht installiert ist. ### `sonar install desktop` Die App ist in der Beta und noch nicht von Apple signiert, also installiert sie die CLI:```sh brew install raskrebs/sonar/sonar && sonar install desktop ``` Das ist das gesamte Tester-Setup. Sonar ruft ein Manifest veröffentlichter Builds ab, wählt den für deinen Rechner aus, prüft dessen sha256 und dessen Größe, installiert ihn und öffnet ihn. **Aus diesem Grund übernimmt die CLI den Download.** macOS weist allem, was ein *Browser* speichert, ein Quarantäne-Attribut zu, und Gatekeeper weigert sich, eine unter Quarantäne gestellte App zu öffnen, die Apple nicht notarisiert hat. Eine Datei, die diese CLI herunterlädt, erhält das Attribut von vornherein nie, sodass sich die Beta ohne Eingabeaufforderung und ohne den Rechtsklick-Öffnen-Tanz öffnet. Sonar setzt weder Quarantäne-Attribute noch entfernt sie — es gibt nichts zu entfernen.```sh sonar install desktop # install and launch sonar install desktop --no-launch # install only sonar install desktop --update # update; does nothing if current sonar install desktop --check # exit 1 when an update is available sonar install desktop --version 0.1.0-beta.1 sonar install desktop --force # ask a running Sonar to quit first sonar install desktop --json # for scripts ``` Der Befehl benötigt kein Netzwerk, um dir zu sagen, was er tut:```sh sonar install desktop --help | grep -- '--no-launch' # check ``` Wo es installiert wird: | | | | --- | --- | | macOS | `/Applications/Sonar.app` oder `~/Applications/Sonar.app`, wenn das erste Verzeichnis nicht beschreibbar ist (sonar verwendet niemals `sudo`) | | Linux | `~/.local/opt/sonar-desktop/Sonar.AppImage`, plus ein Menüeintrag in `~/.local/share/applications` und ein `sonar-desktop`-Link in `~/.local/bin` | | Windows | noch nicht — der Befehl sagt dies und beendet sich mit Exit-Code 1 | `--dir` überschreibt das Verzeichnis auf beiden Systemen. Unter Linux installiert `--deb` die `.deb`-Datei über `apt`/`dpkg` anstelle des AppImage, sofern das Release eine solche veröffentlicht. Die Installation ist atomar: Die neue App wird neben der alten entpackt und per Umbenennung ausgetauscht, sodass ein fehlgeschlagener Download dich nie ohne funktionierende App zurücklässt. Wenn die App geöffnet ist, weigert sich sonar, anstatt ein Bundle darunter zu ersetzen; `--force` fordert sie zum Beenden auf und wartet bis zu zehn Sekunden. `sonar install desktop` zeichnet `desktop.installed_version` und `desktop.installed_path` in `~/.config/sonar/config.yaml` auf — so findet `sonar tray` eine mit `--dir` installierte App und so kennt die Prüfung `desktop_installed` von `sonar doctor` die Version. Woher die Builds stammen, wird durch `desktop.download_base` festgelegt, überschrieben von `SONAR_DESKTOP_BASE` und dann von `--base` — weise sie auf deinen eigenen Build, um einen zu testen. ### `sonar relay` Das Relay ist die Serverseite von sonar: ein kleiner HTTP-Dienst, der von uns für die gehostete App betrieben und als `ghcr.io/raskrebs/sonar-relay` veröffentlicht wird, damit du deinen eigenen betreiben kannst. Es hat nichts mit dem lokalen Daemon zu tun — `sonar serve` überwacht deine Ports, `sonar relay serve` beantwortet HTTP-Anfragen für eine Flotte — und es wird nur deshalb im selben Binary ausgeliefert, damit es genau ein Artefakt zum Bereitstellen gibt. Heute sammelt es anonyme Produkttelemetrie: einen Stapel benannter Ereignisse pro Installation, keine Pfade, keine Hostnamen, keine URLs — an der Tür abgewiesen, wenn ein Wert auch nur danach aussieht. Es ist derselbe Dienst, der später offengelegte Tunnel beendet und die Anmeldung verwaltet.```sh sonar relay serve --db ./relay.db --project-keys "$(openssl rand -hex 24)" ``` `docs/RELAY.md` enthält die Routen, die exakten Validierungsregeln, das Speicherschema und ein Ein-Befehl-Deployment hinter Caddy auf jeder Maschine mit Docker. ## Umstieg von den alten Befehlen Die Pre-Group-Befehle funktionieren weiterhin und geben eine einzelne Zeile auf stderr aus, die angibt, was sie ersetzt hat. Sie verschwinden ab der nächsten Minor-Version. `SONAR_NO_HINTS=1` unterdrückt die Hinweise, und `--json`-Ausgaben enthalten sie nie. | Alt | Neu | |---|---| | `sonar run --tag X -- cmd` | `sonar start --group X -- cmd` | | `sonar runs` | `sonar start --list` | | `sonar list --tag X` | `sonar list --group X` | | `sonar kill-all --filter docker` | `sonar kill --all --filter docker` | | `sonar down X` | `sonar kill -g X` | | `sonar profile create X` | `sonar init` | | `sonar profile show X` | `sonar groups X` | | `sonar up X` (prüfte ein Profil) | `sonar up X` *startet* jetzt die Gruppe | | `sonar tray` (Swift-Menüleisten-App) | `sonar tray` startet die Desktop-App | Profile waren ein maschinenspezifischer Schnappschuss von Ports; `.sonar.yaml` wird mit dem Projekt committet. Konvertiere eines und lies es, bevor du es behältst — es wird nichts für dich geschrieben:```sh sonar profile list # check ``` [No input content provided to translate.]```sh sonar profile export my-app > .sonar.yaml ``` Ein Profil hat nie aufgezeichnet, wie ein Dienst startet, daher enthält der Vorschlag Ports, Namen und Health-Pfade, und Sie füllen `cmd` aus. ## Fehlerbehebung **Etwas stimmt mit dem Daemon nicht.** `sonar daemon log -f`, während Sie das Problem reproduzieren, und `sonar daemon status` für PID, Laufzeit und Scan-Anzahl. Stoppen Sie ihn mit `sonar daemon stop`; jeder Lese-Befehl funktioniert auch ohne ihn weiter. **„daemon unavailable, using direct scan".** Nichts lauscht auf dem Socket. Das ist normal — Lesevorgänge starten keinen Daemon. Führen Sie `sonar serve -d` aus, wenn Sie einen möchten. **Ein Socket, der von einem Absturz übrig geblieben ist.** `sonar daemon path` zeigt ihn an; das Starten eines Daemons entfernt einen veralteten von selbst. Wenn sich ein zweiter Daemon weigert zu starten, während der erste weg ist, räumt `sonar daemon restart` die Sperre auf. **Ports fehlen in der Liste.** Prozesse, die einem anderen Benutzer gehören, sind ohne Berechtigungen unsichtbar; sonar weist unter der Tabelle darauf hin. Führen Sie erneut `sudo sonar list` aus, um sie zu sehen. Unter Linux muss `ss` installiert sein (`iproute2`); unter Windows wird `netstat` verwendet. **Ein Kill hat nichts bewirkt.** Docker-Container werden über den Docker-Daemon gestoppt: Prüfen Sie `docker ps`. Ein Prozess, der SIGTERM ignoriert, benötigt `-f`, und einer, der von etwas anderem überwacht wird (systemd, Compose `restart: always`), kommt absichtlich zurück — stoppen Sie den Supervisor. **Nichts funktioniert und Sie sind sich nicht sicher, warum.** `sonar doctor` prüft die Binärdatei, die Konfiguration, den Daemon, die Datenbank und jede Integration in einem Durchgang und gibt den Befehl aus, der jeden gefundenen Punkt behebt. **Einen Fehler melden.** Fügen Sie diese hinzu, plus die letzten Zeilen von `sonar daemon log`:```sh sonar version sonar daemon status sonar doctor --json # check ``` ## Unterstützte Plattformen - macOS (verwendet `lsof`) - Linux (verwendet `ss`) - Windows (verwendet `netstat`) Für die Gruppierung wird das Arbeitsverzeichnis jedes Prozesses benötigt, und jede Plattform hat dafür eines: `/proc` unter Linux, `lsof` unter macOS und unter Windows ein Auslesen des eigenen PEB des Prozesses. Daher funktionieren Git-Root-Gruppen, `project_root` und auf cwd basierende Namen überall gleich, und `sonar init` kann eine `.sonar.yaml` aus dem vorschlagen, was auf einer der drei Plattformen lauscht. Die Desktop-App ist vorerst eingeschränkter: `sonar install desktop` installiert sie auf macOS (Apple Silicon und Intel) und Linux (x86_64 und aarch64). Unter Windows meldet der Befehl, dass die App noch nicht verfügbar ist, und beendet sich mit Exit-Code 1. Die eine Lücke ist eine 32-Bit-`sonar.exe` unter 64-Bit-Windows: Sie kann den Speicher eines 64-Bit-Prozesses nicht lesen, daher kommen diese Ports ohne Arbeitsverzeichnis zurück und fallen aus ihrer Git-Root-Gruppe heraus. Verwenden Sie den 64-Bit-Build – er liest 64-Bit- und 32-Bit-Prozesse gleichermaßen. Anderswo wird ein Port, dessen Prozess den Zugriff verweigert (ein Dienst, der als anderer Benutzer läuft, ein geschützter Systemprozess), einfach ohne Arbeitsverzeichnis belassen; der Rest des Scans bleibt davon unberührt. ## Mitwirkende Danke an alle, die zu sonar beigetragen haben! <a href="https://github.com/RasKrebs/sonar/graphs/contributors"> <img src="https://stg.contrib.rocks/image?repo=RasKrebs/sonar" /> </a>

Option	Beschreibung
`-h`, `--help`	Zeigt die Hilfemeldung an und beendet das Programm
`-v`, `--verbose`	Aktiviert die ausführliche Ausgabe
`-o`, `--output`	Gibt die Ausgabedatei für die Ergebnisse an
`-t`, `--timeout`	Legt das Zeitlimit für die Anfragen fest (Standard: 30 Sekunden)
`-p`, `--proxy`	Verwendet einen Proxy für die Anfragen (Format: `http://host:port`)
`-c`, `--config`	Gibt die Konfigurationsdatei an (Standard: `config.yaml`)

sonar

Beliebteste

Installation

Docker

Homebrew

GitHub Actions

Usage

Verwenden von Go```sh

Sixty seconds

Installation aus dem Quellcode

Verifizierung der Installation

Verwendung

Grundlegende Syntax

Verfügbare Optionen

Beispiele

Einfacher Scan

Scan mit ausführlicher Ausgabe

Speichern der Ergebnisse in einer Datei

Verwendung eines Proxys

Konfiguration

Beispielkonfiguration

Module

1. Port-Scanner

2. Schwachstellen-Scanner

3. Verzeichnis-Brute-Forcer

4. Subdomain-Enumerator

API-Referenz

Beispiel für die Verwendung der API

Fehlerbehebung

Häufige Probleme

Problem: `Befehl nicht gefunden`

Problem: `Berechtigung verweigert`

Problem: `Modul nicht gefunden`

Lizenz

Mitwirken

Danksagungen

Kontakt