Saltar al contenido principal

Lab 5.1: Reconocimiento de Red con Nmap

Objetivos de Aprendizaje​

Al final de este laboratorio, usted será capaz de:

  • Instalar y configurar Nmap en Windows y Linux
  • Realizar diferentes tipos de escaneos de red
  • Identificar los hosts activos en una red
  • Descubrir los puertos abiertos y servicios en escucha
  • Detectar sistemas operativos de forma remota
  • Identificar vulnerabilidades conocidas con scripts NSE
  • Interpretar los resultados del escaneo para evaluación de seguridad
  • Comprender técnicas de evasión de detección

Duración Estimada​

40 minutos

Prerrequisitos​

  • 2 VMs: Windows y Kali Linux (o 2 Windows)
  • Red interna configurada en VirtualBox
  • Comprensión del modelo TCP/IP
  • Conocimientos sobre puertos y servicios

Contexto Profesional​

Nmap (Network Mapper) es la herramienta de escaneo de red más utilizada en el mundo por:

  • Administradores de sistemas para inventario de red
  • Profesionales de seguridad para pruebas de penetración
  • Analistas SOC para detección de anomalías
  • Auditores para verificación de cumplimiento

Nmap permite:

  • Descubrir todos los dispositivos en una red
  • Identificar los servicios expuestos
  • Detectar los sistemas operativos
  • Encontrar vulnerabilidades conocidas
  • Validar configuraciones de firewall
  • Mapear la infraestructura de red

Escanear una red sin autorización es ilegal en la mayoría de las jurisdicciones.

AUTORIZADO:

  • En su propia red de laboratorio (VMs aisladas)
  • En sistemas de su propiedad
  • En el marco de pruebas de penetración con contrato firmado
  • En plataformas de laboratorio legales (HackTheBox, TryHackMe)

ESTRICTAMENTE PROHIBIDO:

  • Escanear redes empresariales sin autorización escrita
  • Escanear redes públicas o de terceros
  • Escanear Internet aleatoriamente
  • Usar para identificar objetivos a atacar

CONSECUENCIAS LEGALES: Escanear sin autorización = Reconocimiento ilegal, preludio de ataque informático (Código penal art. 342.1). Detección fácil mediante IDS/IPS. Alta probabilidad de proceso penal.

Configuración requerida para este laboratorio:

  • Red de VMs en modo SOLO INTERNO
  • Sin acceso a Internet
  • Entorno aislado y controlado

Parte 1: Instalación y Configuración​

Paso 1.1: Instalación en Windows​

Descarga:

Instalación:

  1. Ejecute el archivo .exe descargado
  2. Acepte la licencia
  3. Componentes recomendados:
    • Nmap Core Files (obligatorio)
    • Npcap (obligatorio - para captura de paquetes)
    • Zenmap GUI (opcional pero útil para principiantes)
    • Ndiff (opcional)
  4. Instalación completa

Verificación:

nmap --version

Resultado esperado:

