pyrph 1.0.0__tar.gz

pyrph-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: pyrph
+Version: 1.0.0
+Summary: Python Obfuscation Engine — VM + Native + MBA
+Author: Therealtobu
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.31.0
+Requires-Dist: python-dotenv>=1.0.0

pyrph-1.0.0/api/database.py

@@ -0,0 +1,35 @@
+import os
+from datetime import datetime
+from sqlalchemy import create_engine, Column, String, Boolean, DateTime, Integer, Text
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+DB_PATH = os.environ.get("DB_PATH", "pyrph.db")
+engine  = create_engine(f"sqlite:///{DB_PATH}", connect_args={"check_same_thread": False})
+Base    = declarative_base()
+Session = sessionmaker(bind=engine)
+
+
+class Key(Base):
+    __tablename__ = "keys"
+    id         = Column(Integer, primary_key=True, autoincrement=True)
+    key_string = Column(String(64), unique=True, nullable=False, index=True)
+    hwid       = Column(String(128), nullable=True, index=True)
+    tier       = Column(String(16), default="free")   # free | paid
+    is_active  = Column(Boolean, default=True)
+    is_used    = Column(Boolean, default=False)        # free one-shot flag
+    created_at = Column(DateTime, default=datetime.utcnow)
+    expires_at = Column(DateTime, nullable=True)
+    note       = Column(Text, nullable=True)
+    used_count = Column(Integer, default=0)
+
+
+def init_db():
+    Base.metadata.create_all(engine)
+
+
+def get_db():
+    db = Session()
+    try:
+        yield db
+    finally:
+        db.close()

pyrph-1.0.0/api/main.py

