pyprivate-obf 1.0.0__py3-none-any.whl

pyprivate_obf/__init__.py

@@ -0,0 +1,18 @@
+from .encoding_methods.encode_strings import encode_strings
+from .encoding_methods.bytecode_obfuscation import bytecode_obfuscation
+from .encoding_methods.simple_marshal import simple_marshal
+from .layers.expiry_time import ExpiryTime
+from .layers.check_version import CheckVersion
+from .layers.libraries_installer import LibrariesInstaller
+from .layers.enter_channel import EnterChannel
+
+__version__ = "1.0.0"
+__all__ = [
+    "encode_strings",
+    "bytecode_obfuscation",
+    "simple_marshal",
+    "ExpiryTime",
+    "CheckVersion",
+    "LibrariesInstaller",
+    "EnterChannel",
+]

pyprivate_obf/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

pyprivate_obf/cli.py

@@ -0,0 +1,476 @@
+import argparse
+import os
+import sys
+from datetime import datetime
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.rule import Rule
+from rich.align import Align
+from rich.prompt import Prompt, Confirm
+from rich.padding import Padding
+from rich import box
+
+from .encoding_methods.encode_strings import encode_strings
+from .encoding_methods.bytecode_obfuscation import bytecode_obfuscation
+from .encoding_methods.simple_marshal import simple_marshal
+from .layers.expiry_time import ExpiryTime
+from .layers.libraries_installer import LibrariesInstaller
+from .layers.check_version import CheckVersion
+from .layers.enter_channel import EnterChannel
+
+
+console = Console(highlight=False)
+
+BANNER_ART = r"""
+ ██████╗ ██╗   ██╗    ██████╗ ██████╗ ██╗██╗   ██╗ █████╗ ████████╗███████╗
+ ██╔══██╗╚██╗ ██╔╝    ██╔══██╗██╔══██╗██║██║   ██║██╔══██╗╚══██╔══╝██╔════╝
+ ██████╔╝ ╚████╔╝     ██████╔╝██████╔╝██║██║   ██║███████║   ██║   █████╗
+ ██╔═══╝   ╚██╔╝      ██╔═══╝ ██╔══██╗██║╚██╗ ██╔╝██╔══██║   ██║   ██╔══╝
+ ██║        ██║       ██║     ██║  ██║██║ ╚████╔╝ ██║  ██║   ██║   ███████╗
+ ╚═╝        ╚═╝       ╚═╝     ╚═╝  ╚═╝╚═╝  ╚═══╝  ╚═╝  ╚═╝   ╚═╝   ╚══════╝
+""".strip("\n")
+
+VERSION = "4.1.2"
+CHANNEL = "t.me/psh_team"
+
+
+def build(
+    source,
+    *,
+    extras=None,
+    encode_strings_opt=False,
+    cpython=False,
+    bytecode=False,
+    layers=1,
+    re_check_version=False,
+):
+    extras = extras or []
+
+    if extras:
+        injected_modules = []
+        injected_code = ""
+        for extra in extras:
+            extra.source = source
+            injected_code += extra.injected_code() + "\n"
+            injected_modules.extend(extra.injected_modules())
+        injected_modules = list(set(injected_modules))
+        source = "\n".join(injected_modules) + "\n\n\n" + injected_code + source
+
+    if encode_strings_opt:
+        source = encode_strings(source)
+
+    if cpython:
+        from .encoding_methods.cpython_obfuscation import cpython_obfuscation
+        source = cpython_obfuscation(source)
+        if encode_strings_opt:
+            source = encode_strings(source)
+
+    no_algorithm_selected = not (cpython or bytecode)
+    for _ in range(layers):
+        if bytecode:
+            source = bytecode_obfuscation(source)
+        if no_algorithm_selected:
+            source = simple_marshal(source)
+        if re_check_version:
+            source = CheckVersion().get_new_source(source)
+            if encode_strings_opt:
+                source = encode_strings(source)
+
+    return source
+
+
+def print_banner():
+    console.print()
+    console.print(Align.center(Text(BANNER_ART, style="bold cyan")))
+    console.print()
+    meta = Table.grid(padding=(0, 3))
+    meta.add_column(justify="center")
+    meta.add_column(justify="center")
+    meta.add_column(justify="center")
+    meta.add_row(
+        Text(f"v{VERSION}", style="bold bright_green"),
+        Text("Python Source Obfuscator", style="bold white"),
+        Text(CHANNEL, style="bold bright_blue underline"),
+    )
+    console.print(Align.center(meta))
+    console.print()
+    console.print(Rule(style="bright_black"))
+    console.print()
+
+
+def print_encoders_table():
+    t = Table(
+        title="[bold white]Encoding Methods[/bold white]",
+        box=box.ROUNDED,
+        border_style="cyan",
+        header_style="bold cyan",
+        title_style="bold white",
+        show_lines=True,
+        expand=True,
+    )
+    t.add_column("Flag", style="bold green", justify="center", width=16)
+    t.add_column("Method", style="white")
+    t.add_column("Description", style="dim white")
+    t.add_row("--bytecode", "BytecodeObfuscation",
+              "Compile to .pyc and marshal into exec loader")
+    t.add_row("--cpython",  "CPythonObfuscation",
+              "Transpile via Cython to native C binary launcher")
+    t.add_row("--strings",  "EncodeStrings",
+              "Replace string literals with bytes([...]).decode()")
+    t.add_row("--marshal",  "SimpleMarshal",
+              "Marshal code object into base64-wrapped exec loader")
+    console.print(t)
+    console.print()
+
+
+def print_layers_table():
+    t = Table(
+        title="[bold white]Protection Layers[/bold white]",
+        box=box.ROUNDED,
+        border_style="magenta",
+        header_style="bold magenta",
+        title_style="bold white",
+        show_lines=True,
+        expand=True,
+    )
+    t.add_column("Flag", style="bold yellow", justify="center", width=22)
+    t.add_column("Layer", style="white")
+    t.add_column("Description", style="dim white")
+    t.add_row("--expiry DATE",          "ExpiryTime",
+              "Script self-destructs after the given date")
+    t.add_row("--channel URL",          "EnterChannel",
+              "Requires user to join a Telegram channel to run")
+    t.add_row("--check-version",        "CheckVersion",
+              "Locks execution to the current Python version")
+    t.add_row("--pip PKG [PKG ...]",    "LibsInstaller",
+              "Auto-installs required pip packages on first run")
+    console.print(t)
+    console.print()
+
+
+def print_help():
+    print_banner()
+
+    usage = Panel(
+        "[bold white]pyprivate-obf[/bold white] [green]<input.py>[/green] "
+        "[cyan]\\[--bytecode|--cpython|--strings|--marshal][/cyan] "
+        "[yellow]\\[--expiry DATE][/yellow] [yellow]\\[--channel URL][/yellow] "
+        "[yellow]\\[--pip PKG ...][/yellow] [dim]\\[-o output.py][/dim]",
+        title="[bold white]Usage[/bold white]",
+        border_style="bright_black",
+        padding=(0, 2),
+    )
+    console.print(usage)
+    console.print()
+    print_encoders_table()
+    print_layers_table()
+
+    eg = Table.grid(padding=(0, 2))
+    eg.add_column(style="bold dim white", justify="right")
+    eg.add_column()
+    eg.add_row(
+        "Bytecode",
+        "[green]pyprivate-obf[/green] script.py [cyan]--bytecode[/cyan]",
+    )
+    eg.add_row(
+        "CPython",
+        "[green]pyprivate-obf[/green] script.py [cyan]--cpython[/cyan] [dim]-o out.py[/dim]",
+    )
+    eg.add_row(
+        "Strings",
+        "[green]pyprivate-obf[/green] script.py [cyan]--strings[/cyan]",
+    )
+    eg.add_row(
+        "Layered",
+        "[green]pyprivate-obf[/green] script.py [cyan]--marshal[/cyan] "
+        "[yellow]--expiry 2025-12-31 --channel https://t.me/psh_team[/yellow]",
+    )
+    eg.add_row(
+        "Interactive",
+        "[green]pyprivate-obf[/green] [cyan]--interactive[/cyan]",
+    )
+    console.print(Panel(eg, title="[bold white]Examples[/bold white]",
+                        border_style="bright_black", padding=(1, 2)))
+    console.print()
+
+
+def ask(prompt, default=None):
+    suffix = f" [dim]\\[{default}][/dim]" if default is not None else ""
+    while True:
+        try:
+            val = Prompt.ask(f"[bold yellow]?[/bold yellow] {prompt}{suffix}")
+        except (EOFError, KeyboardInterrupt):
+            console.print()
+            sys.exit(1)
+        val = val.strip()
+        if val == "" and default is not None:
+            return default
+        if val:
+            return val
+
+
+def ask_yn(prompt, default=False):
+    label = "[bold green]Y[/bold green]/n" if default else "y/[bold red]N[/bold red]"
+    while True:
+        try:
+            ans = Prompt.ask(
+                f"[bold yellow]?[/bold yellow] {prompt} ([{label}])",
+                default="y" if default else "n",
+            ).strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            console.print()
+            sys.exit(1)
+        if ans in ("y", "yes"):
+            return True
+        if ans in ("n", "no"):
+            return False
+        console.print("[red]  Please answer y or n.[/red]")
+
+
+def ask_int(prompt, default=1, lo=1, hi=20):
+    while True:
+        raw = ask(prompt, str(default))
+        try:
+            v = int(raw)
+            if lo <= v <= hi:
+                return v
+        except ValueError:
+            pass
+        console.print(f"[red]  Enter a number between {lo} and {hi}.[/red]")
+
+
+def ask_path(prompt):
+    while True:
+        p = ask(prompt)
+        p = os.path.expanduser(p.strip("'\" "))
+        if os.path.isfile(p):
+            return p
+        console.print(f"[red]  Not a file:[/red] [white]{p}[/white]")
+
+
+def parse_args():
+    p = argparse.ArgumentParser(
+        prog="pyprivate-obf",
+        description="Py Private v4.1.2 — Python source obfuscator.",
+    )
+    p.add_argument("input", nargs="?", help="path to the .py file to obfuscate")
+    p.add_argument("-o", "--output", help="output file (default: <input>.enc.py)")
+    p.add_argument("--encode-strings", action="store_true")
+    p.add_argument("--cpython",         action="store_true")
+    p.add_argument("--bytecode",        action="store_true")
+    p.add_argument("--marshal",         action="store_true")
+    p.add_argument("--layers", type=int, default=1)
+    p.add_argument("--re-check-version", action="store_true")
+    p.add_argument("--expiry")
+    p.add_argument("--expiry-message", default="This file has expired.")
+    p.add_argument("--pip", nargs="+", metavar="PKG")
+    p.add_argument("--check-version", action="store_true")
+    p.add_argument("--telegram-bot-token")
+    p.add_argument("--telegram-channel-id")
+    p.add_argument("--channel",  help="Telegram channel URL for EnterChannel guard")
+    p.add_argument("--interactive", action="store_true")
+    p.add_argument("--list", action="store_true", help="list all methods and layers")
+    return p.parse_args()
+
+
+def interactive_main():
+    print_banner()
+
+    console.print(Panel(
+        "[dim]Answer the prompts to configure your obfuscation job.[/dim]\n"
+        "[dim]Press Ctrl-C at any time to quit.[/dim]",
+        border_style="bright_black",
+        padding=(0, 2),
+    ))
+    console.print()
+
+    in_path = ask_path("Input [bold].py[/bold] file path")
+    size = os.path.getsize(in_path)
+    console.print(Panel(
+        f"[bold green]{in_path}[/bold green]  [dim]{size:,} bytes[/dim]",
+        title="[bold white]Loaded[/bold white]",
+        border_style="green",
+        padding=(0, 2),
+    ))
+    console.print()
+
+    console.print(Rule("[bold cyan]Encoding Method[/bold cyan]", style="cyan"))
+    console.print()
+    encode_strings_opt = ask_yn("Encode strings  [dim](bytes-decode trick)[/dim]", default=True)
+    bytecode_opt       = ask_yn("Bytecode obfuscation  [dim](marshal + opcode swap)[/dim]", default=True)
+    cpython_opt        = ask_yn("CPython obfuscation  [dim](Cython → C → gcc launcher)[/dim]", default=False)
+    marshal_opt        = ask_yn("Simple marshal  [dim](base64 exec loader)[/dim]", default=False)
+    layers             = ask_int("Marshal layers  [dim](1-20)[/dim]", default=1, lo=1, hi=20)
+    re_check_version   = ask_yn("Re-prepend check_version inside each layer", default=False)
+    console.print()
+
+    console.print(Rule("[bold magenta]Protection Layers[/bold magenta]", style="magenta"))
+    console.print()
+    extras = []
+
+    if ask_yn("Add [bold]EXPIRY[/bold] guard", default=False):
+        ts = ask("  Expiry date [dim](YYYY-MM-DD HH:MM:SS)[/dim]",
+                 datetime.now().replace(microsecond=0).isoformat(" "))
+        msg = ask("  Expiry message", "This file has expired.")
+        extras.append(ExpiryTime(time=ts + ".000000", message=msg))
+
+    if ask_yn("Add [bold]PIP INSTALLER[/bold] guard", default=False):
+        pkgs = ask("  Packages [dim](space-separated)[/dim]").split()
+        if pkgs:
+            extras.append(LibrariesInstaller(package_names=pkgs))
+
+    if ask_yn("Add [bold]CHECK VERSION[/bold] guard", default=False):
+        extras.append(CheckVersion())
+
+    if ask_yn("Add [bold]TELEGRAM CHANNEL[/bold] guard", default=False):
+        token = ask("  Bot token")
+        chan  = ask("  Channel id [dim](e.g. @my_channel)[/dim]")
+        extras.append(EnterChannel(bot_token=token, channel_id=chan))
+
+    console.print()
+
+    default_out = os.path.splitext(in_path)[0] + ".enc.py"
+    out_path = os.path.expanduser(ask("Output file path", default_out))
+
+    console.print()
+    console.print(Rule("[bold white]Building[/bold white]", style="bright_black"))
+    console.print()
+
+    with open(in_path, encoding="utf-8") as f:
+        source = f.read()
+
+    try:
+        new_source = build(
+            source,
+            extras=extras,
+            encode_strings_opt=encode_strings_opt,
+            cpython=cpython_opt,
+            bytecode=bytecode_opt or marshal_opt,
+            layers=layers,
+            re_check_version=re_check_version,
+        )
+    except ImportError as e:
+        console.print(Panel(
+            f"[red]{e}[/red]\n"
+            + ("[yellow]Install:[/yellow]  pip install cython  (and ensure gcc is in PATH)" if "Cython" in str(e) else ""),
+            title="[red]Import Error[/red]",
+            border_style="red",
+        ))
+        sys.exit(1)
+
+    with open(out_path, "w", encoding="utf-8") as f:
+        f.write(new_source)
+
+    result = Table.grid(padding=(0, 2))
+    result.add_column(style="bold dim white", justify="right")
+    result.add_column(style="bold white")
+    result.add_row("Output",  f"[bold green]{out_path}[/bold green]")
+    result.add_row("Size",    f"[white]{len(new_source):,} bytes[/white]")
+    if extras:
+        result.add_row("Layers", f"[magenta]{len(extras)} guard(s) applied[/magenta]")
+    console.print(Panel(result, title="[bold green]Done[/bold green]",
+                        border_style="green", padding=(1, 2)))
+    console.print()
+    console.print(f"  [dim]Run:[/dim]  [bold]python {out_path}[/bold]")
+    console.print()
+
+
+def cli_main():
+    args = parse_args()
+
+    if args.list:
+        print_banner()
+        print_encoders_table()
+        print_layers_table()
+        return
+
+    if args.interactive or args.input is None:
+        interactive_main()
+        return
+
+    print_banner()
+
+    if not os.path.isfile(args.input):
+        console.print(Panel(
+            f"[red]File not found:[/red] [white]{args.input}[/white]",
+            title="[red]Error[/red]",
+            border_style="red",
+        ))
+        sys.exit(1)
+
+    with open(args.input, encoding="utf-8") as f:
+        source = f.read()
+
+    extras = []
+    if args.expiry:
+        extras.append(ExpiryTime(time=args.expiry, message=args.expiry_message))
+    if args.pip:
+        extras.append(LibrariesInstaller(package_names=args.pip))
+    if args.check_version:
+        extras.append(CheckVersion())
+    if args.telegram_bot_token and args.telegram_channel_id:
+        extras.append(EnterChannel(
+            bot_token=args.telegram_bot_token,
+            channel_id=args.telegram_channel_id,
+        ))
+    if args.channel:
+        extras.append(EnterChannel(channel_url=args.channel))
+
+    use_marshal = args.marshal and not (args.cpython or args.bytecode)
+
+    info = Table.grid(padding=(0, 2))
+    info.add_column(style="bold dim white", justify="right")
+    info.add_column(style="bold white")
+    info.add_row("Input",  f"[green]{args.input}[/green]")
+    info.add_row("Method",
+        "[cyan]cpython[/cyan]"  if args.cpython  else
+        "[cyan]bytecode[/cyan]" if args.bytecode else
+        "[cyan]strings[/cyan]"  if args.encode_strings else
+        "[cyan]marshal[/cyan]"  if use_marshal else "[dim]default (marshal)[/dim]"
+    )
+    if extras:
+        info.add_row("Guards", f"[magenta]{', '.join(type(e).__name__ for e in extras)}[/magenta]")
+    console.print(Panel(info, title="[bold white]Job[/bold white]",
+                        border_style="cyan", padding=(1, 2)))
+    console.print()
+
+    console.print("[dim]  Encoding...[/dim]")
+
+    output_source = build(
+        source,
+        extras=extras,
+        encode_strings_opt=args.encode_strings,
+        cpython=args.cpython,
+        bytecode=args.bytecode,
+        layers=args.layers,
+        re_check_version=args.re_check_version,
+    )
+
+    out = args.output or (os.path.splitext(args.input)[0] + ".enc.py")
+    with open(out, "w", encoding="utf-8") as f:
+        f.write(output_source)
+
+    done = Table.grid(padding=(0, 2))
+    done.add_column(style="bold dim white", justify="right")
+    done.add_column(style="bold white")
+    done.add_row("Written", f"[bold green]{out}[/bold green]")
+    done.add_row("Size",    f"[white]{len(output_source):,} bytes[/white]")
+    console.print(Panel(done, title="[bold green]Done[/bold green]",
+                        border_style="green", padding=(1, 2)))
+    console.print()
+
+
+def main():
+    try:
+        cli_main()
+    except KeyboardInterrupt:
+        console.print()
+        console.print("[dim]Aborted.[/dim]")
+        sys.exit(130)
+
+
+if __name__ == "__main__":
+    main()

