pycrypt.py

import zlib
import base64
import hashlib
import argparse
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
import random, string

def random_string(length=8):
    return ''.join(random.choice(string.ascii_letters) for _ in range(length))

salt = random_string()

def pad(data):
    pad_len = AES.block_size - (len(data) % AES.block_size)
    return data + bytes([pad_len] * pad_len)

def unpad(data):
    return data[:-data[-1]]

def generate_key(key):
    return hashlib.sha256(key.encode()).digest()

def aes_encrypt(data, key):
    iv = get_random_bytes(AES.block_size)
    cipher = AES.new(key, AES.MODE_CBC, iv)
    encrypted_data = cipher.encrypt(pad(data))
    return base64.b64encode(iv + encrypted_data).decode('utf-8')

def aes_decrypt(enc_data, key):
    enc_data = base64.b64decode(enc_data)
    iv = enc_data[:AES.block_size]
    cipher = AES.new(key, AES.MODE_CBC, iv)
    return unpad(cipher.decrypt(enc_data[AES.block_size:]))

def encrypt_script(input_file, output_file, key):
    with open(input_file, 'rb') as f:
        script_content = f.read()
    
    compressed = zlib.compress(script_content)
    encrypted = aes_encrypt(compressed, generate_key(key))
    obfuscated = encrypted[::-1]
    
    encrypted_key = aes_encrypt(key.encode(), generate_key(salt))
    obfuscated_key = encrypted_key[::-1]
    
    func_unpad = random_string()
    func_generate_key = random_string()
    func_aes_decrypt = random_string()
    var_data = random_string()
    var_data2 = random_string()
    var_data3 = random_string()
    data = random_string()
    decrypted_data = random_string()
    decompressed_data = random_string()
    compiled_script = random_string()
    key_data = random_string()
    
    decryption_code = f"""
# Our channels on Telegram: @darks1ders
# GitHub: https://github.com/s4rrar

import zlib
import base64
import hashlib
from Crypto.Cipher import AES

def {func_unpad}({var_data}):
    return {var_data}[:-{var_data}[-1]]

def {func_generate_key}({var_data}):
    return hashlib.sha256({var_data}.encode()).digest()

def {func_aes_decrypt}({var_data}, {var_data2}):
    {var_data} = base64.b64decode({var_data})
    iv = {var_data}[:AES.block_size]
    {var_data3} = AES.new({var_data2}, AES.MODE_CBC, iv)
    return {func_unpad}({var_data3}.decrypt({var_data}[AES.block_size:]))

{key_data} = "{obfuscated_key}"[::-1]
{key_data} = {func_aes_decrypt}({key_data}, {func_generate_key}("{salt}"))

{data} = "{obfuscated}"[::-1]
{decrypted_data} = {func_aes_decrypt}({data}, {func_generate_key}({key_data}.decode()))
{decompressed_data} = zlib.decompress({decrypted_data})

try:
    {compiled_script} = compile({decompressed_data}, '<string>', 'exec')
    exec({compiled_script})
except SyntaxError as e:
    print(f"SyntaxError in decrypted script: {{e}}")
"""
    
    with open(output_file, 'w') as f:
        f.write(decryption_code)
    print(f"Script encrypted and saved to {output_file}")

if __name__ == "__main__":
    print("PyCrypt by: @s4rrar")
    parser = argparse.ArgumentParser(description="Encrypt a Python script.")
    parser.add_argument("-i", "--input", required=True, help="Input Python script file")
    parser.add_argument("-o", "--output", required=True, help="Output encrypted script file")
    parser.add_argument("-key", "--key", required=True, help="Encryption key")
    args = parser.parse_args()
    
    encrypt_script(args.input, args.output, args.key)