pyarmor 2.5.2__tar.gz → 9.0.7__tar.gz

pyarmor-9.0.7/MANIFEST.in

@@ -0,0 +1,4 @@
+# recursive-include docs/examples *.py *.xml README* LICENSE
+# include docs/user-guide.html docs/rationale.html
+# include LICENSE LICENSE-ZH
+exclude src/pyarmor-deprecated.py src/pyimcore.py

pyarmor-9.0.7/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 1.1
+Name: pyarmor
+Version: 9.0.7
+Summary: A tool used to obfuscate python scripts, bind obfuscated scripts to fixed machine or expire obfuscated scripts.
+Home-page: https://github.com/dashingsoft/pyarmor
+Author: Jondy Zhao
+Author-email: pyarmor@163.com
+License: Free To Use But Restricted
+Description: Protect Python Scripts By Pyarmor
+        =================================
+        
+        Pyarmor is a command line tool used to obfuscate python scripts, bind obfuscated scripts to fixed machine or expire obfuscated scripts.
+        
+        Key Features
+        ------------
+        
+        * The obfuscated scritpt is still a normal `.py` script, in most of cases the original python scripts can be replaced with obfuscated scripts seamlessly.
+        * Provide many ways to obfuscate the scripts to balance security and performance
+        * Rename functions/methods/classes/variables/arguments, irreversible obfuscation
+        * Convert part of Python functions to C function, compile to binary by high optimize option, irreversible obfuscation
+        * Bind obfuscated scripts to fixed machine or expire obfuscted scripts
+        * Protect obfuscated scripts by Themida (Only for Windows)
+        
+        Support Platforms
+        -----------------
+        
+        * Python 3.7~3.13
+        * Windows
+        * Many linuxs, include embedded systems
+        * Apple Intel and Apple Silicon
+        
+        Quick Start
+        -----------
+        
+        Install::
+        
+            pip install pyarmor
+        
+        Obfuscate the script `foo.py`::
+        
+            pyarmor gen foo.py
+        
+        This command generates an obfuscated script `dist/foo.py` like this:
+        
+        .. code:: python
+        
+            from pyarmor_runtime import __pyarmor__
+            __pyarmor__(__name__, __file__, b'\x28\x83\x20\x58....')
+        
+        Run it::
+        
+            python dist/foo.py
+        
+        More Resources
+        --------------
+        
+        - `Home <https://github.com/dashingsoft/pyarmor>`_
+        - `Website <http://pyarmor.dashingsoft.com>`_
+        - `中文网站 <http://pyarmor.dashingsoft.com/index-zh.html>`_
+        - `Issues <https://github.com/dashingsoft/pyarmor/issues>`_
+        - `Documentation <https://pyarmor.readthedocs.io/>`_
+        
+Keywords: protect obfuscate encrypt obfuscation distribute
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Utilities
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Software Distribution
+Classifier: License :: Free To Use But Restricted
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3

pyarmor-9.0.7/README.md