pyprivate_obf/encoding_methods/__init__.py

@@ -0,0 +1,5 @@
+from .encode_strings import encode_strings
+from .bytecode_obfuscation import bytecode_obfuscation
+from .simple_marshal import simple_marshal
+
+__all__ = ["encode_strings", "bytecode_obfuscation", "simple_marshal", "cpython_obfuscation"]

pyprivate_obf/encoding_methods/bytecode_obfuscation.py

@@ -0,0 +1,83 @@
+import dis
+import marshal
+
+
+FAKE_CODE: str = """
+foo = False
+if foo:
+    bar = 1/0
+"""
+
+
+HEX_CODE: str = "6401" "6402" "1b00" "5a01"
+NEW_HEX_CODE: str = "6401" "6402" "8421" "5a01"
+
+
+def _swap_pattern():
+    LOAD_CONST    = dis.opmap.get("LOAD_CONST")
+    STORE_NAME    = dis.opmap.get("STORE_NAME")
+    MAKE_FUNCTION = dis.opmap.get("MAKE_FUNCTION")
+    if None in (LOAD_CONST, STORE_NAME, MAKE_FUNCTION):
+        return None, None
+
+    code = compile(FAKE_CODE, "<f>", "exec")
+    bc   = code.co_code
+    consts = code.co_consts
+    names  = code.co_names
+
+
+    def _find_int(seq, n):
+        for i, v in enumerate(seq):
+            if type(v) is int and v == n:
+                return i
+        return -1
+
+    try:
+        i_one  = _find_int(consts, 1)
+        i_zero = _find_int(consts, 0)
+        i_bar  = names.index("bar")
+        if i_one < 0 or i_zero < 0:
+            return None, None
+    except ValueError:
+        return None, None
+
+    needle      = bytes([LOAD_CONST, i_one, LOAD_CONST, i_zero])
+    store_name  = bytes([STORE_NAME, i_bar])
+
+    start = bc.find(needle)
+    if start < 0:
+        return None, None
+
+
+    end = bc.find(store_name, start + len(needle))
+    if end < 0:
+        return None, None
+
+    old = bytes(bc[start: end + len(store_name)])
+
+
+    middle_len = end - (start + len(needle))
+    if middle_len < 2:
+        return None, None
+    new_middle = bytes([MAKE_FUNCTION, 0x21]) + b"\x00" * (middle_len - 2)
+    new = needle + new_middle + store_name
+
+    if len(old) != len(new):
+        return None, None
+    return old, new
+
+
+def bytecode_obfuscation(source: str) -> str:
+    bytecode = marshal.dumps(compile(FAKE_CODE + source, "string", "exec"))
+
+    old, new = _swap_pattern()
+    if old is not None and old in bytecode:
+        bytecode = bytecode.replace(old, new)
+
+    return f"import marshal\nexec(marshal.loads({bytecode}))"
+
+
+if __name__ == "__main__":
+    import sys
+    src = open(sys.argv[1]).read()
+    sys.stdout.write(bytecode_obfuscation(src))