Nmap version 7.94 ( https://nmap.org )
Platform: x86_64-w64-mingw32
Compiled with: ...

Paso 1.2: Instalación en Kali Linux​

¡Nmap está preinstalado en Kali Linux!

Verificación:

nmap --version

Actualización si es necesario:

sudo apt update
sudo apt install nmap -y

Paso 1.3: Configuración de Red del Laboratorio​

Arquitectura del laboratorio:

VM1 (Kali Linux - Escáner):
  IP: 192.168.100.10
  Rol: Realizar los escaneos

VM2 (Windows - Objetivo):
  IP: 192.168.100.20
  Rol: Sistema a escanear
  Servicios: Varios puertos abiertos

Red: Internal Network "LabNet"

En cada VM, verifique la conectividad:

ping 192.168.100.20  # Desde Kali
ping 192.168.100.10  # Desde Windows

Preguntas:

  1. ¿Qué versión de Nmap ha instalado?
  2. ¿Pueden comunicarse ambas VMs?

Parte 2: Descubrimiento de Hosts (Host Discovery)​

Paso 2.1: Ping Scan Básico​

El escaneo más simple:

nmap 192.168.100.20

Resultado:

Starting Nmap 7.94
Nmap scan report for 192.168.100.20
Host is up (0.00050s latency).
Not shown: 995 closed ports
PORT     STATE SERVICE
135/tcp  open  msrpc
139/tcp  open  netbios-ssn
445/tcp  open  microsoft-ds
3389/tcp open  ms-wbt-server
5357/tcp open  wsdapi

Nmap done: 1 IP address (1 host up) scanned in 2.45 seconds

Análisis:

  • Host activo (up)
  • 5 puertos abiertos detectados
  • Servicios identificados
  • Tiempo de escaneo: ~2 segundos

Paso 2.2: Escaneo de una Red Completa​

Escanear toda una gama de IPs:

nmap 192.168.100.0/24

Opciones:

  • /24 = 256 direcciones (192.168.100.0 a 192.168.100.255)
  • /16 = 65,536 direcciones
  • /8 = 16,777,216 direcciones

Resultado:

Nmap scan report for 192.168.100.1
Host is up (0.00010s latency).

Nmap scan report for 192.168.100.10
Host is up (0.00012s latency).

Nmap scan report for 192.168.100.20
Host is up (0.00015s latency).

Nmap done: 256 IP addresses (3 hosts up) scanned in 4.21 seconds

¡3 hosts activos descubiertos en 4 segundos sobre 256 IPs escaneadas!

Paso 2.3: Descubrimiento de Hosts Sin Escaneo de Puertos​

Solo descubrir qué hosts están activos (sin escaneo de puertos):

nmap -sn 192.168.100.0/24

Opción -sn: Solo ping scan (sin escaneo de puertos)

Más rápido: ¡Escaneo completo en menos de 2 segundos!

Preguntas: 3. ¿Cuántos hosts activos ha descubierto en su red de laboratorio? 4. ¿Cuál es la diferencia de tiempo entre escaneo con y sin puertos?

Parte 3: Escaneo de Puertos​

Paso 3.1: Tipos de Escaneos​

TCP Connect Scan (por defecto para no-root):

nmap -sT 192.168.100.20
  • Conexión TCP completa (3-way handshake)
  • Fiable pero detectable
  • No requiere privilegios root

TCP SYN Scan (sigiloso, requiere root):

sudo nmap -sS 192.168.100.20
  • Conexión TCP incompleta (solo SYN)
  • Más sigiloso
  • Requiere privilegios root/admin

Escaneo UDP:

sudo nmap -sU 192.168.100.20
  • Escanea los puertos UDP
  • Más lento que TCP
  • Importante para DNS, DHCP, SNMP

Paso 3.2: Escaneo de Todos los Puertos​

Por defecto: Nmap escanea solo los 1000 puertos más comunes

Escanear TODOS los 65535 puertos:

nmap -p- 192.168.100.20

Opción -p-: Todos los puertos (1-65535)

ATENCIÓN: ¡Puede tomar 10-20 minutos!

Alternativa rápida:

nmap -p- --min-rate 5000 192.168.100.20

--min-rate 5000: Mínimo 5000 paquetes/segundo = ¡Escaneo en 30-60 segundos!

Paso 3.3: Escaneo de Puertos Específicos​

Puertos específicos:

nmap -p 80,443,3389,445 192.168.100.20

Rango de puertos:

nmap -p 1-1000 192.168.100.20

Combinación:

nmap -p 22,80,443,1000-2000,3389,8080 192.168.100.20

Preguntas: 5. ¿Cuáles son los puertos abiertos en su VM Windows? 6. ¿Cuánto tiempo tarda un escaneo completo de todos los puertos?

Parte 4: Detección de Servicios y Versiones​

Paso 4.1: Detección de Versión de Servicio​

Escanear con detección de versiones:

nmap -sV 192.168.100.20

Opción -sV: Detección de versión

Resultado detallado:

PORT     STATE SERVICE       VERSION
135/tcp  open  msrpc         Microsoft Windows RPC
139/tcp  open  netbios-ssn   Microsoft Windows netbios-ssn
445/tcp  open  microsoft-ds  Microsoft Windows Server 2016 microsoft-ds
3389/tcp open  ms-wbt-server Microsoft Terminal Services
5357/tcp open  http          Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)

Información obtenida:

  • Nombre exacto del servicio
  • Versión del software
  • Información adicional

Intensidad de detección:

nmap -sV --version-intensity 9 192.168.100.20
  • 0 = Ligero (rápido)
  • 9 = Intensivo (completo pero lento)

Paso 4.2: Detección del Sistema Operativo​

Detección de OS:

sudo nmap -O 192.168.100.20

Opción -O: Detección de OS (requiere root)

Resultado:

Running: Microsoft Windows 10|2016|2019
OS CPE: cpe:/o:microsoft:windows_10 cpe:/o:microsoft:windows_server_2016
OS details: Microsoft Windows 10 1709 - 1909, or Windows Server 2016 - 2019
Network Distance: 1 hop

Precisión típica: 85-95%

Paso 4.3: Escaneo Agresivo Completo​

Combinación de todas las opciones:

sudo nmap -A 192.168.100.20

Opción -A: Escaneo agresivo (equivalente a -sV -O -sC --traceroute)

Incluye:

  • Detección de versión
  • Detección de OS
  • Escaneo de scripts
  • Traceroute

Preguntas: 7. ¿Qué sistema operativo ha detectado Nmap? 8. ¿Cuál es la versión de SMB (puerto 445) instalada?

Parte 5: Scripts NSE (Nmap Scripting Engine)​

Paso 5.1: ¿Qué es NSE?​

NSE: Scripts en Lua para automatizar tareas avanzadas:

  • Detección de vulnerabilidades
  • Brute-forcing
  • Enumeración avanzada
  • Explotación de servicios

Categorías de scripts:

  • auth - Autenticación
  • brute - Fuerza bruta
  • discovery - Descubrimiento
  • exploit - Explotación
  • vuln - Vulnerabilidades

Paso 5.2: Escaneo con Scripts por Defecto​

nmap -sC 192.168.100.20

Opción -sC: Escaneo de scripts (scripts por defecto)

Ejemplo de resultado:

PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb2-security-mode: 
|   2.02: 
|     Message signing enabled but not required
| smb2-time: 
|   date: 2024-11-08T15:30:45

¡Información adicional obtenida!

Paso 5.3: Scripts de Vulnerabilidades​

Escanear en busca de vulnerabilidades conocidas:

nmap --script vuln 192.168.100.20

Resultado si es vulnerable:

PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb-vuln-ms17-010: 
|   VULNERABLE:
|   Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
|     State: VULNERABLE
|     IDs:  CVE:CVE-2017-0143
|     Risk factor: HIGH
|       EternalBlue / MS17-010

CRÍTICO: Vulnerabilidad EternalBlue detectada (¡la de WannaCry!)

Paso 5.4: Scripts SMB Enum​

Enumeración completa de SMB:

nmap --script smb-enum-shares,smb-enum-users,smb-os-discovery 192.168.100.20

Información obtenida:

Host script results:
| smb-enum-shares: 
|   account_used: guest
|   \\192.168.100.20\ADMIN$: 
|     Type: STYPE_DISKTREE_HIDDEN
|   \\192.168.100.20\C$: 
|     Type: STYPE_DISKTREE_HIDDEN
|   \\192.168.100.20\IPC$: 
|     Type: STYPE_IPC_HIDDEN
|     
| smb-os-discovery: 
|   OS: Windows 10 Pro (build 19041)
|   Computer name: DESKTOP-ABC123
|   Domain name: WORKGROUP

¡Enumeración completa del sistema objetivo!

Preguntas: 9. ¿Qué recursos compartidos SMB están disponibles? 10. ¿Qué vulnerabilidades ha detectado Nmap?

Parte 6: Técnicas de Escaneo Avanzadas​

Paso 6.1: Escaneo Rápido (Top Ports)​

Escanear solo los puertos más comunes:

nmap --top-ports 20 192.168.100.0/24

Escanea los 20 puertos más comunes en toda la red

Aún más rápido:

nmap --top-ports 100 --min-rate 10000 192.168.100.0/24
  • Top 100 puertos
  • Mínimo 10,000 paquetes/segundo
  • ¡Escaneo completo de red en pocos segundos!

Paso 6.2: Timing Templates​

Nmap ofrece 6 plantillas de velocidad:

nmap -T0 target  # Paranoid (muy lento, sigiloso)
nmap -T1 target  # Sneaky (lento, sigiloso)
nmap -T2 target  # Polite (lento, menos carga)
nmap -T3 target  # Normal (por defecto)
nmap -T4 target  # Aggressive (rápido)
nmap -T5 target  # Insane (muy rápido, puede omitir puertos)

Para este laboratorio, use T4:

nmap -T4 -sV -O 192.168.100.20

¡Escaneo completo y rápido!

Paso 6.3: Output y Formatos de Resultados​

Guardar resultados en archivo:

Formato normal (legible):

nmap 192.168.100.20 -oN scan_results.txt

Formato XML (para herramientas):

nmap 192.168.100.20 -oX scan_results.xml

Formato Grepable (para parsing):

nmap 192.168.100.20 -oG scan_results.gnmap

Todos los formatos al mismo tiempo:

nmap 192.168.100.20 -oA scan_complete

Genera: scan_complete.nmap, scan_complete.xml, scan_complete.gnmap

Preguntas: 11. ¿Qué formato de salida es el más útil para análisis automatizado? 12. ¿Cómo analizaría los resultados con PowerShell?

Parte 7: Escenarios de Uso Reales​

Paso 7.1: Escaneo de Red Empresarial (Simulación)​

Escenario: Auditoría de seguridad de una red empresarial

Fase 1 - Descubrimiento inicial:

nmap -sn 192.168.100.0/24 -oA discovery

Fase 2 - Escaneo rápido de hosts activos:

nmap -iL discovery.gnmap -sV --top-ports 1000 -T4 -oA quick_scan

Fase 3 - Escaneo profundo de servidores:

nmap -iL servers.txt -sV -sC -O -p- -T4 -oA deep_scan

Fase 4 - Escaneo de vulnerabilidades:

nmap -iL servers.txt --script vuln -oA vuln_scan

Resultado: ¡Informe completo de seguridad de la red!

Paso 7.2: Identificación de Máquinas Vulnerables​

Script para encontrar sistemas vulnerables:

# Buscar Windows XP/7/8 (no soportados)
nmap -O 192.168.100.0/24 | grep -B 5 "Windows XP\|Windows 7\|Windows 8"

# Buscar SMBv1 (vulnerable a EternalBlue)
nmap --script smb-protocols 192.168.100.0/24 | grep -B 10 "SMBv1"

# Buscar servicios con versiones antiguas
nmap -sV 192.168.100.0/24 | grep -i "apache 2.2\|openssh 7.4"

Priorización de objetivos:

  1. OS no soportados
  2. Servicios con CVE conocidas
  3. Puertos sensibles abiertos (RDP, SMB, etc.)

Paso 7.3: Cartografía de Red Completa​

Escaneo exhaustivo para documentación:

nmap -sV -sC -O -p- --script discovery -T4 192.168.100.0/24 -oA network_map

Luego analice con Zenmap (GUI):

zenmap

Archivo → Abrir → network_map.xml

¡Visualización gráfica de la red!

Preguntas: 13. ¿Cuánto tiempo tarda un escaneo completo de su red de laboratorio? 14. ¿Qué información crítica ha descubierto?

Parte 8: Técnicas Ofensivas​

Paso 8.1: Fuerza Bruta de Servicios​

SSH Brute Force:

nmap --script ssh-brute --script-args userdb=users.txt,passdb=passwords.txt -p 22 target

RDP Brute Force:

nmap --script rdp-brute -p 3389 target

SMB Brute Force:

nmap --script smb-brute -p 445 target

ATENCIÓN: ¡La fuerza bruta genera muchos logs! Detección fácil.

Paso 8.2: Explotación con Scripts NSE​

Buscar exploits disponibles:

ls /usr/share/nmap/scripts/*exploit*

Ejemplo - MS08-067 (antiguo pero para demostración):

nmap --script smb-vuln-ms08-067 192.168.100.20

Si es vulnerable, el script lo indicará!

Lista de scripts de vulnerabilidades:

nmap --script-help vuln

Paso 8.3: Evasión de Firewall​

Técnicas para evadir la detección:

Fragmentar paquetes:

nmap -f 192.168.100.20

Decoy scans (falsos escaneos desde otras IPs):

nmap -D RND:10 192.168.100.20

Spoof de IP de origen:

sudo nmap -S 192.168.100.50 -e eth0 192.168.100.20

Aleatorizar orden de escaneo:

nmap --randomize-hosts 192.168.100.0/24

Preguntas: 15. ¿Por qué usar técnicas de evasión? 16. ¿Puede un firewall bloquear completamente Nmap?

Parte 9: Automatización y Reporting​

Paso 9.1: Script de Escaneo Automatizado​

Cree auto_scan.sh:

#!/bin/bash

TARGET=$1
OUTPUT_DIR="nmap_scans_$(date +%Y%m%d_%H%M%S)"

mkdir -p $OUTPUT_DIR

echo "[*] Starting automated scan of $TARGET"
echo "[*] Output directory: $OUTPUT_DIR"

# Phase 1: Host Discovery
echo "[*] Phase 1: Host Discovery"
nmap -sn $TARGET -oA $OUTPUT_DIR/01_discovery

# Phase 2: Quick Port Scan
echo "[*] Phase 2: Quick Port Scan"
nmap -sV --top-ports 1000 -T4 $TARGET -oA $OUTPUT_DIR/02_quick_scan

# Phase 3: Full Port Scan
echo "[*] Phase 3: Full Port Scan"
nmap -p- --min-rate 5000 $TARGET -oA $OUTPUT_DIR/03_full_scan

# Phase 4: Vulnerability Scan
echo "[*] Phase 4: Vulnerability Scan"
nmap --script vuln $TARGET -oA $OUTPUT_DIR/04_vuln_scan

# Phase 5: OS Detection
echo "[*] Phase 5: OS Detection"
sudo nmap -O $TARGET -oA $OUTPUT_DIR/05_os_detection

echo "[*] Scan complete! Results in: $OUTPUT_DIR/"

Uso:

chmod +x auto_scan.sh
./auto_scan.sh 192.168.100.0/24

¡Escaneo completo automatizado de la red!

Paso 9.2: Parsing y Análisis con PowerShell​

En Windows, analice los resultados XML:

[xml]$nmapResults = Get-Content scan_results.xml

# Extraer todos los hosts y puertos abiertos
$nmapResults.nmaprun.host | ForEach-Object {
    $ip = $_.address.addr
    $hostname = $_.hostnames.hostname.name
    
    Write-Host "Host: $ip ($hostname)"
    
    $_.ports.port | Where-Object {$_.state.state -eq "open"} | ForEach-Object {
        Write-Host "  $($_.portid)/$($_.protocol) - $($_.service.name) $($_.service.version)"
    }
}

Paso 9.3: Generación de Reporte HTML​

Convertir XML a HTML:

xsltproc scan_results.xml -o report.html

O utilice un script en Python:

import nmap
import datetime

nm = nmap.PortScanner()
nm.scan('192.168.100.0/24', arguments='-sV')

html = "<html><head><title>Nmap Scan Report</title></head><body>"
html += f"<h1>Network Scan Report</h1>"
html += f"<p>Date: {datetime.datetime.now()}</p>"

for host in nm.all_hosts():
    html += f"<h2>Host: {host}</h2>"
    html += "<table border='1'><tr><th>Port</th><th>Service</th><th>Version</th></tr>"
    
    for proto in nm[host].all_protocols():
        ports = nm[host][proto].keys()
        for port in ports:
            service = nm[host][proto][port]['name']
            version = nm[host][proto][port]['version']
            html += f"<tr><td>{port}</td><td>{service}</td><td>{version}</td></tr>"
    
    html += "</table>"

html += "</body></html>"

with open('nmap_report.html', 'w') as f:
    f.write(html)

print("Report generated: nmap_report.html")

Preguntas: 17. ¿Cómo presentaría los resultados a un cliente? 18. ¿Qué información es la más crítica para incluir?

Entregables​

A entregar:

  1. Informe de escaneo de red (Word/PDF, 5-6 páginas):

    • Respuestas a las 18 preguntas
    • Metodología de escaneo utilizada
    • Resultados de cada fase de escaneo
    • Análisis de vulnerabilidades encontradas
    • Cartografía de red (esquema)

  2. Capturas de pantalla (mínimo 8):

    • Escaneo de descubrimiento de hosts
    • Escaneo de puertos completo
    • Detección de versiones (-sV)
    • Detección de OS (-O)
    • Script vuln en acción
    • Resultados de scripts NSE
    • Visualización en Zenmap
    • Informe generado

  3. Archivos de resultados Nmap:

    • Formatos .nmap, .xml, .gnmap
    • Para al menos 3 tipos de escaneos diferentes

  4. Script de automatización:

    • Script bash o PowerShell
    • Escaneo completo automatizado
    • Generación de informe

  5. Análisis de seguridad (2-3 páginas):

    • Vulnerabilidades críticas identificadas
    • Riesgos asociados
    • Recomendaciones de remediación priorizadas

Criterios de Evaluación​

CriterioPuntos
Dominio de los diferentes tipos de escaneo25%
Uso correcto de las opciones de Nmap20%
Detección y análisis de vulnerabilidades25%
Script de automatización funcional15%
Calidad del informe y análisis15%

Comandos de Referencia Rápida​

Escaneos Básicos​

nmap target                    # Escaneo simple
nmap -sn target                # Solo descubrimiento de hosts
nmap -p- target                # Todos los puertos
nmap -p 80,443 target          # Puertos específicos
nmap 192.168.1.0/24            # Escanear una red

Escaneos Avanzados​

nmap -sV target                # Detección de versión
nmap -O target                 # Detección de OS
nmap -sC target                # Escaneo de scripts
nmap -A target                 # Agresivo (todo)
nmap -T4 target                # Timing template

Scripts NSE​

nmap --script vuln target                  # Vulnerabilidades
nmap --script smb-enum-shares target       # Recursos compartidos SMB
nmap --script http-enum target             # Enumeración HTTP
nmap --script ssl-heartbleed target        # Heartbleed

Output​

nmap target -oN file.nmap      # Salida normal
nmap target -oX file.xml       # Salida XML
nmap target -oG file.gnmap     # Salida Grepable
nmap target -oA basename       # Todos los formatos

Optimización​

nmap --min-rate 5000 target              # Velocidad mínima
nmap --max-retries 1 target              # Menos reintentos
nmap --host-timeout 5m target            # Timeout por host
nmap -n target                           # Sin resolución DNS

Solución de Problemas​

Problema: "You requested a scan type which requires raw sockets"​

Solución: Ejecute con sudo (Linux) o como administrador (Windows) para escaneos SYN (-sS) y detección de OS (-O).

Problema: Escaneo muy lento​

Soluciones:

  • Use -T4 para velocidad
  • Limite a los top ports: --top-ports 100
  • Aumente min-rate: --min-rate 5000
  • Desactive resolución DNS: -n

Problema: No se detectan puertos pero el host está activo​

Soluciones:

  • Probablemente el firewall está bloqueando
  • Pruebe escaneo UDP: -sU
  • Pruebe diferentes tipos de escaneo: -sT, -sS
  • Verifique conectividad básica: ping

Para Profundizar (Opcional)​

Challenge 1: Nmap Scripting​

Cree su propio script NSE para:

  • Enumeración personalizada
  • Detección de configuración específica
  • Extracción de información personalizada

Challenge 2: Integración con Metasploit​

Utilice resultados de Nmap en Metasploit:

db_nmap -sV 192.168.100.0/24
hosts
services
vulns

Challenge 3: Comparación Temporal​

Escanee la misma red en diferentes momentos:

  • Identificar nuevos hosts
  • Detectar cambios de configuración
  • Monitoreo de seguridad continuo
ndiff scan1.xml scan2.xml

Recursos Adicionales​

Conclusión​

Este laboratorio le ha enseñado:

  • Instalación y configuración de Nmap
  • Diferentes tipos de escaneos de red
  • Detección de servicios y sistemas operativos
  • Uso de scripts NSE para vulnerabilidades
  • Automatización y reporting
  • Metodología de reconocimiento profesional

Lecciones clave:

  1. Nmap es la herramienta estándar de la industria para reconocimiento de red
  2. Diferentes tipos de escaneo para diferentes objetivos
  3. Los scripts NSE multiplican las capacidades de Nmap
  4. Automatización esencial para redes de gran tamaño
  5. Documentación y reporting críticos para auditoría profesional

En un pentest real:

  • Nmap es siempre el primer paso (reconocimiento)
  • Los resultados guían el resto del ataque
  • Detección fácil si no se toman precauciones (IDS/IPS)
  • El timing y la discreción son importantes en un engagement Red Team

Próximo paso: Lab 5.2 donde aprenderá enumeración DNS avanzada para descubrir subdominios ocultos e información sensible.

Laboratorio desarrollado en el marco del curso Sistemas Operativos - MÓDULO 5