auto-scrambling-python-opcodes 0.1.0__py3-none-any.whl

auto_scrambling_python_opcodes-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: auto-scrambling-python-opcodes
+Version: 0.1.0
+Summary: 一个适用于Python 3.13的自动混淆opcode脚本
+Author-email: ExMC-Github <2545869165@qq.com>
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+### Auto-Scrambling-Python-Opcodes
+###### Made By ExRFy
+------
+
+<img src="https://img.shields.io/badge/Python-3.13.8-blue">
+
+<img src="https://img.shields.io/badge/使用提示-生产环境建议使用git备份-red">
+
+------
+
+目录
+* [介绍](#介绍)
+* [使用](#使用)
+
+<p id="介绍"></p>
+
+------
+
+# 介绍
+
+这是一款使用python的Python 3.13 opcodes混淆工具
+
+能让opcode的顺序完全重新排列，如
+```
+Examples (name: old -> new):
+    CACHE: 0 -> 208
+    NOP: 30 -> 105
+    LOAD_CONST: 83 -> 103
+    POP_TOP: 32 -> 72
+    RESUME: 149 -> 138
+    INSTRUMENTED_LINE: 254 -> 27
+    JUMP: 256 -> 265
+    STORE_FAST_MAYBE_NULL: 267 -> 256
+```
+
+这种的
+
+<p id="使用"></p>
+
+------
+
+# 使用
+
+使用方法：
+
+1. 找一个3.13的cpython仓库，download下来
+
+2. 运行脚本，第一个参数填仓库目录
+
+可选择项：
+
+  --seed 该参数能指定随机数种子，若无该参数则反转opcode

auto_scrambling_python_opcodes-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+auto_scrambling_python_opcodes-0.1.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+scramble_313_opcodes/__init__.py,sha256=q21gi3THKM24Atvi-moP_txfLNAua1fFrOLZihKBZk4,30
+scramble_313_opcodes/scramble_opcodes.py,sha256=O8D2yLoK74lcjMXl0VMFAXIKEn2Q8FEU_Gr3dSzdu48,12116
+auto_scrambling_python_opcodes-0.1.0.dist-info/METADATA,sha256=-x5JsXp30OgmL9leBeriovSe2Zz3NSW4UEsg6gU05vc,1460
+auto_scrambling_python_opcodes-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+auto_scrambling_python_opcodes-0.1.0.dist-info/entry_points.txt,sha256=DYgvVKmMxj6nRjQNSNqEzO1xA7zrVqpndLCbJB2mPQc,62
+auto_scrambling_python_opcodes-0.1.0.dist-info/top_level.txt,sha256=l-VIYPJ1UT25UtsxTnmvlNz3aRq7HLzD7LXdP7Qrp5M,21
+auto_scrambling_python_opcodes-0.1.0.dist-info/RECORD,,

auto_scrambling_python_opcodes-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

auto_scrambling_python_opcodes-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+scramble-opcodes = scramble_opcodes.py:main

auto_scrambling_python_opcodes-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

auto_scrambling_python_opcodes-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+scramble_313_opcodes

scramble_313_opcodes/__init__.py

@@ -0,0 +1 @@
+from scramble_opcodes import *

scramble_313_opcodes/scramble_opcodes.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""
+CPython 3.13 Opcode Scrambling Script
+
+Scrambles all opcode values in a CPython 3.13 source tree so that the
+bytecode appears fully randomized (e.g., CACHE is no longer 0).
+
+Two scrambling modes:
+  1. Reversal (default): new_value = 254 - old_value (deterministic)
+  2. Random shuffle (--seed N): uses a seeded random permutation
+
+Usage:
+    python scramble_opcodes.py <cpython_source_root>
+    python scramble_opcodes.py <cpython_source_root> --seed 42
+    python scramble_opcodes.py <cpython_source_root> --seed 12345
+"""
+
+import os
+import re
+import sys
+import random
+
+
+def parse_opcode_ids_h(filepath):
+    """Parse Include/opcode_ids.h to extract opcode name -> value mappings."""
+    opcodes = {}
+    with open(filepath, 'r', encoding='utf-8') as f:
+        for line in f:
+            m = re.match(r'#define\s+(\w+)\s+(\d+)', line.strip())
+            if m:
+                name = m.group(1)
+                value = int(m.group(2))
+                if name in ('HAVE_ARGUMENT', 'MIN_INSTRUMENTED_OPCODE', 'NB_OPARG_LAST'):
+                    continue
+                if name.startswith('NB_'):
+                    continue
+                opcodes[name] = value
+    return opcodes
+
+
+def parse_opcode_metadata_py(filepath):
+    """Parse Lib/_opcode_metadata.py to extract opmap and specialized_opmap."""
+    namespace = {}
+    with open(filepath, 'r', encoding='utf-8') as f:
+        content = f.read()
+    exec(content, namespace)
+    return {
+        'opmap': namespace['opmap'],
+        '_specialized_opmap': namespace['_specialized_opmap'],
+        '_specializations': namespace['_specializations'],
+        'HAVE_ARGUMENT': namespace['HAVE_ARGUMENT'],
+        'MIN_INSTRUMENTED_OPCODE': namespace['MIN_INSTRUMENTED_OPCODE'],
+    }
+
+
+def compute_reversed_mapping(opcodes):
+    """Reversal: real opcodes 0-254 -> 254-0, pseudo 256-267 -> 267-256."""
+    MAX_REAL = 254
+    PSEUDO_BASE = 256
+    PSEUDO_MAX = 267
+    new_opcodes = {}
+    for name, value in opcodes.items():
+        if value <= MAX_REAL:
+            new_opcodes[name] = MAX_REAL - value
+        elif value >= PSEUDO_BASE:
+            new_opcodes[name] = (PSEUDO_BASE + PSEUDO_MAX) - value
+        else:
+            raise ValueError(f"Unexpected opcode value {value} for {name}")
+    return new_opcodes
+
+
+def compute_random_mapping(opcodes, seed):
+    """Random shuffle: permute real opcodes within 0-254, pseudo within 256-267."""
+    MAX_REAL = 254
+    PSEUDO_BASE = 256
+    PSEUDO_MAX = 267
+
+    rng = random.Random(seed)
+
+    # Separate real and pseudo opcodes
+    real_names = [n for n, v in opcodes.items() if v <= MAX_REAL]
+    pseudo_names = [n for n, v in opcodes.items() if v >= PSEUDO_BASE]
+
+    # Shuffle target values
+    real_values = list(range(MAX_REAL + 1))
+    rng.shuffle(real_values)
+    pseudo_values = list(range(PSEUDO_BASE, PSEUDO_MAX + 1))
+    rng.shuffle(pseudo_values)
+
+    new_opcodes = {}
+    for name, value in opcodes.items():
+        if value <= MAX_REAL:
+            idx = [n for n, v in opcodes.items() if v <= MAX_REAL].index(name)
+            new_opcodes[name] = real_values[idx]
+        elif value >= PSEUDO_BASE:
+            idx = [n for n, v in opcodes.items() if v >= PSEUDO_BASE].index(name)
+            new_opcodes[name] = pseudo_values[idx]
+        else:
+            raise ValueError(f"Unexpected opcode value {value} for {name}")
+    return new_opcodes
+
+
+def write_opcode_ids_h(filepath, new_opcodes):
+    """Write updated Include/opcode_ids.h with new opcode values."""
+    # Re-parse to get original values for HAVE_ARGUMENT calculation
+    original_opcodes = {}
+    with open(filepath, 'r', encoding='utf-8') as f:
+        for line in f:
+            m = re.match(r'#define\s+(\w+)\s+(\d+)', line.strip())
+            if m:
+                name = m.group(1)
+                value = int(m.group(2))
+                if name not in ('HAVE_ARGUMENT', 'MIN_INSTRUMENTED_OPCODE',
+                                'NB_OPARG_LAST') and not name.startswith('NB_'):
+                    original_opcodes[name] = value
+
+    orig_have_argument = 44
+    min_has_arg = 255
+    for name, orig_val in original_opcodes.items():
+        if orig_val >= orig_have_argument:
+            new_val = new_opcodes[name]
+            if new_val < min_has_arg:
+                min_has_arg = new_val
+
+    min_instrumented = 255
+    for name, orig_val in original_opcodes.items():
+        if name.startswith('INSTRUMENTED_'):
+            new_val = new_opcodes[name]
+            if new_val < min_instrumented:
+                min_instrumented = new_val
+
+    new_lines = []
+    with open(filepath, 'r', encoding='utf-8') as f:
+        for line in f:
+            stripped = line.strip()
+            m = re.match(r'#define\s+(\w+)\s+(\d+)', stripped)
+            if m:
+                name = m.group(1)
+                if name in ('HAVE_ARGUMENT',):
+                    new_lines.append(f'#define HAVE_ARGUMENT'
+                                     f'{"".ljust(36)}{min_has_arg}\n')
+                    continue
+                elif name in ('MIN_INSTRUMENTED_OPCODE',):
+                    new_lines.append(f'#define MIN_INSTRUMENTED_OPCODE'
+                                     f'{"".ljust(24)}{min_instrumented}\n')
+                    continue
+                elif name.startswith('NB_') or name == 'NB_OPARG_LAST':
+                    new_lines.append(line)
+                    continue
+                elif name in new_opcodes:
+                    padding = 40 - len(name) - 9
+                    if padding < 1:
+                        padding = 1
+                    new_lines.append(f'#define {name}'
+                                     f'{" " * padding}{new_opcodes[name]}\n')
+                    continue
+            new_lines.append(line)
+
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.writelines(new_lines)
+
+
+def write_opcode_metadata_py(filepath, new_opcodes, metadata):
+    """Write updated Lib/_opcode_metadata.py with new opcode values."""
+    new_opmap = {}
+    for name, value in metadata['opmap'].items():
+        if name in new_opcodes:
+            new_opmap[name] = new_opcodes[name]
+        else:
+            new_opmap[name] = value
+
+    new_specialized_opmap = {}
+    for name, value in metadata['_specialized_opmap'].items():
+        if name in new_opcodes:
+            new_specialized_opmap[name] = new_opcodes[name]
+        else:
+            new_specialized_opmap[name] = value
+
+    orig_have_argument = metadata['HAVE_ARGUMENT']
+    min_has_arg = 255
+    for name, orig_val in metadata['opmap'].items():
+        if orig_val >= orig_have_argument:
+            new_val = new_opcodes.get(name, orig_val)
+            if new_val < min_has_arg:
+                min_has_arg = new_val
+
+    min_instrumented = 255
+    for name, orig_val in metadata['opmap'].items():
+        if name.startswith('INSTRUMENTED_'):
+            new_val = new_opcodes.get(name, orig_val)
+            if new_val < min_instrumented:
+                min_instrumented = new_val
+
+    lines = []
+    lines.append('# This file is generated by Tools/cases_generator/py_metadata_generator.py')
+    lines.append('# from:')
+    lines.append('#   Python/bytecodes.c')
+    lines.append('# Do not edit!')
+    lines.append('')
+
+    lines.append('_specializations = {')
+    for parent, children in metadata['_specializations'].items():
+        lines.append(f'    "{parent}": [')
+        for child in children:
+            lines.append(f'        "{child}",')
+        lines.append('    ],')
+    lines.append('}')
+    lines.append('')
+
+    lines.append('_specialized_opmap = {')
+    for name in sorted(new_specialized_opmap.keys(), key=lambda x: new_specialized_opmap[x]):
+        lines.append(f"    '{name}': {new_specialized_opmap[name]},")
+    lines.append('}')
+    lines.append('')
+
+    lines.append('opmap = {')
+    for name in sorted(new_opmap.keys(), key=lambda x: new_opmap[x]):
+        lines.append(f"    '{name}': {new_opmap[name]},")
+    lines.append('}')
+    lines.append('')
+
+    lines.append(f'HAVE_ARGUMENT = {min_has_arg}')
+    lines.append(f'MIN_INSTRUMENTED_OPCODE = {min_instrumented}')
+    lines.append('')
+
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write('\n'.join(lines))
+
+
+def update_extra_cases(filepath, new_opcodes):
+    """Update EXTRA_CASES in pycore_opcode_metadata.h with new unused values."""
+    used_values = set()
+    for name, value in new_opcodes.items():
+        if value <= 254:
+            used_values.add(value)
+
+    gaps = []
+    for v in range(256):
+        if v not in used_values:
+            gaps.append(v)
+
+    with open(filepath, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    extra_cases_lines = []
+    for v in gaps:
+        extra_cases_lines.append(f'    case {v}: \\')
+
+    extra_cases_str = '#define EXTRA_CASES \\\n' + '\n'.join(extra_cases_lines)
+    if extra_cases_lines:
+        extra_cases_str = extra_cases_str.rstrip(' \\')
+        extra_cases_str += '\n        ;'
+
+    pattern = r'#define EXTRA_CASES\s*\\[^;]*;'
+    content = re.sub(pattern, extra_cases_str, content, flags=re.DOTALL)
+
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(
+        description="Scramble CPython 3.13 opcode values")
+    parser.add_argument("source_root", help="CPython source root directory")
+    parser.add_argument("--seed", type=int, default=None,
+                        help="Random seed for shuffle (omit for deterministic reversal)")
+    args = parser.parse_args()
+
+    source_root = os.path.abspath(args.source_root)
+
+    opcode_ids_h = os.path.join(source_root, 'Include', 'opcode_ids.h')
+    opcode_metadata_py = os.path.join(source_root, 'Lib', '_opcode_metadata.py')
+    opcode_metadata_h = os.path.join(source_root, 'Include', 'internal',
+                                      'pycore_opcode_metadata.h')
+
+    for f in [opcode_ids_h, opcode_metadata_py, opcode_metadata_h]:
+        if not os.path.exists(f):
+            print(f"Error: {f} not found. Is this a CPython 3.13 source tree?")
+            sys.exit(1)
+
+    mode = "random shuffle" if args.seed is not None else "reversal"
+    print(f"=== CPython 3.13 Opcode Scrambling Script (mode: {mode}) ===\n")
+
+    print("[1/4] Parsing current opcode definitions...")
+    opcodes = parse_opcode_ids_h(opcode_ids_h)
+    print(f"  Found {len(opcodes)} opcodes")
+
+    print("[2/4] Computing new opcode mapping...")
+    if args.seed is not None:
+        new_opcodes = compute_random_mapping(opcodes, args.seed)
+        print(f"  Using random seed: {args.seed}")
+    else:
+        new_opcodes = compute_reversed_mapping(opcodes)
+        print("  Using reversal (default)")
+
+    examples = ['CACHE', 'NOP', 'LOAD_CONST', 'POP_TOP', 'RESUME',
+                'INSTRUMENTED_LINE', 'JUMP', 'STORE_FAST_MAYBE_NULL']
+    print("  Examples (name: old -> new):")
+    for name in examples:
+        if name in opcodes:
+            print(f"    {name}: {opcodes[name]} -> {new_opcodes[name]}")
+
+    print("[3/4] Updating header and metadata files...")
+    write_opcode_ids_h(opcode_ids_h, new_opcodes)
+    print(f"  Updated {opcode_ids_h}")
+
+    metadata = parse_opcode_metadata_py(opcode_metadata_py)
+    write_opcode_metadata_py(opcode_metadata_py, new_opcodes, metadata)
+    print(f"  Updated {opcode_metadata_py}")
+
+    update_extra_cases(opcode_metadata_h, new_opcodes)
+    print(f"  Updated {opcode_metadata_h}")
+
+    print("\n=== Done! ===")
+    print("Opcode values have been scrambled. The modified Python interpreter")
+    print("will use completely different bytecode values, making .pyc files")
+    print("incompatible with standard Python 3.13.")
+    print("\nYou need to rebuild CPython for changes to take effect.")
+
+
+if __name__ == '__main__':
+    main()