pyprivate_obf/encoding_methods/cpython_obfuscation.py

@@ -0,0 +1,111 @@
+import io
+import os
+import re
+from contextlib import redirect_stderr
+from datetime import datetime
+
+from Cython.Compiler.CmdLine import parse_command_line
+from Cython.Compiler import Main
+
+
+def C_SOURCE(c_source: str) -> str:
+    return r"""
+import os
+import sys
+
+PSH_TEAM_KEY = "بخ 👀"
+
+EXECUTE_FILE = ".PY_PRIVATE/%s"
+PREFIX = sys.prefix
+EXPORT_PYTHONHOME = 'export PYTHONHOME='+PREFIX
+EXPORT_PYTHON_EXECUTABLE = 'export PYTHON_EXECUTABLE='+sys.executable
+
+RUN = "./"+EXECUTE_FILE
+
+if os.path.isfile(EXECUTE_FILE):
+    os.system(EXPORT_PYTHONHOME+" && "+EXPORT_PYTHON_EXECUTABLE+" && "+RUN)
+    exit(0)
+
+C_SOURCE = r'''%s'''
+C_FILE = ".py_private.c"
+PYTHON_VERSION = ".".join(sys.version.split(" ")[0].split(".")[:-1])
+COMPILE_FILE = (
+    'gcc -I' +
+    PREFIX +
+    '/include/python' +
+    PYTHON_VERSION +
+    ' -o ' +
+    EXECUTE_FILE +
+    ' ' +
+    C_FILE +
+    ' -L' +
+    PREFIX +
+    '/lib -lpython' +
+    PYTHON_VERSION
+)
+
+
+with open(C_FILE, "w") as f:
+    f.write(C_SOURCE)
+
+os.makedirs(os.path.dirname(EXECUTE_FILE), exist_ok=True)
+os.system(EXPORT_PYTHONHOME+" && "+EXPORT_PYTHON_EXECUTABLE+" && "+COMPILE_FILE+" && "+RUN)
+
+os.remove(C_FILE)
+""" % (datetime.now().strftime("%Y%m%d%H%M%S%f")[:-3], c_source)
+
+
+def _compile_single(input_file: str, option) -> None:
+    try:
+        Main.compile_single(input_file, option)
+    except TypeError:
+
+        Main.compile_single(input_file, option, full_module_name=None)
+
+
+def cpython_obfuscation(
+    source: str,
+    input_file: str = "input.py",
+    output_file: str = "input.c",
+) -> str:
+
+    with open(input_file, "w") as f:
+        f.write(source)
+
+
+    option, _ = parse_command_line(
+        ["-o", output_file, "-3", "--embed", input_file, "-f"]
+    )
+
+
+    f = io.StringIO()
+    with redirect_stderr(f):
+        _compile_single(input_file, option)
+    errors = f.getvalue()
+    if errors.strip() != "":
+        print(errors)
+
+
+    comment_pattern = re.compile(
+        r"/\*\s*" + f'"{input_file}"' + r"\s*.*?\*/", re.DOTALL
+    )
+    cython_header_pattern = re.compile(
+        r"/\*\s*Generated by Cython\s+[\d.A-Za-z+-]+\s*\*/"
+    )
+    with open(output_file, "r") as f:
+        c_source = f.read()
+    c_source = re.sub(comment_pattern, "", c_source)
+    c_source = re.sub(cython_header_pattern, "", c_source).strip()
+
+
+    os.remove(input_file)
+    os.remove(output_file)
+
+
+    return C_SOURCE(c_source)
+
+
+if __name__ == "__main__":
+    import sys
+    src = open(sys.argv[1]).read()
+    sys.stdout.write(cpython_obfuscation(src))