pyarmor 9.2.6__4-py3-none-any.whl

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 script 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.15
+* 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/__init__.py

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

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()

pyarmor/build_meta.py

@@ -0,0 +1,126 @@
+"""A PEP 517 interface to building pyarmored wheel based on setuptools
+
+Here is an example package
+
+    mypkg/
+        pyproject.toml
+        setup.py
+        src/
+            __init__.py
+            ...
+
+The content of minimum build file "pyproject.toml"
+
+    [build-system]
+    requires = ["setuptools", "wheel", "pyarmor>=7.2.0"]
+    build-backend = "pyarmor.build_meta"
+
+Now build a pyarmored wheel by pip
+
+    cd mypkg/
+    pip wheel .
+
+
+Again, this is not a formal definition! Just a "taste" of the module.
+"""
+
+import os
+import shutil
+import sys
+
+from wheel.wheelfile import WheelFile
+from wheel.cli.pack import pack as wheel_pack
+from pyarmor.pyarmor import main as pyarmor_main
+
+from setuptools.build_meta import build_wheel as setuptools_build_wheel
+
+try:
+    from distutils.util import get_platform
+except ModuleNotFoundError:
+    from polyfills import get_platform
+
+
+def _wheel_unpack(path, dest='.'):
+    with WheelFile(path) as wf:
+        namever = wf.parsed_filename.group('namever')
+        destination = os.path.join(dest, namever)
+        sys.stdout.flush()
+        wf.extractall(destination)
+    return namever
+
+
+def _wheel_append_runtime_files(build_path, namever, pkgname):
+    namelist = []
+    for name in os.listdir(os.path.join(build_path, pkgname)):
+        if name.startswith('pytransform'):
+            path = os.path.join(build_path, pkgname, name)
+            n = len(path) + 1
+            if os.path.isdir(path):
+                for root, dirs, files in os.walk(path):
+                    prefix = root[n:].replace('\\', '/')
+                    for x in files:
+                        namelist.append(prefix + '/' + x)
+            else:
+                namelist.append(name)
+
+    wheel_record = os.path.join(build_path, namever + '.dist-info', 'RECORD')
+    with open(wheel_record, 'a') as f:
+        for name in namelist:
+            f.write(pkgname + '/' + name + ',,\n')
+
+
+def _fix_config(config_settings, obf_options):
+    from pip._internal.configuration import Configuration, ConfigurationError
+    config = Configuration(False)
+    config.load()
+    for k, v in reversed(config.items()):
+        if k in ('pyarmor.advanced', ':env:.pyarmor-advanced'):
+            if v not in ('2', '3', '4', '5'):
+                raise ConfigurationError('Invalid pyarmor.advanced')
+            obf_options.extend(['--advanced', v])
+            break
+
+    config_settings = config_settings or {}
+    global_options = config_settings.get('--global-option', [])
+
+    plat_name = get_platform().replace('-', '_').replace('.', '_')
+    global_options.append('--plat-name=%s' % plat_name)
+
+    global_options.append('--python-tag=cp%s%s' % sys.version_info[:2])
+    # global_options.append('--py-limited-api=cp%s%s' % sys.version_info[:2])
+
+    config_settings['--global-option'] = global_options
+    return config_settings
+
+
+def build_wheel(wheel_directory, config_settings=None,
+                metadata_directory=None):
+    obf_options = ['obfuscate', '--enable-suffix', '--in-place',
+                   '-r', '--bootstrap', '3']
+    config_settings = _fix_config(config_settings, obf_options)
+
+    # Build wheel by setuptools
+    result_basename = setuptools_build_wheel(
+        wheel_directory,
+        config_settings=config_settings,
+        metadata_directory=metadata_directory
+    )
+
+    # Unpack wheel and replace the original .py with obfuscated ones
+    result_wheel = os.path.join(wheel_directory, result_basename)
+    namever = _wheel_unpack(result_wheel, wheel_directory)
+
+    pkgname = namever.split('-')[0]
+    build_path = os.path.join(wheel_directory, namever)
+
+    obf_options.append(os.path.join(build_path, pkgname, '__init__.py'))
+    pyarmor_main(obf_options)
+
+    # Append runtime files of obfuscated scripts to wheel
+    _wheel_append_runtime_files(build_path, namever, pkgname)
+
+    # Pack the patched wheel again
+    wheel_pack(build_path, wheel_directory, None)
+
+    shutil.rmtree(build_path)
+    return result_basename

pyarmor/cli/__init__.py

@@ -0,0 +1,46 @@
+import logging
+
+__VERSION__ = '9.2.6'
+
+logger = logging.getLogger('cli')
+
+
+class CliError(Exception):
+    pass
+
+
+def resoptions(meth):
+
+    def process(self, res, *args, **kwargs):
+        self._options = self.ctx.get_res_options(res.fullname, self._Catalog)
+        return meth(self, res, *args, **kwargs)
+
+    return process
+
+
+class Component(object):
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+        self._options = {}
+
+        self.logger = logging.getLogger(self.LOGNAME)
+
+    def __getattr__(self, opt):
+        if opt.startswith('o_'):
+            return self._options.get(opt[2:], '')
+        elif opt.startswith('oi_'):
+            return int(self._options.get(opt[3:]))
+        elif opt.startswith('ob_'):
+            v = self._options.get(opt[3:], '')
+            if isinstance(v, str):
+                if v.isdigit():
+                    return bool(int(v))
+                return v.lower() in ('1', 'true', 'on', 'yes')
+
+            return v
+        return AttributeError(opt)
+
+    def trace(self, res, node, value):
+        lineno = getattr(node, 'lineno', -1)
+        self.logger.info('%s:%s:%s', res.fullname, lineno, value)