Update bot.py

bot.py

@@ -5,7 +5,6 @@ import base64
 import uuid
 import tempfile
 import shutil
-import subprocess
 from pathlib import Path
 from fastapi import FastAPI, UploadFile, File
 import aiohttp
@@ -13,85 +12,59 @@ import uvicorn
 
 app = FastAPI()
 
+MAX_FILE_SIZE = 5*1024*1024  # 5 MB
+
 # -------------------------------
-# 🔐 Custom C-Based Python File Encoder
+# 🔐 Pure Python Encryptor
 # -------------------------------
 
-C_TEMPLATE = """/*KEY_BYTES*/"""  # Replace with your actual C template
-SETUP_PY = """# Your setup.py content"""  # Replace with actual setup.py
-
 def make_zip_bytes(filename: str, content: bytes) -> bytes:
     bio = io.BytesIO()
     with zipfile.ZipFile(bio, "w", compression=zipfile.ZIP_DEFLATED) as zf:
         zf.writestr(filename, content)
     return bio.getvalue()
 
-def rand_bytes(n): 
+def rand_bytes(n: int) -> bytes:
     return os.urandom(n)
 
-def compile_c_extension(build_dir: Path):
-    (build_dir/"setup.py").write_text(SETUP_PY)
-    proc = subprocess.run([os.sys.executable,"setup.py","build_ext","--inplace"],
-                          cwd=str(build_dir), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=30)
-    candidates = list(build_dir.glob("aes_helper*.so")) + list(build_dir.glob("build/lib.*/*.so"))
-    if not candidates:
-        raise RuntimeError("Compile fail:\n"+proc.stdout.decode())
-    return candidates[0]
-
-def build_wrapper(cipher_b64, so_b64, so_filename):
-    wrapper = f"""# Auto Encrypted by JerryCoder C Encryptor
-import base64,zipfile,io,tempfile,os,runpy
-O = base64.b64decode('{cipher_b64}')
-M = base64.b64decode('{so_b64}')
+def xor_bytes(data: bytes, key: bytes) -> bytes:
+    return bytes([b ^ key[i % len(key)] for i, b in enumerate(data)])
+
+def generate_junk_data(min_kb=50, max_kb=70):
+    junk_size = int.from_bytes(rand_bytes(2), 'big') % ((max_kb-min_kb)*1024) + min_kb*1024
+    chars = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_()-./,;:!?"
+    return bytes([chars[b % len(chars)] for b in rand_bytes(junk_size)])
+
+def build_wrapper(enc_b64: str, key_b64: str):
+    junk = generate_junk_data()
+    wrapper = f"""# Auto Encrypted by JerryCoder Python Encryptor
+import base64, zipfile, io, tempfile, os, runpy
+D = base64.b64decode('{enc_b64}')
+K = base64.b64decode('{key_b64}')
+O = bytes([b ^ K[i % len(K)] for i, b in enumerate(D)])
 tmpdir = tempfile.mkdtemp()
-so_path = os.path.join(tmpdir,'{so_filename}')
-with open(so_path,'wb') as f: f.write(M)
-import importlib.machinery as L, importlib.util as U
-loader = L.ExtensionFileLoader('aes_helper',so_path)
-spec = U.spec_from_loader(loader.name,loader)
-mod = U.module_from_spec(spec)
-loader.exec_module(mod)
-try:
-    z = mod.decrypt(O)
-    extract_dir = tempfile.mkdtemp()
-    zipfile.ZipFile(io.BytesIO(z)).extractall(extract_dir)
-    py_file = [f for f in os.listdir(extract_dir) if f.endswith('.py')][0]
-    runpy.run_path(os.path.join(extract_dir, py_file))
-except Exception as e:
-    print('decrypt_error', e)
-finally:
-    os.remove(so_path)
+zipfile.ZipFile(io.BytesIO(O)).extractall(tmpdir)
+py_file = [f for f in os.listdir(tmpdir) if f.endswith('.py')][0]
+runpy.run_path(os.path.join(tmpdir, py_file))
 """
     return wrapper.encode()
 
 def encode_bytes(file_bytes: bytes, filename: str):
-    tmpdir = Path(tempfile.mkdtemp())
-    try:
-        # Save original .py
-        input_path = tmpdir/filename
-        input_path.write_bytes(file_bytes)
-        zipped = make_zip_bytes(filename, file_bytes)
-        key = rand_bytes(32)
-        iv = rand_bytes(16)
-        (tmpdir/"aes_helper.c").write_text(C_TEMPLATE.replace("/*KEY_BYTES*/", ",".join(str(x) for x in key)))
-        so_path = compile_c_extension(tmpdir)
-        so_b64 = base64.b64encode(so_path.read_bytes()).decode()
-        cipher_b64 = base64.b64encode(zipped).decode()  # Optionally replace with mod.encrypt(zipped)
-        wrapper_name = f"{os.path.splitext(filename)[0]}_{uuid.uuid4().hex}_enc.py"
-        wrapper_bytes = build_wrapper(cipher_b64, so_b64, so_path.name)
-        return wrapper_bytes, wrapper_name
-    finally:
-        shutil.rmtree(tmpdir, ignore_errors=True)
-
-MAX_FILE_SIZE = 5*1024*1024  # 5 MB limit
+    zipped = make_zip_bytes(filename, file_bytes)
+    key = rand_bytes(16)
+    enc = xor_bytes(zipped, key)
+    enc_b64 = base64.b64encode(enc).decode()
+    key_b64 = base64.b64encode(key).decode()
+    wrapper_bytes = build_wrapper(enc_b64, key_b64)
+    wrapper_name = f"{os.path.splitext(filename)[0]}_{uuid.uuid4().hex}_enc.py"
+    return wrapper_bytes, wrapper_name
 
 # -------------------------------
 # POST /api/encode
 # -------------------------------
 @app.post("/api/encode")
 async def encode_post(file: UploadFile = File(...)):
-    filename = file.filename
-    if not filename.endswith(".py"):
+    if not file.filename.endswith(".py"):
         return {"ok": False, "error": "Only Python (.py) files are allowed"}
 
     try:
@@ -99,8 +72,7 @@ async def encode_post(file: UploadFile = File(...)):
         if len(file_bytes) > MAX_FILE_SIZE:
             return {"ok": False, "error": "File too large (max 5MB)"}
 
-        wrapper_bytes, wrapper_name = encode_bytes(file_bytes, filename)
-
+        wrapper_bytes, wrapper_name = encode_bytes(file_bytes, file.filename)
         tmp_path = os.path.join(tempfile.gettempdir(), wrapper_name)
         with open(tmp_path, "wb") as f:
             f.write(wrapper_bytes)
@@ -132,6 +104,7 @@ async def encode_get(url: str, filename: str = "file.py"):
                 if resp.status != 200:
                     return {"ok": False, "error": f"Failed to fetch file ({resp.status})"}
                 file_bytes = await resp.read()
+
         wrapper_bytes, wrapper_name = encode_bytes(file_bytes, filename)
         tmp_path = os.path.join(tempfile.gettempdir(), wrapper_name)
         with open(tmp_path, "wb") as f: