Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
sonar — Outil CLI pour inspecter et gérer les services écoutant sur les ports localhost. | Kitploit
Outils/GitHubGitHub/raskrebs/sonar
Utilitaires GénérauxCartographie RéseauScan de PortsScripting et AutomatisationCollecte d'InformationsDevSecOps
GitHubraskrebs/sonar

sonar

Outil CLI pour inspecter et gérer les services écoutant sur les ports localhost.

Voir le dépôt
1.1k3367il y a 12 joursVérifié par Kitploit
Partager
<div align="center">

```
██████    ███    ██████    ██    ██████
██           ██      ██  ██  ██      ██
██      ██   ██  ██  ██  ██  ██      ██
  ██  ██   ██  ██  ██  ██  ██  ████
    ██  ██       ██  ██  ██  ██  ██  ██
██████    ███    ██  ██  ██  ██  ██  ██
```
Sachez ce qui tourne sur votre machine.

</div>

Sonar affiche tout ce qui écoute sur localhost et le met en ordre : chaque port
appartient à un **groupe** — normalement le dépôt depuis lequel il a été démarré — et
à l'intérieur de ce groupe à un **service** nommé. Démarrez vos serveurs de développement avec
`sonar start` et tout le projet devient une seule chose que vous pouvez lister sous forme d'arbre,
attendre, suivre et arrêter avec une seule commande. Les conteneurs Docker, les projets
Compose et les processus que vous avez démarrés à la main sont également détectés, sans aucune
configuration.

```
$ 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
```

## Installation

### Homebrew (macOS / Linux)

```sh
brew install raskrebs/sonar/sonar
```

Homebrew 6 refuse les formules des taps tiers tant que vous n'avez pas approuvé le tap une fois
(`Error: Refusing to load formula raskrebs/sonar/sonar from untrusted tap`) :

```sh
brew trust raskrebs/sonar
```

### Script d'installation

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

Télécharge le dernier binaire dans `~/.local/bin` et l'ajoute à votre PATH si nécessaire. Redémarrez votre terminal ou exécutez `source ~/.zshrc`.

Sur Windows (PowerShell) :

```powershell
irm https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.ps1 | iex
```

Emplacement d'installation personnalisé :

```sh
curl -sfL https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.sh | SONAR_INSTALL_DIR=/usr/local/bin bash
```

Installer une version spécifique :

```sh
curl -sfL https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.sh | SONAR_VERSION=vX.Y.Z bash
```

```powershell
$env:SONAR_VERSION="vX.Y.Z"; irm https://raw.githubusercontent.com/raskrebs/sonar/main/scripts/install.ps1 | iex
```

### Utilisation de Go

```sh
go install github.com/raskrebs/sonar@latest
```

Complétions du shell (complétion par tabulation des numéros de port) :

```sh
sonar completion zsh > "${fpath[1]}/_sonar"   # zsh
sonar completion bash > /etc/bash_completion.d/sonar  # bash
sonar completion fish | source                 # fish
```

## Soixante secondes

Décrivez comment votre projet s'exécute dans un `sonar.yaml` à la racine du dépôt, à
la place d'un `dev.sh` :

```yaml
name: my-app
services:
  - name: db
    cmd: docker compose up db
    port: 5432
  - name: api
    cmd: uv run uvicorn app:app --port ${port}
    port: auto
    depends_on: [db]
  - name: frontend
    cmd: npm run dev -- --port ${port} --strictPort
    port: auto
    depends_on: [api]
    env:
      VITE_API_URL: ${api.url}
```

Puis démarrez-le :

```sh
sonar start
```

```
  ✓ db        http://localhost:5432   pid 41022  ~/.config/sonar/logs/my-app/db.log
  ✓ api       http://localhost:21408  pid 41040  ~/.config/sonar/logs/my-app/api.log
  ✓ frontend  http://localhost:21409  pid 41077  ~/.config/sonar/logs/my-app/frontend.log

3 started
following the logs; Ctrl+C stops the 3 services started here
api      | INFO:     Uvicorn running on http://127.0.0.1:21408
frontend | VITE v5.4  ready in 312 ms
```

Sonar choisit un port libre pour chaque service `port: auto` et indique à chaque service
où se trouvent les autres, de sorte qu'un second worktree s'exécute à côté du premier sans
qu'un seul port n'entre en conflit. `sonar start -d` fait la même chose en arrière-plan, et
`sonar down` l'arrête et libère les ports. Dans un autre terminal :

```sh
sonar list --tree
```

```
my-app  (3 ports, running)                        ~/code/my-app
├─ 5432   db          postgres:17                 http://localhost:5432
├─ 21408  api         uvicorn app:app             http://localhost:21408
└─ 21409  frontend    vite (v5.4)                 http://localhost:21409
```

Pas de `sonar.yaml` ? `sonar start -- npm run dev` exécute une commande en tant que
service nommé, et `sonar list` et `sonar kill` fonctionnent sur tout ce qui écoute.

Les exemples ci-dessous marqués `# check` sont exécutés sur une version fraîche par
`scripts/readme-check.sh` à chaque exécution de la CI.

## Commandes

### `sonar list`

```sh
sonar list
sonar list --tree
sonar list --group my-app
sonar list --json
# check
```

```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
```

Les colonnes par défaut sont `port`, `process`, `group`, `container`, `image`,
`containerport`, `url`, où `process` affiche le nom que vous avez donné au port
(`sonar rename`), puis le nom du service, puis ce qui a été détecté.

Colonnes disponibles : `port`, `process`, `pid`, `type`, `url`, `group`, `cpu`,
`mem`, `threads`, `uptime`, `state`, `connections`, `health`, `latency`,
`container`, `image`, `containerport`, `compose`, `project`, `user`, `bind`,
`ip`.

Les applications de bureau et les services système qui se trouvent écouter — Figma, Discord,
Spotify, ControlCenter, les bundles `.app` de macOS, les démons de `/System/Library/` — sont
masqués sauf si vous passez `-a`.

### `sonar start`

Démarrer un projet à partir de son `sonar.yaml` :

```sh
sonar start                    # every service in the nearest sonar.yaml
sonar start api frontend       # only these (they still wait for their dependencies)
sonar start ../other-project   # the sonar.yaml in or above another directory
sonar start -d                 # in the background, like `sonar up`
```

Au premier plan, sonar démarre les services via le démon, suit leurs
journaux avec le nom du service devant chaque ligne, et lorsque vous appuyez sur Ctrl+C
arrête les services qu'il a démarrés. Un service qui était déjà en cours d'exécution est laissé
tranquille, et sonar revient de lui-même une fois que chaque service qu'il a démarré s'est terminé.

Les arguments avant `--` désignent un répertoire ou des services ; tout ce qui suit `--` est une
commande. Ou exécutez une commande en tant que service nommé dans un groupe :

```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
```

Rien ne doit être passé :

- **Group** — `--group`, sinon le `name` dans le `sonar.yaml` le plus proche, sinon le nom du répertoire de la racine git (un worktree devient `repo@worktree`), sinon le nom du répertoire courant.
- **Name** — `--name`, sinon le service `sonar.yaml` dont le `cmd` correspond, sinon déduit de la commande (`npm run dev` → `dev`, `uv run api` → `api`, `python -m uvicorn` → `uvicorn`, `./dev.sh` → `dev.sh`).
- **Port** — `--port` est un indice, pas une liaison : l'exécution apparaît comme `starting` jusqu'à ce que le port soit réellement en écoute, et le daemon l'utilise pour faire correspondre le processus au port.

L'enfant hérite de stdin, stdout, stderr, cwd et de l'environnement, plus `SONAR_GROUP`, `SONAR_NAME` et `SONAR_RUN_ID`. Il obtient son propre groupe de processus, donc `sonar kill` abat tout l'arbre — un serveur de développement avec ses watchers et ses workers. Ctrl+C est transmis, et sonar se termine avec le code de sortie de l'enfant.

`--detach` retourne immédiatement et écrit la sortie dans `~/.config/sonar/logs/<group>/<name>.log`. `--list` montre ce que sonar a démarré, et en dessous ce qui s'est terminé depuis — avec le code de sortie, et s'il a planté ou a été arrêté (`--json` pour la forme lisible par machine) :

```sh
sonar start --list
sonar start --detach --name demo --port 8123 -- sleep 5
sonar start --list --json
# check
```

### `sonar.yaml`

Un projet se nomme lui-même et nomme ses services dans un `sonar.yaml` à la racine
du dépôt. Il est facultatif — sonar regroupe par racine git sans lui — et il est
destiné à être commité :

```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` — le nom du groupe. Pas de barres obliques, pas d'espaces.
- `cmd`, `cwd`, `port` — comment `sonar start` démarre le service. `cwd` est relatif au
  fichier et ne peut pas sortir de son répertoire.
- `health` — un chemin HTTP que le démon interroge tant que le service est actif, afin qu'un
  service puisse être *en cours d'exécution* mais pas encore *sain*. Il rapporte `ok`, `fail` ou
  `unknown`, avec la raison d'un échec.
- `description`, `icon`, `color` — métadonnées libres pour l'application de bureau ; sonar
  ne les déduit jamais.
- `depends_on` — ordre de démarrage. Nommer un service qui n'est pas dans le fichier, ou un
  cycle, est une erreur ; un fichier invalide est signalé une fois et n'arrête jamais une analyse.
- `env` — variables définies pour le service lorsque sonar le démarre.

#### `port: auto` et références

Un service peut laisser son port à sonar, et trouver les autres via son
environnement au lieu d'un `localhost:8080` codé en dur :

```yaml
services:
  - name: api
    cmd: uv run uvicorn app:app --port ${port}
    port: auto
  - name: frontend
    cmd: npm run dev -- --port ${port} --strictPort
    port: auto
    depends_on: [api]
    env:
      VITE_API_URL: ${api.url}
```

`sonar start` réserve un port libre pour chaque service `port: auto` qu'il démarre : le même à chaque fois dans le même checkout, et un différent dans chaque autre checkout, afin qu'un worktree n'entre jamais en collision avec le principal. Le service le reçoit sous les noms `PORT`, `SONAR_PORT` et `${port}`, et il doit l'utiliser — lire `PORT`, ou passer `${port}` sur sa ligne de commande. Un service déjà en cours d'exécution conserve son port, donc un service démarré plus tard le trouve encore. La réservation derrière un port attribué dure un jour à partir du dernier démarrage ; `claims.ttl` modifie cela (voir Le daemon).

`${port}` et `${url}` (`http://localhost:<port>`) appartiennent au service lui-même ; `${<service>.port}` et `${<service>.url}` appartiennent à un autre. Ils fonctionnent dans `cmd` et dans `env`. Une référence à un service qui n'est pas dans le fichier, ou à un service sans port, est une erreur au chargement du fichier. Tout le reste entre `${` et `}`, comme `${HOME}`, est laissé exactement tel qu'écrit.

`sonar.yml` est lu si c'est ainsi que vous l'écrivez ; `sonar init` écrit toujours `sonar.yaml`. Le fichier était auparavant le dotfile `.sonar.yaml`, et ce nom fonctionne toujours : sonar cherche `sonar.yaml`, `sonar.yml`, `.sonar.yaml` et `.sonar.yml`, dans cet ordre, et lit le premier qu'il trouve. Les modifications sont réécrites dans le fichier que sonar a lu, donc rien n'est renommé à votre insu. `sonar doctor` signale un fichier sous l'ancien nom, et `sonar doctor --fix` le renomme (avec `git mv` lorsque le fichier est suivi). Le daemon surveille les projets qu'il connaît et prend en compte les modifications du fichier sans redémarrage. Chaque modification effectuée par sonar — depuis l'application de bureau, depuis `sonar groups add`, `rename` et `remove`, depuis un agent — passe par le daemon, qui réécrit le fichier à partir de son propre arbre syntaxique, de sorte que les commentaires, l'ordre des clés et la mise en page survivent à une modification qui ajoute, renomme ou supprime un service, tout comme ils survivent à un changement de métadonnées. La seule exception : les espaces supplémentaires alignant un commentaire en fin de ligne (`cmd: x     # note`) se réduisent à un seul, car la bibliothèque YAML conserve le commentaire mais pas sa colonne.

