Solo es necesario PowerShell para empezar en el mundo de la seguridad informática.
No hace falta comenzar instalando Kali Linux, montar media docena de máquinas virtuales o llenar el escritorio de programas que todavía no sabemos utilizar. Si tienes Windows, ya tienes una consola capaz de convertirse en el centro de un laboratorio serio de aprendizaje: PowerShell.
La idea de esta guía es sencilla. Vamos a construir una pequeña estación de trabajo para OSINT, hacking ético, pentesting y auditoría informática utilizando PowerShell como punto de control. No se trata de convertir Windows en Kali a la fuerza. Se trata de aprender qué hace cada herramienta, por qué la utilizamos y cómo encadenarla con las demás.
Hay una regla que no admite excepciones: todo lo que aparece aquí debe utilizarse exclusivamente sobre equipos propios, laboratorios, CTF o sistemas para los que exista autorización expresa. En seguridad ofensiva, el permiso no es un detalle administrativo; es lo que separa una auditoría de una intrusión.
PowerShell no es solo una consola de administración
Durante mucho tiempo PowerShell se ha asociado casi exclusivamente a administradores de Windows. Pero su verdadero valor aparece cuando empezamos a combinar comandos, procesos, archivos, red, JSON, APIs y aplicaciones externas desde un mismo entorno.
Para alguien que está empezando en seguridad informática tiene otra ventaja: obliga a entender lo que ocurre. Cuando ejecutamos un escaneo, capturamos tráfico o analizamos metadatos desde la consola, vemos de forma mucho más clara las entradas, las salidas y los errores. Y eso es exactamente lo que necesitamos para aprender.
No quiero una colección de iconos. Quiero un banco de trabajo.
1. Crear el laboratorio
Empezaría creando una estructura sencilla. Abre PowerShell como administrador y ejecuta:
New-Item -ItemType Directory -Force C:\PentestLab New-Item -ItemType Directory -Force C:\PentestLab\Tools New-Item -ItemType Directory -Force C:\PentestLab\Reports New-Item -ItemType Directory -Force C:\PentestLab\Captures New-Item -ItemType Directory -Force C:\PentestLab\OSINT New-Item -ItemType Directory -Force C:\PentestLab\Wordlists
Con esto tendremos una zona para herramientas, informes, capturas de tráfico, material OSINT y diccionarios de pruebas.
2. Git: la puerta de entrada a muchos proyectos de seguridad
Git no es una herramienta ofensiva, pero termina apareciendo por todas partes. Repositorios de código, scripts, laboratorios, plantillas y proyectos de investigación se distribuyen con Git.
Instalación:
winget install --id Git.Git -e
Comprobación:
git --version
Ejemplo: clonar un repositorio público para estudiarlo.
git clone https://github.com/sherlock-project/sherlock.git C:\PentestLab\Tools\sherlock-src
3. Python: imprescindible para herramientas y pequeños scripts
Python sigue siendo uno de los lenguajes más presentes en automatización, análisis y seguridad. Tenerlo instalado nos permite utilizar herramientas escritas en Python y crear nuestros propios scripts.
Instalación:
winget install --id Python.Python.3.12 -e
Comprobación:
python --version
Para aplicaciones Python independientes resulta útil pipx:
python -m pip install --user pipx python -m pipx ensurepath
Ejemplo: levantar un pequeño servidor web local para el laboratorio:
Set-Location C:\PentestLab python -m http.server 8080
Desde otro equipo propio podremos acceder a ese servicio y utilizarlo como objetivo de pruebas básicas.
4. Go: muchas herramientas modernas viven aquí
ProjectDiscovery, FFUF, Gitleaks y otros proyectos modernos están escritos en Go. Instalarlo abre la puerta a un ecosistema enorme de herramientas CLI.
Instalación:
winget install --id GoLang.Go -e
Comprobación:
go version
Los binarios instalados con Go suelen quedar en:
C:\Users\TU_USUARIO\go\bin
Podemos añadir esa ruta permanentemente al PATH del usuario:
$GoBin = "$env:USERPROFILE\go\bin"
$UserPath = [Environment]::GetEnvironmentVariable("Path","User")
if ($UserPath -notlike "*$GoBin*") {
[Environment]::SetEnvironmentVariable("Path", "$UserPath;$GoBin", "User")
}
5. Nmap: conocer antes de atacar
Nmap es una de esas herramientas que deberían estudiarse despacio. No solo sirve para saber si un puerto está abierto. Ayuda a comprender servicios, protocolos, sistemas y superficie de exposición.
Instalación:
winget install --id Insecure.Nmap -e
La web oficial de Nmap mantiene además un instalador específico para Windows.
Ejemplo: imaginemos una máquina de laboratorio en 192.168.1.50.
nmap 192.168.1.50
Identificación de servicios:
nmap -sV 192.168.1.50
Todos los puertos TCP:
nmap -p- 192.168.1.50
Guardar el resultado para el informe:
nmap -sV 192.168.1.50 -oA C:\PentestLab\Reports\host01
La primera lección de pentesting aparece aquí: antes de pensar en vulnerabilidades necesitamos saber qué existe.
6. Ncat: hablar con servicios sin intermediarios
Ncat se instala junto a Nmap. Permite crear conexiones TCP/UDP y resulta excelente para entender qué ocurre realmente cuando un cliente habla con un servicio.
Ejemplo: listener dentro de nuestro laboratorio:
ncat -l 4444
Desde otro equipo propio:
ncat 192.168.1.50 4444
También podemos enviar una petición HTTP básica:
"GET / HTTP/1.0`r`n`r`n" | ncat 192.168.1.50 80
Es un ejercicio pequeño, pero ayuda a desmontar mentalmente la web: detrás del navegador continúan existiendo sockets, puertos y protocolos.
7. Nping: comprobar conectividad y filtrado
Nping forma parte del paquete Nmap y permite generar y analizar tráfico de prueba.
Ejemplo ICMP:
nping --icmp 192.168.1.50
Ejemplo TCP sobre 443:
nping --tcp -p 443 192.168.1.50
Es útil para aprender qué deja pasar un firewall y cómo responde una máquina ante distintos tipos de tráfico.
8. Wireshark y TShark: ver la conversación
Wireshark es imprescindible para aprender redes. En este laboratorio nos interesa especialmente TShark, su analizador de protocolos para línea de comandos.
Instalación:
winget install --id WiresharkFoundation.Wireshark -e
Durante la instalación conviene mantener TShark y Npcap. Después podemos listar interfaces:
tshark -D
Capturar tráfico desde la interfaz 1:
tshark -i 1
Capturar solo DNS:
tshark -i 1 -f "port 53"
Guardar una captura:
tshark -i 1 -w C:\PentestLab\Captures\laboratorio.pcapng
Y analizar después solo DNS:
tshark -r C:\PentestLab\Captures\laboratorio.pcapng -Y "dns"
Cuando empiezas a capturar tus propios paquetes, una red deja de ser algo abstracto. Puedes verla respirar.
9. Sherlock: OSINT sobre nombres de usuario
Sherlock busca la presencia pública de un nombre de usuario en numerosas plataformas. Es especialmente útil para estudiar reutilización de alias e identidad digital.
Instalación:
pipx install sherlock-project
Ejemplo con un alias de laboratorio:
sherlock usuario_prueba
Guardar resultados:
sherlock usuario_prueba --output C:\PentestLab\OSINT\sherlock.txt
La lección aquí no es “buscar gente”. Es entender que una misma identidad reutilizada durante años puede unir información que el usuario creía separada.
10. ExifTool: los archivos también filtran información
Una fotografía o un documento pueden conservar metadatos sobre fechas, programas, cámaras, autores y, en determinados casos, geolocalización.
Instalación con WinGet:
winget install -e --id OliverBetz.ExifTool
Ejemplo con una fotografía propia:
exiftool C:\PentestLab\OSINT\foto.jpg
Buscar campos GPS:
exiftool -GPS* C:\PentestLab\OSINT\foto.jpg
Analizar un PDF:
exiftool C:\PentestLab\OSINT\documento.pdf
En OSINT, muchas veces el dato interesante no está escrito en la página: viaja pegado al archivo.
11. Subfinder: descubrir subdominios
Subfinder realiza enumeración pasiva de subdominios. Es perfecto para comprender el concepto de superficie de ataque externa.
Instalación:
go install -v github.com/projectdiscovery/subfinder/v2/cmd/subfinder@latest
Ejemplo sobre un dominio que controlemos:
subfinder -d ejemplo.es
Guardar resultados:
subfinder -d ejemplo.es -o C:\PentestLab\OSINT\subdominios.txt
Una empresa puede proteger perfectamente su web principal y olvidar un servidor de pruebas, una VPN antigua o un panel secundario. El trabajo de reconocimiento consiste en mirar el conjunto.
12. DNSX: validar y estudiar DNS
DNSX complementa muy bien a Subfinder.
Instalación:
go install -v github.com/projectdiscovery/dnsx/cmd/dnsx@latest
Ejemplo:
"www.ejemplo.es" | dnsx
Consultar registros A:
"www.ejemplo.es" | dnsx -a
Consultar MX:
"ejemplo.es" | dnsx -mx
Y aquí empieza lo interesante:
subfinder -d ejemplo.es -silent | dnsx
Una herramienta descubre. Otra confirma.
13. HTTPX: identificar servicios web activos
HTTPX permite tomar una lista de hosts y comprobar cuáles responden por HTTP/HTTPS, además de mostrar información útil como códigos de estado o títulos.
Instalación:
go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest
Ejemplo local:
"http://192.168.1.50" | httpx -status-code -title -web-server
Encadenado con Subfinder:
subfinder -d ejemplo.es -silent | httpx -status-code -title
Esto ya empieza a parecer un flujo real de reconocimiento.
14. Naabu: descubrimiento rápido de puertos
Naabu está diseñado para descubrir puertos abiertos de forma rápida y se integra muy bien con otras herramientas.
Instalación:
go install -v github.com/projectdiscovery/naabu/v2/cmd/naabu@latest
Ejemplo en una máquina propia:
naabu -host 192.168.1.50 -top-ports 100
Mi forma de verlo es sencilla: Naabu puede localizar rápido y Nmap profundizar después. No tienen por qué competir.
15. Nuclei: comprobaciones de seguridad basadas en plantillas
Nuclei automatiza comprobaciones mediante plantillas. Es una herramienta potente, pero también una buena ocasión para recordar que un escáner no sustituye a un auditor.
Instalación:
go install -v github.com/projectdiscovery/nuclei/v3/cmd/nuclei@latest
Actualizar plantillas:
nuclei -update-templates
Ejemplo en un servidor web de laboratorio:
nuclei -u http://192.168.1.50 -severity info,low,medium
Guardar resultados:
nuclei -u http://192.168.1.50 -o C:\PentestLab\Reports\nuclei.txt
Un hallazgo automático necesita contexto y validación. Si no sabemos explicar qué ha detectado la herramienta, todavía no tenemos un informe: tenemos una salida de consola.
16. Katana: recorrer nuestra aplicación web
Katana es un crawler que ayuda a descubrir rutas y recursos de una aplicación.
Instalación:
go install github.com/projectdiscovery/katana/cmd/katana@latest
Ejemplo sobre una aplicación local:
katana -u http://127.0.0.1:8080 -d 2
Guardar las URLs:
katana -u http://127.0.0.1:8080 -d 2 -o C:\PentestLab\Reports\urls.txt
Antes de revisar una aplicación conviene saber qué rutas, endpoints y recursos forman parte de ella.
17. FFUF: fuzzing de contenido en un entorno controlado
FFUF permite probar palabras o rutas contra una aplicación. Es especialmente útil en laboratorios donde hemos creado deliberadamente recursos que después intentaremos descubrir.
Instalación:
go install github.com/ffuf/ffuf/v2@latest
Ejemplo:
ffuf -w C:\PentestLab\Wordlists\directories.txt -u http://127.0.0.1:8080/FUZZ
Con extensiones:
ffuf -w C:\PentestLab\Wordlists\directories.txt -u http://127.0.0.1:8080/FUZZ -e .html,.txt
En un laboratorio podemos crear /admin-pruebas, /backup.txt y otras rutas ficticias para entender cómo funcionan los diccionarios y los códigos HTTP.
18. Gitleaks: buscar secretos dentro del código
Las auditorías no terminan en la red. Tokens, contraseñas y claves API pueden acabar accidentalmente dentro de repositorios.
Instalación:
go install github.com/gitleaks/gitleaks/v8@latest
Ejemplo sobre un proyecto propio:
gitleaks dir C:\PentestLab\MiProyecto
Guardar un informe:
gitleaks dir C:\PentestLab\MiProyecto --report-path C:\PentestLab\Reports\gitleaks.json
La seguridad del software empieza mucho antes de que ese software llegue a un servidor.
19. Semgrep: análisis estático desde PowerShell
Semgrep ya dispone de soporte nativo para Windows y puede instalarse desde Python. Nos permite realizar análisis estático de código y buscar patrones potencialmente peligrosos.
Instalación:
python -m pip install semgrep
Ejemplo:
semgrep scan --config auto C:\PentestLab\MiProyecto
No es una sentencia de culpabilidad para el código. Es una forma de encontrar puntos que merecen revisión.
20. Bandit: revisar código Python
Bandit está orientado al análisis de determinados problemas de seguridad en proyectos Python.
Instalación:
python -m pip install bandit
Ejemplo:
bandit -r C:\PentestLab\MiProyecto
Informe JSON:
bandit -r C:\PentestLab\MiProyecto -f json -o C:\PentestLab\Reports\bandit.json
21. jq: cuando los resultados empiezan a crecer
Muchas herramientas de seguridad generan JSON. Poder filtrarlo rápidamente facilita muchísimo la automatización.
Instalación:
winget install --id jqlang.jq -e
Ejemplo:
Get-Content C:\PentestLab\Reports\resultado.json | jq .
Extraer un campo concreto:
Get-Content C:\PentestLab\Reports\resultado.json | jq '.[].host'
Cuando dejamos de coleccionar herramientas y empezamos a trabajar
Instalar veinte programas no convierte a nadie en pentester. Lo que empieza a parecerse a una auditoría es el proceso que construimos con ellos.
Por ejemplo, dentro de un dominio propio podríamos trabajar así:
Dominio ↓ Subfinder ↓ DNSX ↓ HTTPX ↓ Katana ↓ Naabu / Nmap ↓ Nuclei ↓ Validación manual ↓ Informe
Desde PowerShell incluso podemos encadenar parte del proceso:
subfinder -d ejemplo.es -silent |
httpx -silent |
nuclei -severity info,low,medium
El comando no es lo importante. Lo importante es entender por qué el resultado de una fase se convierte en la entrada de la siguiente.
Un laboratorio OSINT también cabe en PowerShell
Podemos hacer lo mismo con información pública:
Alias ───────→ Sherlock
│
Fotografía ──→ ExifTool
│
Dominio ─────→ Subfinder
│
DNSX / HTTPX
│
↓
Correlación
│
↓
Informe
OSINT no consiste en acumular datos de personas. Un trabajo serio exige finalidad legítima, proporcionalidad, respeto a la privacidad y, sobre todo, capacidad para distinguir coincidencia de evidencia.
Algo de literatura hacker: las herramientas cambian, la forma de pensar permanece
Si queremos aprender de verdad, no deberíamos vivir únicamente dentro de la consola. La cultura hacker tiene décadas de historia y parte de esa historia sigue explicando muy bien por qué hacemos las cosas de una determinada manera.
Hackers: Heroes of the Computer Revolution, de Steven Levy, es una buena puerta de entrada a la cultura hacker temprana. No es un manual de intrusión. Es una historia sobre curiosidad, creatividad, acceso al conocimiento y obsesión por comprender sistemas.
The Cuckoo’s Egg, de Clifford Stoll, sigue siendo una lectura magnífica porque el núcleo de la historia no envejece: una anomalía pequeña lleva a investigar, correlacionar y seguir rastros hasta comprender un incidente mucho mayor.
The Web Application Hacker’s Handbook, de Dafydd Stuttard y Marcus Pinto, pertenece a otra época tecnológica en algunos detalles, pero continúa siendo útil para aprender a razonar sobre aplicaciones web.
También merece la pena leer write-ups de CTF, avisos de seguridad de fabricantes, informes de respuesta a incidentes y análisis técnicos de vulnerabilidades. Una persona que quiera dedicarse a pentesting debería acostumbrarse a leer documentación técnica casi a diario.
El error de instalar 200 herramientas
Hay una trampa muy común cuando empezamos: queremos tenerlo todo.
Metasploit, 40 scanners, 20 crawlers, 15 utilidades OSINT y una carpeta llena de scripts que nunca hemos abierto.
Pero si no sabemos explicar qué diferencia existe entre TCP y UDP, qué representa un SYN, cómo funciona DNS o por qué una respuesta HTTP devuelve un 301, esa colección sirve de poco.
Yo utilizaría cada herramienta para aprender un concepto:
- Nmap para puertos, servicios y enumeración.
- TShark para paquetes y protocolos.
- Sherlock y ExifTool para identidad digital y metadatos.
- Subfinder y DNSX para superficie externa y DNS.
- HTTPX y Katana para entender aplicaciones y recursos web.
- Nuclei para aprender a detectar, validar y documentar hallazgos.
- Gitleaks, Semgrep y Bandit para introducir seguridad en el código.
La herramienta es temporal. El concepto se queda.
¿Puede PowerShell sustituir a Kali Linux?
No completamente. Y tampoco debería ser nuestro objetivo.
Kali Linux reúne un ecosistema enorme específicamente preparado para seguridad ofensiva. Algunas técnicas y herramientas resultan más naturales en Linux. Pero para empezar, aprender redes, hacer OSINT, analizar tráfico, revisar código, enumerar activos y practicar auditorías básicas, PowerShell ofrece muchísimo más de lo que muchos imaginan.
Cuando después pases a Kali, las herramientas cambiarán, pero ya sabrás qué problema intentas resolver. Esa diferencia es enorme.
Mi laboratorio mínimo para empezar
Si hoy empezara desde cero, instalaría esto y me obligaría a aprenderlo antes de añadir más:
PowerShell Git Python Go Nmap / Ncat / Nping TShark Sherlock ExifTool Subfinder DNSX HTTPX Naabu Nuclei Katana FFUF Gitleaks Semgrep Bandit jq
Con esta lista hay material de sobra para meses.
Un primer ejercicio completo
Dos ordenadores propios conectados a la misma red son suficientes.
En uno dejamos un pequeño servidor web:
python -m http.server 8080
Desde el equipo auditor:
nmap -sV 192.168.1.50
Comprobamos conectividad:
nping --icmp 192.168.1.50
Miramos el servicio HTTP:
"http://192.168.1.50:8080" | httpx -status-code -title -web-server
Recorremos nuestra propia aplicación:
katana -u http://192.168.1.50:8080
Mientras tanto capturamos nuestro tráfico:
tshark -i 1 -w C:\PentestLab\Captures\ejercicio01.pcapng
Y guardamos cada resultado dentro de C:\PentestLab\Reports.
No hemos hecho nada espectacular. Precisamente por eso es un buen laboratorio: hemos levantado un servicio, descubierto el puerto, identificado la aplicación, generado tráfico, lo hemos capturado y lo podemos documentar. Hemos entendido el proceso.
Legalidad y ética: no es una nota al pie
Escanear, enumerar, interceptar comunicaciones o realizar pruebas activas sobre sistemas que no nos pertenecen puede tener consecuencias técnicas y legales. Por eso los ejemplos de esta guía utilizan entornos propios o ficticios.
En una auditoría profesional debe existir un alcance definido: sistemas autorizados, ventanas de trabajo, técnicas permitidas, limitaciones, tratamiento de datos, responsables y procedimiento de comunicación de incidentes.
Eso también forma parte del hacking ético. De hecho, es lo que hace que sea ético.
Conclusión
Solo hace falta PowerShell para empezar. No para saberlo todo, ni para sustituir todas las plataformas, sino para comenzar de verdad.
Instala Nmap y mira tu propia red. Levanta un servicio y comprueba qué puerto aparece. Captura el tráfico con TShark. Analiza una fotografía tuya con ExifTool. Crea un alias de pruebas y observa su huella con Sherlock. Monta una pequeña aplicación web y recórrela con HTTPX y Katana. Revisa tu propio código con Gitleaks, Semgrep o Bandit.
Rompe cosas que sean tuyas. Después intenta explicar por qué se rompieron.
Para mí, ahí empieza el hacking ético: no en el comando más espectacular, sino en esa costumbre de mirar un sistema y preguntarse: ¿qué está pasando realmente aquí?
Artículo original de Antoni Clarens – Bussio28Team.
Fuentes técnicas de referencia
- Documentación oficial de Nmap y guía de instalación para Windows.
- Documentación oficial de Wireshark/TShark para Windows.
- Documentación oficial de ProjectDiscovery para Subfinder, HTTPX y Nuclei.
- Documentación oficial de Semgrep Community Edition para Windows.
- Repositorio oficial de Sherlock.
- Documentación oficial de Bandit.