@@ -0,0 +1,115 @@
+# Pyarmor
+
+Pyarmor is a command-line tool designed for obfuscating Python scripts, binding obfuscated scripts to specific machines, and setting expiration dates for obfuscated scripts.
+
+## Key Features
+
+- **Seamless Replacement**: Obfuscated scripts remain as standard `.py` files, allowing them to seamlessly replace the original Python scripts in most cases.
+- **Balanced Obfuscation**: Offers multiple ways to obfuscate scripts to balance security and performance.
+- **Irreversible Obfuscation**: Renames functions, methods, classes, variables, and arguments.
+- **C Function Conversion**: Converts some Python functions to C functions and compiles them into machine instructions using high optimization options for irreversible obfuscation.
+- **Script Binding**: Binds obfuscated scripts to specific machines or sets expiration dates for obfuscated scripts.
+- **Themida Protection**: Protects obfuscated scripts using Themida (Windows only).
+
+## Supported Platforms
+
+- Python 2 and Python 3[^1]
+- Windows
+- Various Linux distributions, including embedded systems and Raspberry Pi
+- Apple Intel and Apple Silicon
+- Supported architectures: x86_64, aarch64, armv7, etc.[^2]
+
+For more information, check out the [Pyarmor Environments][encironments].
+
+[^1]: Some features may be exclusive to Python 3.
+[^2]: Some features may be exclusive to specific architectures.
+
+[encironments]: https://pyarmor.readthedocs.io/en/stable/reference/environments.html
+
+## Quick start
+
+1. **Install Pyarmor**:
+```shell
+pip install pyarmor
+```
+
+2. **Obfuscate the `foo.py` script**:
+```shell
+pyarmor gen foo.py
+```
+
+This command generates an obfuscated script like this at `dist/foo.py`:
+
+```python
+from pyarmor_runtime import __pyarmor__
+__pyarmor__(__name__, __file__, b'\x28\x83\x20\x58....')
+```
+
+3. **Run the obfuscated script**:
+```shell
+python dist/foo.py
+```
+
+For more information, check out the [getting started tutorial][tutorial].
+
+[tutorial]: https://pyarmor.readthedocs.io/en/stable/tutorial/getting-started.html
+
+## License
+
+Pyarmor is published as shareware. The free trial version never expires, but has some limitations.
+
+Refer to [Pyarmor licenses][licenses] for information on license types, features, limitations, and purchasing a Pyarmor license.
+
+Please read the [Pyarmor EULA](LICENSE).
+
+[licenses]: https://pyarmor.readthedocs.io/en/latest/licenses.html
+
+## Getting Help
+
+1. **Consult the [Pyarmor Documentation][doc].**
+2. **Check the [FAQ][faq] for answers to common questions.**
+3. **Try the documentation [index][genindex] or the [detailed table of contents][mastertoc].**
+4. **If you still can't find the information you need, see [asking questions on GitHub][asking].**
+5. **[Report bugs][issues] following the issue template.**
+6. **For business and security inquiries, send an email to <pyarmor@163.com>.**
+
+There are also some third-party learn platforms (not Pyarmor offical)
+
+- **[Ask Pyarmor Guru][gurubase], it is a Pyarmor-focused AI to answer your questions**
+
+[faq]: https://pyarmor.readthedocs.io/en/latest/questions.html
+[issues]: https://github.com/dashingsoft/pyarmor/issues
+[genindex]: https://pyarmor.readthedocs.io/en/stable/genindex.html
+[mastertoc]: https://pyarmor.readthedocs.io/en/stable/index.html#table-of-contents
+[asking]: https://pyarmor.readthedocs.io/en/latest/questions.html#asking-questions-in-github
+[doc]: https://pyarmor.readthedocs.io/
+[gurubase]: https://gurubase.io/g/pyarmor
+
+## Resources
+
+* [Website](https://pyarmor.dashingsoft.com)
+* [Documentation][doc]
+* [Documentation 8.x](https://pyarmor.readthedocs.io/en/v8.5.12/)
+* [Documentation 7.x](https://pyarmor.readthedocs.io/en/v7.7/)
+
+中文资源
+
+* [Pyarmor 网站](https://pyarmor.dashingsoft.com/index-zh.html)
+* [Pyarmor 在线文档](https://pyarmor.readthedocs.io/zh/latest/)
+* [Pyarmor 8.x 在线文档](https://pyarmor.readthedocs.io/zh/v8.5.12/)
+* [Pyarmor 7.x 在线文档](https://pyarmor.readthedocs.io/zh/v7.x/)
+
+## Changelog
+
+Each major version comes with a separate changelog file, detailing fixed issues, new features, and compatibility issues between different versions.
+
+Make sure to read the changelog carefully before upgrading Pyarmor:
+
+- [Pyarmor 8.x Changelog](docs/ChangeLogs.8)
+- [Pyarmor 9.x Changelog](docs/ChangeLogs.9)
+
+**Full changelogs** at [releases][releases]
+
+**Upcoming features** at [Pyarmor Release Plan](docs/ReleasePlan.md)
+
+[releases]: https://github.com/dashingsoft/pyarmor/releases

pyarmor-9.0.7/pyarmor/README.rst

@@ -0,0 +1,53 @@
+Protect Python Scripts By Pyarmor
+=================================
+
+Pyarmor is a command line tool used to obfuscate python scripts, bind obfuscated scripts to fixed machine or expire obfuscated scripts.
+
+Key Features
+------------
+
+* The obfuscated scritpt is still a normal `.py` script, in most of cases the original python scripts can be replaced with obfuscated scripts seamlessly.
+* Provide many ways to obfuscate the scripts to balance security and performance
+* Rename functions/methods/classes/variables/arguments, irreversible obfuscation
+* Convert part of Python functions to C function, compile to binary by high optimize option, irreversible obfuscation
+* Bind obfuscated scripts to fixed machine or expire obfuscted scripts
+* Protect obfuscated scripts by Themida (Only for Windows)
+
+Support Platforms
+-----------------
+
+* Python 3.7~3.13
+* Windows
+* Many linuxs, include embedded systems
+* Apple Intel and Apple Silicon
+
+Quick Start
+-----------
+
+Install::
+
+    pip install pyarmor
+
+Obfuscate the script `foo.py`::
+
+    pyarmor gen foo.py
+
+This command generates an obfuscated script `dist/foo.py` like this:
+
+.. code:: python
+
+    from pyarmor_runtime import __pyarmor__
+    __pyarmor__(__name__, __file__, b'\x28\x83\x20\x58....')
+
+Run it::
+
+    python dist/foo.py
+
+More Resources
+--------------
+
+- `Home <https://github.com/dashingsoft/pyarmor>`_
+- `Website <http://pyarmor.dashingsoft.com>`_
+- `中文网站 <http://pyarmor.dashingsoft.com/index-zh.html>`_
+- `Issues <https://github.com/dashingsoft/pyarmor/issues>`_
+- `Documentation <https://pyarmor.readthedocs.io/>`_

pyarmor-9.0.7/pyarmor/__init__.py

@@ -0,0 +1,4 @@
+# Package pyarmor
+import sys
+from os.path import abspath, dirname
+sys.path.insert(0, abspath(dirname(__file__)))

pyarmor-9.0.7/pyarmor/benchmark.py

@@ -0,0 +1,382 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#############################################################
+#                                                           #
+#      Copyright @ 2013 - 2017 Dashingsoft corp.            #
+#      All rights reserved.                                 #
+#                                                           #
+#      pyarmor                                              #
+#                                                           #
+#      Version: 1.7.0 -                                     #
+#                                                           #
+#############################################################
+#
+#
+#  @File: benchmark.py
+#
+#  @Author: Jondy Zhao(jondy.zhao@gmail.com)
+#
+#  @Create Date: 2017/11/21
+#
+#  @Description:
+#
+#   Check performance of pyarmor.
+#
+import logging
+import os
+import shutil
+import sys
+import subprocess
+import time
+
+from ctypes import c_int, c_void_p, py_object, pythonapi, PYFUNCTYPE
+
+import pytransform
+
+OBF_MODULE_MODE = 'none', 'des', 'aes'
+OBF_CODE_MODE = 'none', 'fast', 'aes', 'wrap'
+
+PYARMOR_PATH = os.path.dirname(__file__)
+PYARMOR = 'pyarmor.py'
+
+
+def make_test_script(filename):
+    lines = [
+        'def empty():',
+        '  return 0',
+        '',
+        'def call_1k_function(n):',
+        '  for i in range(n):',
+        '    one_thousand()',
+        '',
+        'def call_10k_function(n):',
+        '  for i in range(n):',
+        '    ten_thousand()',
+        '',
+        'def one_thousand():',
+        '  if True:',
+        '    i = 0',
+    ]
+    lines.extend(['    i += 1'] * 100)
+    lines.append('\n  return 1000\n')
+    lines.extend(['def ten_thousand():',
+                  '  if True:',
+                  '    i = 0'])
+    lines.extend(['    i += 1'] * 1000)
+    lines.append('\n  return 10000\n')
+
+    with open(filename, 'wb') as f:
+        f.write('\n'.join(lines).encode())
+
+
+def call_pyarmor(args):
+    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    p.wait()
+
+
+def obffuscate_scripts(output, filename,
+                       mod_mode, code_mode, wrap_mode, adv_mode):
+    project = os.path.join(output, 'project')
+    if os.path.exists(project):
+        shutil.rmtree(project)
+
+    args = [sys.executable, PYARMOR, 'init', '--src', output,
+            '--entry', filename, project]
+    call_pyarmor(args)
+
+    args = [sys.executable, PYARMOR, 'config',
+            '--manifest', 'include %s' % filename,
+            '--obf-mod', mod_mode,
+            '--obf-code', code_mode,
+            '--wrap-mode', wrap_mode,
+            '--advanced', adv_mode,
+            '--restrict-mode', '0',
+            '--package-runtime', '0',
+            project]
+    call_pyarmor(args)
+
+    args = [sys.executable, PYARMOR, 'build', '-B', project]
+    call_pyarmor(args)
+
+    for s in os.listdir(os.path.join(project, 'dist')):
+        shutil.copy(os.path.join(project, 'dist', s), output)
+
+
+def metricmethod(func):
+    if not hasattr(time, 'process_time'):
+        time.process_time = time.clock
+
+    def wrap(*args, **kwargs):
+        t1 = time.process_time()
+        result = func(*args, **kwargs)
+        t2 = time.process_time()
+        logging.info('%-50s: %10.6f ms', func.__name__, (t2 - t1) * 1000)
+        return result
+    return wrap
+
+
+@metricmethod
+def verify_license(m):
+    try:
+        prototype = PYFUNCTYPE(py_object)
+        dlfunc = prototype(('get_registration_code', m))
+        code = dlfunc()
+    except Exception:
+        logging.warning('Verify license failed')
+        code = ''
+    return code
+
+
+@metricmethod
+def init_pytransform(m):
+    major, minor = sys.version_info[0:2]
+    # Python2.5 no sys.maxsize but sys.maxint
+    # bitness = 64 if sys.maxsize > 2**32 else 32
+    prototype = PYFUNCTYPE(c_int, c_int, c_int, c_void_p)
+    init_module = prototype(('init_module', m))
+    init_module(major, minor, pythonapi._handle)
+
+    prototype = PYFUNCTYPE(c_int, c_int, c_int, c_int)
+    init_runtime = prototype(('init_runtime', m))
+    init_runtime(0, 0, 0, 0)
+
+
+@metricmethod
+def load_pytransform():
+    return pytransform._load_library(PYARMOR_PATH, is_runtime=1)
+
+
+@metricmethod
+def total_extra_init_time():
+    m = load_pytransform()
+    init_pytransform(m)
+    verify_license(m)
+
+
+@metricmethod
+def import_first_no_obfuscated_module(name):
+    return __import__(name)
+
+
+@metricmethod
+def import_first_obfuscated_module(name):
+    return __import__(name)
+
+
+@metricmethod
+def re_import_no_obfuscated_module(name):
+    return __import__(name)
+
+
+@metricmethod
+def re_import_obfuscated_module(name):
+    return __import__(name)
+
+
+@metricmethod
+def run_empty_obfuscated_code_object(foo):
+    return foo.empty()
+
+
+@metricmethod
+def run_obfuscated_1k_bytecode(foo):
+    return foo.one_thousand()
+
+
+@metricmethod
+def run_obfuscated_10k_bytecode(foo):
+    return foo.ten_thousand()
+
+
+@metricmethod
+def run_empty_no_obfuscated_code_object(foo):
+    return foo.empty()
+
+
+@metricmethod
+def run_no_obfuscated_1k_bytecode(foo):
+    return foo.one_thousand()
+
+
+@metricmethod
+def run_no_obfuscated_10k_bytecode(foo):
+    return foo.ten_thousand()
+
+
+@metricmethod
+def import_many_obfuscated_modules(name, n=100):
+    for i in range(n):
+        __import__(name % i)
+
+
+@metricmethod
+def import_many_no_obfuscated_modules(name, n=100):
+    for i in range(n):
+        __import__(name % i)
+
+
+@metricmethod
+def call_1000_no_obfuscated_1k_bytecode(foo):
+    return foo.call_1k_function(1000)
+
+
+@metricmethod
+def call_1000_obfuscated_1k_bytecode(foo):
+    return foo.call_1k_function(1000)
+
+
+@metricmethod
+def call_1000_no_obfuscated_10k_bytecode(foo):
+    return foo.call_10k_function(1000)
+
+
+@metricmethod
+def call_1000_obfuscated_10k_bytecode(foo):
+    return foo.call_10k_function(1000)
+
+
+@metricmethod
+def call_10000_no_obfuscated_1k_bytecode(foo):
+    return foo.call_1k_function(10000)
+
+
+@metricmethod
+def call_10000_obfuscated_1k_bytecode(foo):
+    return foo.call_1k_function(10000)
+
+
+@metricmethod
+def call_10000_no_obfuscated_10k_bytecode(foo):
+    return foo.call_10k_function(10000)
+
+
+@metricmethod
+def call_10000_obfuscated_10k_bytecode(foo):
+    return foo.call_10k_function(10000)
+
+
+def main():
+    if not os.path.exists('benchmark.py'):
+        logging.warning('Please change current path to %s', PYARMOR_PATH)
+        return
+
+    output = '.benchtest'
+    name = 'bfoo'
+    filename = os.path.join(output, name + '.py')
+
+    obname = 'obfoo'
+    obfilename = os.path.join(output, obname + '.py')
+
+    if len(sys.argv) > 1 and 'bootstrap'.startswith(sys.argv[1]):
+        if len(sys.argv) < 6:
+            sys.argv.extend(['1', '1', '1', '0'])
+        obf_mod, obf_code, wrap_mode, adv_mode = sys.argv[2:6]
+
+        if os.path.exists(output) and output.endswith('.benchtest'):
+            logging.info('Clean output path: %s', output)
+            shutil.rmtree(output)
+        logging.info('Create output path: %s', output)
+        os.makedirs(output)
+
+        logging.info('Generate test script %s ...', filename)
+        make_test_script(filename)
+
+        logging.info('Obffuscate test script ...')
+        shutil.copy(filename, obfilename)
+        obffuscate_scripts(output, os.path.basename(obfilename),
+                           obf_mod, obf_code, wrap_mode, adv_mode)
+        if not os.path.exists(obfilename):
+            logging.info('Something is wrong to obsfucate the script')
+            return
+        logging.info('Generate obffuscated script %s', obfilename)
+
+        logging.info('Copy benchmark.py to %s', output)
+        shutil.copy('benchmark.py', output)
+
+        logging.info('')
+        logging.info('Now change to "%s"', output)
+        logging.info('Run "%s benchmark.py".', sys.executable)
+        return
+
+    filename = os.path.basename(filename)
+    if os.path.exists(filename):
+        logging.info('Test script: %s', filename)
+    else:
+        logging.warning('Test script: %s not found', filename)
+        logging.info('Run "%s benchmark.py bootstrap" first.', sys.executable)
+        return
+
+    obfilename = os.path.basename(obfilename)
+    if os.path.exists(obfilename):
+        logging.info('Obfuscated script: %s', obfilename)
+    else:
+        logging.warning('Obfuscated script: %s not found', obfilename)
+        logging.info('Run "%s benchmark.py bootstrap" first.', sys.executable)
+        return
+
+    logging.info('--------------------------------------')
+
+    # It doens't work for super mode
+    # logging.info('')
+    # total_extra_init_time()
+
+    logging.info('')
+    foo = import_first_no_obfuscated_module(name)
+    obfoo = import_first_obfuscated_module(obname)
+
+    logging.info('')
+    foo = re_import_no_obfuscated_module(name)
+    obfoo = re_import_obfuscated_module(obname)
+
+    logging.info('')
+    n = 10
+    logging.info('--- Import %d modules ---', n)
+    for i in range(n):
+        shutil.copy(filename, filename.replace('.py', '_%s.py' % i))
+        with open(obfilename) as f:
+            lines = f.readlines()
+        with open(obfilename.replace('.py', '_%s.py' % i), 'w') as f:
+            f.write(lines[2] if lines[0].find('pyarmor_runtime') > 0 \
+                    else ''.join(lines))
+    import_many_no_obfuscated_modules('bfoo_%s', n)
+    import_many_obfuscated_modules('obfoo_%s', n)
+
+    logging.info('')
+    run_empty_no_obfuscated_code_object(foo)
+    run_empty_obfuscated_code_object(obfoo)
+
+    logging.info('')
+    run_no_obfuscated_1k_bytecode(foo)
+    run_obfuscated_1k_bytecode(obfoo)
+
+    logging.info('')
+    run_no_obfuscated_10k_bytecode(foo)
+    run_obfuscated_10k_bytecode(obfoo)
+
+    logging.info('')
+    call_1000_no_obfuscated_1k_bytecode(foo)
+    call_1000_obfuscated_1k_bytecode(obfoo)
+
+    logging.info('')
+    call_1000_no_obfuscated_10k_bytecode(foo)
+    call_1000_obfuscated_10k_bytecode(obfoo)
+
+    logging.info('')
+    call_10000_no_obfuscated_1k_bytecode(foo)
+    call_10000_obfuscated_1k_bytecode(obfoo)
+
+    logging.info('')
+    call_10000_no_obfuscated_10k_bytecode(foo)
+    call_10000_obfuscated_10k_bytecode(obfoo)
+
+    logging.info('')
+    logging.info('--------------------------------------')
+
+
+if __name__ == '__main__':
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(message)s',
+    )
+    main()