#### `sonar env`

Ce à quoi le fichier se résout est lisible sans rien démarrer :

```sh
sonar env                      # every service: port, url and its expanded env
sonar env frontend             # one service, as export lines
sonar env --json               # for tools
```

```
SERVICE   PORT   URL                     ENV
db        5432   http://localhost:5432
api       21408  http://localhost:21408  DB_URL=postgres://localhost:5432/app
frontend  21409  http://localhost:21409  VITE_API_URL=http://localhost:21408
```

Un service `port: auto` qui n'est pas en cours d'exécution reçoit ici sa revendication, la même revendication que celle émise par `sonar start`, donc ce que `sonar env` affiche correspond à ce qu'un démarrage ultérieur liera ; un service déjà en cours d'exécution conserve le port sur lequel il se trouve. Nommé, un service est présenté sous forme de lignes `export`, afin qu'un shell puisse voir ce que le service ferait :

```sh
eval "$(sonar env frontend)" && npm test
```

Derrière lui se trouve `groups.env` sur le daemon, pour un éditeur ou un agent qui
configure un worktree avant que ses services n'existent.

### `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
```

`sonar up` est `sonar start -d`, qui peut aussi nommer un groupe depuis n'importe où et
le démarrer sur un autre hôte. Il démarre chaque service déclaré par le `sonar.yaml`
du groupe, dans l'ordre `depends_on` :
un service attend les ports que ses dépendances déclarent avant d'être démarré, et
celui qui écoute déjà est ignoré. Chacun s'exécute en arrière-plan dans son propre groupe
de processus, avec sa sortie dans `~/.config/sonar/logs/<group>/<service>.log`, et avec
l'environnement du shell dans lequel vous avez exécuté `sonar up`, plus `PORT` pour un service
avec un port.

```
  ✓ db        http://localhost:5432  pid 41022  ~/.config/sonar/logs/my-app/db.log
  - api       already running
  ✓ frontend  http://localhost:5173  pid 41108  ~/.config/sonar/logs/my-app/frontend.log

2 started, 1 already running
```

Un service qui ne parvient pas à démarrer est signalé sur sa propre ligne et fait que la commande se termine avec un code non nul, quoi qu'il arrive d'autre. Arrêtez-les tous à nouveau avec `sonar down`.
`sonar up` a besoin du démon et le démarre s'il n'est pas déjà en cours d'exécution.

### `sonar down`

```sh
sonar down                     # the project in the nearest sonar.yaml
sonar down my-app              # a group by name
sonar down --only api,worker   # only these services
```

Arrête tous les services du projet — chaque port qu'il écoute, et chaque
service que sonar a démarré pour lui et qui ne détient aucun port, comme un worker — et libère
les ports que sonar a réservés pour ses services `port: auto`. `--only` restreint tout
cela aux services nommés, de la même manière que `sonar up --only` n'en démarre que quelques-uns ; un nom
que le fichier ne déclare pas est une erreur. `sonar kill -g my-app` arrête les ports
et ne libère rien.

### `sonar groups` et `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` liste chaque groupe que sonar peut voir et l'origine de chaque nom :
`manual` (vous l'avez épinglé avec `sonar assign`), `start` (une exécution `sonar start`),
`file` (un `sonar.yaml`) ou `auto` (la racine git ou le projet Compose).
`sonar groups <name>` affiche les ports et services d'un groupe, ainsi que les services
déclarés mais non démarrés.

`sonar init` écrit un `sonar.yaml` à la racine git à partir de ce qu'il peut affirmer : les
ports en écoute dans le projet à cet instant (applications de bureau et ports inférieurs à 1024
exclus), plus ce qu'un fichier compose ou un `package.json` déclare explicitement — un
service par service compose, avec son port publié et son `depends_on`, et
le script `dev` exécuté par le gestionnaire de paquets auquel votre lockfile vous engage.
Là où les deux divergent, le port en écoute l'emporte : c'est une preuve, pas une
déclaration. Le fichier qu'il écrit indique ce qu'il n'a pas pu déterminer.

Rien d'autre n'est détecté. Une cible Makefile, une ligne de Procfile, un point d'entrée
enfoui dans un framework — ce sont des suppositions sur votre dépôt, et un tableau
de celles-ci ne serait jamais terminé. Cette partie revient à un agent :

```sh
sonar init --agent              # whichever agent is installed
sonar init --agent codex        # name one
sonar init --agent claude -- --allow-dangerously-skip-permissions
```

`--agent` ouvre l'agent de codage que vous avez déjà, dans ce terminal, avec le
prompt déjà envoyé : ce que sonar sait, le brouillon qu'il aurait écrit, le
format, et la règle selon laquelle il écrit le fichier et ne démarre rien. Vous le regardez
lire le dépôt et approuver ses modifications exactement comme vous le faites toujours — c'est votre
agent, sous vos permissions — et tout ce qui suit `--` lui est transmis. sonar
connaît `claude`, `codex`, `cursor-agent` et `opencode` ; si plusieurs sont installés,
nommez-en un. Lorsque l'agent se termine, sonar charge le fichier et affiche les services qu'il
déclare, ou pourquoi il ne se charge pas. Sans terminal — un pipe, la CI — `--agent`
affiche le prompt au lieu de démarrer quoi que ce soit.

Il refuse d'écraser sans `--force`, et `--dry-run` affiche le fichier
au lieu de l'écrire. `--merge` ajoute à un fichier déjà présent
au lieu de refuser, et `--service name:port[:health]` — répétable — écrit
les services que vous nommez au lieu de ceux qu'il a trouvés, en conservant la commande qu'il
a devinée pour un port que vous avez gardé. `--force` et `--merge` sont mutuellement exclusifs.

`sonar groups add <group> <name> --port N` ajoute un service au
`sonar.yaml` de ce groupe, avec `--cmd`, `--cwd`, `--health`, `--description`, `--icon`,
`--color` et un `--depends-on` répétable pour le reste. `sonar groups
rename <group> <old> <new>` renomme un service partout dans le fichier,
références `depends_on` incluses, et `sonar groups remove <group> <name>` en supprime un et
le retire de chaque `depends_on` qui le nommait. Les trois refusent une modification qui
rendrait le fichier invalide — un nom en double, un port qu'un autre service revendique déjà,
un service qui n'est pas là — et aucun d'eux n'écrit un octet tant que
toute la modification n'est pas reconnue comme valide.

Le daemon fait l'écriture, c'est pourquoi le fichier revient avec ses commentaires
et son ordre de clés intacts, que la modification vienne de la CLI, de l'application de bureau ou d'un
agent. `sonar groups add`, `rename` et `remove` nécessitent le daemon et le démarrent s'il
n'est pas déjà en cours d'exécution ; les trois noms sont des sous-commandes, donc un groupe réellement
appelé `add` se lit avec `sonar groups --json`.

### `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` accepte n'importe quel sélecteur et ne modifie rien : il affiche les actions que le kill effectuerait, en commençant par les enfants, et laisse tout en cours d'exécution. De bout en bout, contre un listener qui vous appartient :

```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
```

Un argument positionnel est interprété comme un port, et comme un pid uniquement lorsqu'aucun processus n'écoute sur ce numéro. `-g` correspond au groupe résolu, à une étiquette ou un id d'exécution hérité, et au projet Compose, sans distinction de casse.

Un processus qui ignore SIGTERM reçoit SIGKILL une fois que le port est toujours en écoute après `--grace` (5s) ; `--no-escalate` désactive ce comportement. Les enfants sont signalés avant les parents, de sorte qu'une arborescence est arrêtée dans l'ordre. Les conteneurs Docker sont arrêtés avec `docker stop` et ne reçoivent jamais de signal. Un listener démarré par `sonar start` est toujours arrêté avec son groupe de processus.

`--json` affiche une ligne par processus :
`{port, bind_address, pid, name, method, ok, error}`, où `method` vaut
`sigterm`, `sigkill`, `docker_stop`, `map_stop` ou `none`. Un balayage vide se termine avec le code 0 ; un groupe inconnu se termine avec le code 1.

### `sonar map`

```sh
sonar map 6873 3002        # also serve the service on 6873 from port 3002
```

Exécute un proxy TCP au premier plan jusqu'à ce que vous l'arrêtiez. `sonar kill` signale une
correspondance qu'il a arrêtée comme `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
```

```sh
sonar history --since 1h
sonar history --json
# check
```

Les noms et les épinglages sont stockés dans la base de données de sonar, indexés par l'élément le plus spécifique connu à propos du port : le run (`run:<group>/<name>`), le conteneur (`docker:<project>/<service>`), le répertoire de travail, et le numéro de port en dernier. Un serveur de développement renommé conserve son nom à travers les redémarrages ; un nom épinglé au seul port 3000 s'applique à tout ce qui répond à cette adresse. Ces trois commandes nécessitent le daemon et le démarrent s'il n'est pas en cours d'exécution.

### Lire un port

```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
```

```sh
sonar next 3000
sonar next 3000-3100 -n 3 --json
sonar graph --json
sonar info --help
# check
```

`sonar wait` se termine avec `0` (prêt), `1` (délai dépassé) ou `2` (interrompu), ce qui en fait l'élément à placer entre le démarrage de quelque chose et son test :

```sh
docker compose up -d
sonar wait 5432 3000 --timeout 60s && npm run migrate && npm run test
```

**Démon ou analyse directe.** Chaque commande de lecture demande au démon s'il en existe un en cours d'exécution, car il possède déjà la réponse et n'a pas besoin de forker `lsof`. Si aucun n'est en cours d'exécution, ils analysent directement et affichent une note sur stderr pour le signaler. `sonar kill` suit la même règle : un démon joignable effectue le kill, il réanalyse donc immédiatement et sa réponse suivante — ainsi que l'historique des ports — sait déjà que le port a disparu. Ni les lectures ni les kills ne démarrent un démon à votre insu. `--no-daemon` force l'analyse directe silencieusement et fonctionne sur n'importe quelle commande :

```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
```

```sh
sonar host
# check
```

Le démon mesure sa propre machine selon la cadence de scan et la publie comme la
ligne `localhost` de la collection `hosts` du snapshot : os et noyau, uptime, pourcentage
cpu, charge moyenne, mémoire et le disque contenant `/`. Le pourcentage CPU est le travail
effectué entre deux scans, il est donc null tant que le démon n'a pas scanné deux fois ; une
valeur qu'une plateforme ne peut pas produire — la charge moyenne sous Windows, qui n'en a pas —
est null plutôt que zéro. Chaque hôte enregistré avec `sonar remote add` rejoint
la même table avec sa propre charge. La commande nécessite un démon en cours d'exécution : c'est le
démon qui détient l'échantillon précédent par rapport auquel un pourcentage est mesuré.

Les GPU sont listés sous leur hôte avec l'utilisation et la mémoire : depuis `ioreg` sur
macOS (la mémoire Apple silicon est unifiée, donc seule ce que le GPU détient est affiché),
et depuis `nvidia-smi` ou les compteurs sysfs d'amdgpu sur Linux. Le démon les lit
toutes les cinq secondes en arrière-plan, jamais sur le chemin d'une commande ; `gpus` est null
là où il n'y a pas de source (Windows, Linux Intel uniquement) et `[]` sur une machine sans
GPU.

### `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
```

Installe sonar sur un hôte auquel vous pouvez déjà vous connecter en ssh et y démarre son démon. L'archive de version est téléchargée et son checksum vérifié **sur l'hôte distant** — rien n'est copié depuis cette machine — et le binaire atterrit dans `~/.local/bin/sonar`, donc rien de tout cela n'a besoin de root. Le démon s'exécute comme une unité utilisateur systemd là où l'hôte en dispose (`~/.config/systemd/user/sonar.service`), et en mode détaché là où il n'en dispose pas ; `loginctl enable-linger` est affiché comme conseil lorsque la session utilisateur se terminerait à la déconnexion et emporterait le démon avec elle.

La version installée est la version du sonar depuis laquelle vous l'avez lancé, ainsi les deux extrémités parlent le même protocole. Le relancer effectue une mise à niveau sur place et redémarre le démon, ce qui fait qu'une installation et une mise à jour sont la même commande.

La cible est transmise à `ssh` telle quelle : un alias `Host` issu de `~/.ssh/config` fonctionne, tout comme les `ProxyJump`, `IdentityFile` et `Port` qu'il définit. `--identity` et `--ssh-arg` sont là pour les options qu'une configuration ne couvre pas.

### `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
```

Un hôte enregistré exécute le même démon, et le démon sur cette machine
maintient une connexion SSH vers lui — `ssh <target> sonar daemon stdio`, en
cherchant dans `~/.local/bin` avant le `PATH` distant — et multiplexe
ce qu'il rapporte dans l'état que chaque client lit déjà. Rien de nouveau n'écoute
nulle part : le socket du démon distant reste privé à l'utilisateur SSH, et les clients
ne parlent jamais SSH eux-mêmes.

Chaque ligne porte désormais l'hôte dont elle provient. Les lignes locales indiquent `localhost` et
conservent les clés qu'elles ont toujours eues, donc rien de ce qui lit sonar aujourd'hui ne change ;
les lignes distantes indiquent le nom enregistré et sont indexées `<host>/<port>:<bind>`, ce qui
permet au port 3000 sur deux machines d'être deux lignes. Un abonné ne voit que
localhost sauf s'il en demande plus (`state.subscribe {"hosts": ["*"]}`).

La cible est transmise à `ssh` telle quelle, donc les alias de `~/.ssh/config`, `ProxyJump` et
les identités s'appliquent tous ; `--ssh-arg`, `--identity` et `--port` couvrent ce qu'une configuration
ne fait pas, et `--remote-bin` nomme un sonar qui se trouve ailleurs. La commande
par défaut s'exécute via `sh`, donc un hôte Windows, dont le sonar provient de
l'installateur PowerShell, nécessite `--remote-bin sonar`. sonar ne stocke ni mot de passe ni clé. Un hôte qui disparaît conserve sa
ligne et son statut pendant que le démon réessaie, avec un délai croissant d'une seconde à
trente tant qu'il reste enregistré.

`--host` accepte aussi toujours un simple `user@host` que sonar ne connaît pas : il
se rabat sur le scan sans agent `ssh` + `ss`/`lsof` et affiche une indication vers
`sonar remote install`.

#### Agir sur une autre machine

Chaque écriture prend aussi `--host`, et y fait exactement ce qu'elle fait ici :

```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
```

Le démon local transmet l'appel via le bridge de cet hôte et renvoie ce que
le démon distant a répondu, dans la même enveloppe qu'un appel local renvoie — chaque
ligne de résultat indique sur quel hôte elle s'est produite, et l'`affected` d'un kill porte les
clés `<host>/<port>:<bind>` que le flux utilise pour ces lignes. Une commande de streaming
streame : `sonar up --host` affiche chaque service au fur et à mesure que le côté distant le démarre, et
Ctrl-C arrête le travail distant plutôt que seulement ce terminal.

Comme la clé d'une ligne nomme déjà son hôte, un client peut en renvoyer une directement
comme sélecteur — `{"key": "hetzner/3000:127.0.0.1"}` constitue à lui seul un sélecteur,
hôte inclus. Un appel agit sur une seule machine ; en nommer deux est une erreur plutôt qu'un
demi-kill sur chacune.

Deux choses restent locales. `sonar attach` place *ce* terminal devant un
processus, donc il refuse `--host` et indique de se connecter en ssh et d'attacher là-bas. Et une
session d'agent est un état que ce démon détient, donc `sonar kill --session` n'a pas de

---

[Read more](https://github.com/raskrebs/sonar)
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    911
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    548
  • 3

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    366
  • 4

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    362
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    311
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    287

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →