Update bot.py

bot.py

@@ -4,16 +4,22 @@ import zipfile
 import base64
 import uuid
 import tempfile
-from fastapi import FastAPI, Request, UploadFile, File
+import shutil
+import subprocess
+from pathlib import Path
+from fastapi import FastAPI, UploadFile, File
 import aiohttp
 import uvicorn
 
 app = FastAPI()
 
 # -------------------------------
-# 🔐 Simple Python File Encoder
+# 🔐 Custom C-Based Python File Encoder
 # -------------------------------
 
+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:
@@ -23,35 +29,65 @@ def make_zip_bytes(filename: str, content: bytes) -> bytes:
 def rand_bytes(n): 
     return os.urandom(n)
 
-def xor_bytes(data: bytes, key: bytes) -> bytes:
-    return bytes([b ^ key[i % len(key)] for i, b in enumerate(data)])
-
-def encode_bytes(file_bytes: bytes, filename: str):
-    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 = f"""# Auto Encrypted by JerryCoder Encryptor
+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
-D=base64.b64decode('{enc_b64}')
-K=base64.b64decode('{key_b64}')
-O=bytes([b^K[i%len(K)] for i,b in enumerate(D)])
-t=tempfile.mkdtemp()
-zipfile.ZipFile(io.BytesIO(O)).extractall(t)
-p=[f for f in os.listdir(t) if f.endswith('.py')][0]
-runpy.run_path(os.path.join(t,p))
+O = base64.b64decode('{cipher_b64}')
+M = base64.b64decode('{so_b64}')
+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)
 """
-    unique_name = f"{os.path.splitext(filename)[0]}_{uuid.uuid4().hex}_enc.py"
-    return wrapper.encode(), unique_name
+    return wrapper.encode()
 
-MAX_FILE_SIZE = 3 * 1024 * 1024  # 3 MB limit
+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
 
 # -------------------------------
-# POST /api/encode - receive raw file bytes
+# POST /api/encode
 # -------------------------------
-
 @app.post("/api/encode")
 async def encode_post(file: UploadFile = File(...)):
     filename = file.filename
@@ -61,80 +97,64 @@ async def encode_post(file: UploadFile = File(...)):
     try:
         file_bytes = await file.read()
         if len(file_bytes) > MAX_FILE_SIZE:
-            return {"ok": False, "error": "File too large (max 3MB)"}
+            return {"ok": False, "error": "File too large (max 5MB)"}
 
-        encoded_bytes, out_name = encode_bytes(file_bytes, filename)
+        wrapper_bytes, wrapper_name = encode_bytes(file_bytes, filename)
 
-        tmp_path = os.path.join(tempfile.gettempdir(), out_name)
+        tmp_path = os.path.join(tempfile.gettempdir(), wrapper_name)
         with open(tmp_path, "wb") as f:
-            f.write(encoded_bytes)
+            f.write(wrapper_bytes)
 
         # Upload to AR Hosting
-        upload_url = "https://ar-hosting.pages.dev/upload"
-        form_data = aiohttp.FormData()
-        f = open(tmp_path, "rb")
-        form_data.add_field("file", f, filename=out_name, content_type="application/octet-stream")
-
         async with aiohttp.ClientSession() as session:
-            async with session.post(upload_url, data=form_data) as resp:
-                try:
-                    result = await resp.json()
-                except Exception:
-                    f.close()
-                    return {"ok": False, "error": f"AR Hosting returned invalid JSON (status {resp.status})"}
-
-                if resp.status != 200 or "url" not in result:
+            form = aiohttp.FormData()
+            f = open(tmp_path,"rb")
+            form.add_field("file", f, filename=wrapper_name, content_type="application/octet-stream")
+            async with session.post("https://ar-hosting.pages.dev/upload", data=form) as resp:
+                if resp.status != 200:
                     f.close()
-                    return {"ok": False, "error": f"AR Hosting upload failed: {result}"}
-        f.close()
-        return {"ok": True, "result_url": result.get("url"), "filename": out_name}
+                    return {"ok": False, "error": f"AR Hosting failed with status {resp.status}"}
+                result = await resp.json()
+            f.close()
+        return {"ok": True, "result_url": result.get("url"), "filename": wrapper_name}
 
     except Exception as e:
-        return {"ok": False, "error": f"Internal server error: {str(e)}"}
+        return {"ok": False, "error": f"Internal error: {str(e)}"}
 
 # -------------------------------
-# GET /encode?url=...&filename=... (optional)
+# GET /encode?url=...&filename=...
 # -------------------------------
-
 @app.get("/encode")
 async def encode_get(url: str, filename: str = "file.py"):
-    # Keep GET for backward compatibility if URL is public
     try:
         async with aiohttp.ClientSession() as session:
             async with session.get(url) as resp:
                 if resp.status != 200:
                     return {"ok": False, "error": f"Failed to fetch file ({resp.status})"}
                 file_bytes = await resp.read()
-        encoded_bytes, out_name = encode_bytes(file_bytes, filename)
-
-        tmp_path = os.path.join(tempfile.gettempdir(), out_name)
+        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:
-            f.write(encoded_bytes)
+            f.write(wrapper_bytes)
 
         # Upload to AR Hosting
-        upload_url = "https://ar-hosting.pages.dev/upload"
-        form_data = aiohttp.FormData()
-        f = open(tmp_path, "rb")
-        form_data.add_field("file", f, filename=out_name, content_type="application/octet-stream")
-
         async with aiohttp.ClientSession() as session:
-            async with session.post(upload_url, data=form_data) as resp:
-                try:
-                    result = await resp.json()
-                except Exception:
-                    f.close()
-                    return {"ok": False, "error": f"AR Hosting returned invalid JSON (status {resp.status})"}
-                if resp.status != 200 or "url" not in result:
+            form = aiohttp.FormData()
+            f = open(tmp_path,"rb")
+            form.add_field("file", f, filename=wrapper_name, content_type="application/octet-stream")
+            async with session.post("https://ar-hosting.pages.dev/upload", data=form) as resp:
+                if resp.status != 200:
                     f.close()
-                    return {"ok": False, "error": f"AR Hosting upload failed: {result}"}
-        f.close()
-        return {"ok": True, "result_url": result.get("url"), "filename": out_name}
+                    return {"ok": False, "error": f"AR Hosting failed with status {resp.status}"}
+                result = await resp.json()
+            f.close()
+        return {"ok": True, "result_url": result.get("url"), "filename": wrapper_name}
 
     except Exception as e:
-        return {"ok": False, "error": f"Internal server error: {str(e)}"}
+        return {"ok": False, "error": f"Internal error: {str(e)}"}
 
 # -------------------------------
-# 🏁 Run App
+# Run App
 # -------------------------------
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))