@@ -0,0 +1,234 @@
+import os
+from datetime import datetime
+from typing import Optional
+from fastapi import FastAPI, Depends, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from .database import init_db, get_db, Key
+from .utils import gen_key, hash_hwid, is_admin, free_expiry, is_expired
+
+app = FastAPI(docs_url=None, redoc_url=None)
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+_web = os.path.join(os.path.dirname(__file__), "..", "web", "static")
+if os.path.exists(_web):
+    app.mount("/static", StaticFiles(directory=_web), name="static")
+
+@app.on_event("startup")
+def startup(): init_db()
+
+# ── Models ────────────────────────────────────────────────────────────────
+class GetkeyReq(BaseModel):
+    hwid: str
+
+class VerifyReq(BaseModel):
+    key: str
+    hwid: str
+
+class ActivateReq(BaseModel):
+    key: str
+    hwid: str
+
+class MarkUsedReq(BaseModel):
+    key: str
+    hwid: str
+
+class AdminGenReq(BaseModel):
+    token: str
+    tier: str = "paid"
+    note: Optional[str] = None
+
+class AdminRevokeReq(BaseModel):
+    token: str
+    key: str
+
+class AdminActivateReq(BaseModel):
+    token: str
+    hwid: str    # hashed HWID from user
+    key: str
+
+class AdminResetReq(BaseModel):
+    token: str
+    key: str
+
+
+# ── Public ────────────────────────────────────────────────────────────────
+
+@app.post("/api/getkey")
+async def getkey(req: GetkeyReq, db: Session = Depends(get_db)):
+    hashed = hash_hwid(req.hwid)
+
+    # Check existing active free key
+    existing = db.query(Key).filter(
+        Key.hwid == hashed, Key.tier == "free",
+        Key.is_active == True, Key.is_used == False
+    ).first()
+
+    if existing and not is_expired(existing.expires_at):
+        return {"ok": True, "key": existing.key_string,
+                "tier": "free", "message": "You already have an active free key."}
+
+    # Create new free key (not yet bound to HWID — bound on activate)
+    k = Key(key_string=gen_key("free"), tier="free",
+            expires_at=free_expiry(), is_used=False)
+    db.add(k); db.commit()
+    return {"ok": True, "key": k.key_string, "tier": "free",
+            "expires_at": k.expires_at.isoformat(),
+            "message": "Free key generated. Activate it with: pyrph --activate <key>"}
+
+
+@app.post("/api/activate")
+async def activate(req: ActivateReq, db: Session = Depends(get_db)):
+    hashed = hash_hwid(req.hwid)
+    k = db.query(Key).filter(Key.key_string == req.key).first()
+
+    if not k:
+        raise HTTPException(403, "Invalid key.")
+    if not k.is_active:
+        raise HTTPException(403, "Key revoked.")
+    if is_expired(k.expires_at):
+        k.is_active = False; db.commit()
+        raise HTTPException(403, "Key expired.")
+    if k.is_used and k.tier == "free":
+        raise HTTPException(403, "Free key already used. Get a new one.")
+
+    # Bind HWID if not yet bound
+    if k.hwid is None:
+        k.hwid = hashed; db.commit()
+    elif k.hwid != hashed:
+        raise HTTPException(403, "Key bound to a different machine.")
+
+    return {"ok": True, "tier": k.tier,
+            "expires_at": k.expires_at.isoformat() if k.expires_at else None}
+
+
+@app.post("/api/verify")
+async def verify(req: VerifyReq, db: Session = Depends(get_db)):
+    hashed = hash_hwid(req.hwid)
+    k = db.query(Key).filter(Key.key_string == req.key).first()
+
+    if not k:              raise HTTPException(403, "Invalid key.")
+    if not k.is_active:    raise HTTPException(403, "Key revoked.")
+    if is_expired(k.expires_at):
+        k.is_active = False; db.commit()
+        raise HTTPException(403, "Key expired.")
+    if k.is_used and k.tier == "free":
+        raise HTTPException(403, "Free key already used.")
+    if k.hwid and k.hwid != hashed:
+        raise HTTPException(403, "Key bound to a different machine.")
+
+    k.used_count += 1; db.commit()
+
+    features = {
+        "profiles":  ["fast","balanced"] if k.tier=="free" else ["fast","balanced","max","stealth","vm","vm_max"],
+        "native":    k.tier == "paid",
+        "nested_vm": k.tier == "paid",
+        "poly_vm":   True,
+        "one_shot":  k.tier == "free",
+    }
+    return {"ok": True, "tier": k.tier, "features": features,
+            "expires_at": k.expires_at.isoformat() if k.expires_at else None}
+
+
+@app.post("/api/mark_used")
+async def mark_used(req: MarkUsedReq, db: Session = Depends(get_db)):
+    hashed = hash_hwid(req.hwid)
+    k = db.query(Key).filter(Key.key_string == req.key, Key.hwid == hashed).first()
+    if k and k.tier == "free":
+        k.is_used = True; db.commit()
+    return {"ok": True}
+
+
+@app.get("/api/status")
+async def status():
+    return {"status": "online", "version": "1.0.0"}
+
+
+# ── Admin ─────────────────────────────────────────────────────────────────
+
+@app.post("/api/admin/genkey")
+async def admin_genkey(req: AdminGenReq, db: Session = Depends(get_db)):
+    if not is_admin(req.token): raise HTTPException(401, "Unauthorized.")
+    tier = req.tier if req.tier in ("free","paid") else "paid"
+    k    = Key(key_string=gen_key(tier), tier=tier,
+                expires_at=free_expiry() if tier=="free" else None,
+                note=req.note)
+    db.add(k); db.commit()
+    return {"ok": True, "key": k.key_string, "tier": tier,
+            "expires_at": k.expires_at.isoformat() if k.expires_at else "lifetime"}
+
+
+@app.post("/api/admin/activate")
+async def admin_activate(req: AdminActivateReq, db: Session = Depends(get_db)):
+    """Admin manually binds a paid key to a user's HWID."""
+    if not is_admin(req.token): raise HTTPException(401, "Unauthorized.")
+    k = db.query(Key).filter(Key.key_string == req.key).first()
+    if not k: raise HTTPException(404, "Key not found.")
+    k.hwid      = req.hwid   # already hashed from client
+    k.is_active = True
+    db.commit()
+    return {"ok": True, "message": f"Key {req.key} bound to HWID."}
+
+
+@app.post("/api/admin/reset_hwid")
+async def admin_reset_hwid(req: AdminResetReq, db: Session = Depends(get_db)):
+    """Reset HWID binding so key can be activated on a new machine."""
+    if not is_admin(req.token): raise HTTPException(401, "Unauthorized.")
+    k = db.query(Key).filter(Key.key_string == req.key).first()
+    if not k: raise HTTPException(404, "Key not found.")
+    k.hwid = None; db.commit()
+    return {"ok": True, "message": "HWID reset. User can activate on a new machine."}
+
+
+@app.post("/api/admin/revoke")
+async def admin_revoke(req: AdminRevokeReq, db: Session = Depends(get_db)):
+    if not is_admin(req.token): raise HTTPException(401, "Unauthorized.")
+    k = db.query(Key).filter(Key.key_string == req.key).first()
+    if not k: raise HTTPException(404, "Key not found.")
+    k.is_active = False; db.commit()
+    return {"ok": True, "message": f"Key {req.key} revoked."}
+
+
+@app.get("/api/admin/keys")
+async def admin_keys(token: str, db: Session = Depends(get_db)):
+    if not is_admin(token): raise HTTPException(401, "Unauthorized.")
+    keys = db.query(Key).order_by(Key.created_at.desc()).limit(300).all()
+    return {"ok": True, "keys": [
+        {"key": k.key_string, "tier": k.tier,
+         "hwid": (k.hwid[:12]+"..." if k.hwid else None),
+         "hwid_full": k.hwid,
+         "active": k.is_active, "used": k.is_used,
+         "uses": k.used_count, "note": k.note,
+         "expires": k.expires_at.isoformat() if k.expires_at else "lifetime",
+         "created": k.created_at.isoformat()}
+        for k in keys
+    ]}
+
+
+@app.get("/api/admin/stats")
+async def admin_stats(token: str, db: Session = Depends(get_db)):
+    if not is_admin(token): raise HTTPException(401, "Unauthorized.")
+    total  = db.query(Key).count()
+    active = db.query(Key).filter(Key.is_active==True).count()
+    free   = db.query(Key).filter(Key.tier=="free", Key.is_active==True).count()
+    paid   = db.query(Key).filter(Key.tier=="paid", Key.is_active==True).count()
+    uses   = sum(k.used_count for k in db.query(Key).all())
+    return {"ok":True,"total_keys":total,"active_keys":active,
+            "free_keys":free,"paid_keys":paid,"total_uses":uses}
+
+
+# ── Pages ─────────────────────────────────────────────────────────────────
+_T = lambda f: os.path.join(os.path.dirname(__file__),"..","web","templates",f)
+
+@app.get("/",        response_class=HTMLResponse)
+async def pg_index():  return FileResponse(_T("index.html"))
+
+@app.get("/getkey",  response_class=HTMLResponse)
+async def pg_getkey(): return FileResponse(_T("getkey.html"))
+
+@app.get("/admin",   response_class=HTMLResponse)
+async def pg_admin():  return FileResponse(_T("admin.html"))

pyrph-1.0.0/api/utils.py

@@ -0,0 +1,21 @@
+import hashlib, hmac, os, secrets
+from datetime import datetime, timedelta
+
+ADMIN_SECRET = os.environ.get("ADMIN_SECRET", "changeme")
+
+def gen_key(tier: str) -> str:
+    prefix = "PRF" if tier == "free" else "PRP"
+    b = secrets.token_hex(10).upper()
+    return f"{prefix}-{b[:5]}-{b[5:10]}-{b[10:15]}-{b[15:20]}"
+
+def hash_hwid(hwid: str) -> str:
+    return hmac.new(ADMIN_SECRET.encode(), hwid.encode(), hashlib.sha256).hexdigest()[:48]
+
+def is_admin(token: str) -> bool:
+    return hmac.compare_digest(token, ADMIN_SECRET)
+
+def free_expiry() -> datetime:
+    return datetime.utcnow() + timedelta(hours=24)
+
+def is_expired(dt) -> bool:
+    return dt is not None and datetime.utcnow() > dt

pyrph-1.0.0/pyrph/__init__.py

@@ -0,0 +1,2 @@
+"""Pyrph — Python Obfuscation Engine"""
+__version__ = "1.0.0"

pyrph-1.0.0/pyrph/__main__.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+Pyrph — Python Obfuscation Engine
+Entry point: python -m pyrph  OR  pyrph  (after pip install)
+"""
+import sys
+import os
+import ast
+import time
+from pathlib import Path
+
+
+# ── ANSI colors ───────────────────────────────────────────────────────────
+R="\033[0m"; B="\033[1m"; DIM="\033[2m"
+CY="\033[36m"; GR="\033[32m"; YL="\033[33m"; RD="\033[31m"; PU="\033[35m"
+
+
+def _c(s, *codes): return "".join(codes)+s+R
+
+
+# ── Banner ────────────────────────────────────────────────────────────────
+BANNER = f"""
+{CY}{B}  ██████╗ ██╗   ██╗██████╗ ██████╗ ██╗  ██╗
+  ██╔══██╗╚██╗ ██╔╝██╔══██╗██╔══██╗██║  ██║
+  ██████╔╝ ╚████╔╝ ██████╔╝██████╔╝███████║
+  ██╔═══╝   ╚██╔╝  ██╔══██╗██╔═══╝ ██╔══██║
+  ██║        ██║   ██║  ██║██║     ██║  ██║
+  ╚═╝        ╚═╝   ╚═╝  ╚═╝╚═╝     ╚═╝  ╚═╝{R}
+{DIM}  Python Obfuscation Engine · v1.0.0{R}
+"""
+
+
+def _print_banner():
+    print(BANNER)
+
+
+def _print_hwid_screen(hwid: str):
+    print(_c("  ┌─────────────────────────────────────────┐", DIM))
+    print(_c("  │           MACHINE IDENTIFIER            │", DIM))
+    print(_c("  └─────────────────────────────────────────┘", DIM))
+    print()
+    print(f"  {DIM}Your HWID:{R}")
+    print(f"  {CY}{B}{hwid}{R}")
+    print()
+    print(f"  {DIM}To use Pyrph, you need a key:{R}")
+    print(f"  {GR}▸ Free key  {R}{DIM}→  Visit: {R}{CY}https://pyrph.vercel.app/getkey{R}")
+    print(f"  {YL}▸ Paid key  {R}{DIM}→  Visit: {R}{CY}https://pyrph.vercel.app{R}")
+    print()
+    print(f"  {DIM}Already have a key? Run:{R}")
+    print(f"  {CY}pyrph --activate <your-key>{R}")
+    print()
+
+
+def _print_tier_screen(tier: str, expires_at=None):
+    if tier == "paid":
+        icon  = f"{GR}●{R}"
+        label = f"{GR}{B}PAID{R}"
+        info  = f"{GR}Full access · Lifetime · Native + PolyVM + NestedVM{R}"
+    else:
+        icon  = f"{YL}●{R}"
+        label = f"{YL}{B}FREE{R}"
+        exp   = f" · Expires after this run" if expires_at else ""
+        info  = f"{YL}Limited access · PolyVM only · 1 obfuscation{R}{exp}"
+
+    print(f"  {icon} Status: {label}")
+    print(f"  {DIM}{info}{R}")
+    print()
+
+
+def _prompt_file() -> str:
+    print(f"  {DIM}Enter the Python file to obfuscate:{R}")
+    try:
+        path = input(f"  {CY}▸ File path: {R}").strip()
+    except (KeyboardInterrupt, EOFError):
+        print("\n  Cancelled.")
+        sys.exit(0)
+    return path
+
+
+def _run_obf(filepath: str, tier: str, key: str):
+    src_path = Path(filepath)
+
+    if not src_path.exists():
+        print(f"\n  {RD}✗ File not found: {filepath}{R}")
+        sys.exit(1)
+
+    if not filepath.endswith(".py"):
+        print(f"\n  {RD}✗ Only .py files supported.{R}")
+        sys.exit(1)
+
+    size_kb = src_path.stat().st_size / 1024
+    if tier == "free" and size_kb > 50:
+        print(f"\n  {RD}✗ Free tier limited to 50KB. Your file: {size_kb:.1f}KB{R}")
+        print(f"  {YL}Upgrade to paid for unlimited file size.{R}")
+        sys.exit(1)
+
+    # Determine profile and options based on tier
+    if tier == "paid":
+        profile = "balanced"
+        opts = dict(native=True, use_vm=True, vm_mode=False)
+    else:
+        # Free: PolyVM only, no Nested, no Native
+        profile = "balanced"
+        opts = dict(native=False, use_vm=True, vm_mode=False,
+                    layer2=True, cff=True, mba=True)
+
+    print(f"\n  {DIM}Reading {src_path.name} ({size_kb:.1f}KB)...{R}")
+    source = src_path.read_text(encoding="utf-8")
+
+    print(f"  {DIM}Building pipeline [{profile}]...{R}\n")
+
+    try:
+        from pyrph.phases.unified import build_pipeline
+        p       = build_pipeline(profile=profile, **opts)
+        t0      = time.time()
+        results = p.run(source)
+        elapsed = time.time() - t0
+        final   = results[-1].code
+    except Exception as e:
+        print(f"  {RD}✗ Obfuscation failed: {e}{R}")
+        sys.exit(1)
+
+    # Print pass results
+    for r in results:
+        icon = f"{GR}✓{R}" if r.success else f"{RD}✗{R}"
+        msg  = f"{DIM}{r.message}{R}" if r.message else ""
+        print(f"  {icon}  {r.pass_name:<22} {msg}")
+
+    # Validate output
+    try:
+        ast.parse(final)
+    except SyntaxError as e:
+        print(f"\n  {RD}✗ Output syntax error: {e}{R}")
+        sys.exit(1)
+
+    # Save output
+    out_path = src_path.with_stem(src_path.stem + "_obf")
+    out_path.write_text(final, encoding="utf-8")
+
+    in_l  = len(source.splitlines())
+    out_l = len(final.splitlines())
+
+    print(f"\n  {GR}✓ Done in {elapsed:.2f}s{R}")
+    print(f"  {DIM}Lines: {in_l} → {out_l}  ·  Size: {size_kb:.1f}KB → {len(final.encode())/1024:.1f}KB{R}")
+    print(f"  {CY}Saved: {out_path}{R}\n")
+
+    # Mark free key as used (one-shot)
+    if tier == "free":
+        try:
+            from pyrph.key.client import mark_used
+            mark_used(key)
+            print(f"  {YL}⚠ Free key expired. Get a new one at pyrph.vercel.app/getkey{R}\n")
+        except Exception:
+            pass
+
+
+def main():
+    _print_banner()
+
+    args = sys.argv[1:]
+
+    # ── --activate <key> ──────────────────────────────────────────────────
+    if "--activate" in args or "-a" in args:
+        try:
+            idx = args.index("--activate") if "--activate" in args else args.index("-a")
+            key = args[idx + 1]
+        except IndexError:
+            print(f"  {RD}Usage: pyrph --activate <key>{R}")
+            sys.exit(1)
+
+        print(f"  {DIM}Activating key...{R}")
+        from pyrph.key.client import activate
+        result = activate(key)
+        if result.get("ok"):
+            tier = result.get("tier", "free")
+            print(f"  {GR}✓ Activated! Tier: {tier.upper()}{R}")
+            if tier == "paid":
+                print(f"  {GR}Full access unlocked. Run: pyrph{R}")
+            else:
+                print(f"  {YL}Free access. Run: pyrph{R}")
+        else:
+            print(f"  {RD}✗ {result.get('error') or result.get('detail', 'Activation failed')}{R}")
+        sys.exit(0)
+
+    # ── --getkey ──────────────────────────────────────────────────────────
+    if "--getkey" in args:
+        from pyrph.key.hwid import get_hwid
+        from pyrph.key.client import getkey_request
+        hwid = get_hwid()
+        print(f"  {DIM}Requesting free key for HWID: {hwid[:16]}...{R}")
+        result = getkey_request(hwid)
+        if result.get("ok"):
+            key = result["key"]
+            print(f"  {GR}✓ Key generated:{R}")
+            print(f"  {CY}{B}{key}{R}")
+            print(f"\n  {DIM}Activate it:{R} {CY}pyrph --activate {key}{R}")
+        else:
+            print(f"  {RD}✗ {result.get('error','Failed')}{R}")
+            print(f"  {DIM}Or visit: https://pyrph.vercel.app/getkey{R}")
+        sys.exit(0)
+
+    # ── --logout ──────────────────────────────────────────────────────────
+    if "--logout" in args:
+        from pyrph.key.client import delete_key
+        delete_key()
+        print(f"  {GR}✓ Key removed.{R}")
+        sys.exit(0)
+
+    # ── Main flow ─────────────────────────────────────────────────────────
+    from pyrph.key.hwid    import get_hwid
+    from pyrph.key.client  import verify, load_key
+
+    hwid = get_hwid()
+    key  = load_key() or os.environ.get("PYRPH_KEY")
+
+    if not key:
+        _print_hwid_screen(hwid)
+        sys.exit(0)
+
+    # Verify key
+    print(f"  {DIM}Verifying key...{R}", end="", flush=True)
+    result = verify(key)
+    print(f"\r  ", end="")
+
+    if not result.get("ok"):
+        err = result.get("error", "unknown")
+        if err == "offline":
+            print(f"  {YL}⚠ Offline — using cached license.{R}")
+        elif err in ("expired", "Key expired."):
+            print(f"  {RD}✗ Key expired.{R}")
+            from pyrph.key.client import delete_key
+            delete_key()
+            _print_hwid_screen(hwid)
+            sys.exit(1)
+        else:
+            print(f"  {RD}✗ {err}{R}")
+            _print_hwid_screen(hwid)
+            sys.exit(1)
+        # Try cached result
+        result = {"ok": True, "tier": "free", "features": None}
+
+    tier       = result.get("tier", "free")
+    expires_at = result.get("expires_at")
+
+    _print_tier_screen(tier, expires_at)
+
+    # Prompt for file
+    filepath = _prompt_file()
+    if not filepath:
+        print(f"  {RD}No file entered.{R}")
+        sys.exit(1)
+
+    _run_obf(filepath, tier, key)
+
+
+if __name__ == "__main__":
+    main()