pyarmor.cli 9.2.5__2-py3-none-any.whl

pyarmor/cli/merge.py

@@ -0,0 +1,232 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#############################################################
+#                                                           #
+#      Copyright @ 2023 -  Dashingsoft corp.                #
+#      All rights reserved.                                 #
+#                                                           #
+#      Pyarmor                                              #
+#                                                           #
+#      Version: 8.2.3 -                                     #
+#                                                           #
+#############################################################
+#
+#
+#  @File: cli/merge.py
+#
+#  @Author: Jondy Zhao (pyarmor@163.com)
+#
+#  @Create Date: Tue May 30 19:35:02 CST 2023
+#
+import argparse
+import logging
+import os
+import shutil
+import struct
+import sys
+
+logger = logging.getLogger('merge')
+
+
+def is_pyscript(filename):
+    return os.path.splitext(filename)[-1].lower() in ('.py', '.pyw')
+
+
+def parse_script(filename):
+    with open(filename) as f:
+        for line in f:
+            if line.startswith('__pyarmor__('):
+                i = line.find('(')
+                args = line.strip()[i+1:-1].split(', ', 2)
+                co = compile(line, '<str>', 'exec')
+                return args, co.co_consts[0]
+
+
+def parse_header(code):
+    left_size = len(code)
+    offset = 0
+    infos = []
+    valid = False
+
+    while left_size > 0:
+        pymajor, pyminor = struct.unpack("BB", code[offset+9:offset+11])
+        size, = struct.unpack("i", code[offset+56:offset+60])
+        if not size:
+            valid = True
+            size = left_size
+        left_size -= size
+        infos.append([offset, size, (pymajor, pyminor)])
+        offset += size
+
+    if not valid:
+        raise RuntimeError('invalid header in this script')
+
+    return infos
+
+
+def merge_scripts(name, paths, dest):
+    scripts = [os.path.join(p, name) for p in paths]
+
+    refscript = scripts.pop(0)
+    result = parse_script(refscript)
+
+    if result is None:
+        logger.info('copy script, it is not obfuscated')
+        shutil.copy2(refscript, dest)
+        return
+
+    refmark = '--xxxxxx--'
+    refitem, refcode = result
+    with open(refscript) as f:
+        refdata = f.read().replace(refitem[-1], refmark)
+
+    pieces = []
+
+    for script in reversed(scripts):
+        result = parse_script(script)
+        if not result:
+            raise RuntimeError('"%s" is not an obfuscated script' % script)
+        item, code = result
+        infos = parse_header(code)
+        off, size, pyver = infos[-1]
+        logger.debug('merge py%s.%s at %d (%d)', *pyver, off, size)
+        pieces.extend([code[:off+56], struct.pack("i", size), code[off+60:]])
+
+    for off, size, pyver in parse_header(refcode):
+        logger.debug('merge py%s.%s at %d (%d)', *pyver, off, size)
+        pieces.append(refcode[off:off+size])
+
+    logger.info('write "%s"', dest)
+    with open(dest, 'w') as f:
+        f.write(refdata.replace(refmark, repr(b''.join(pieces))))
+
+
+def merge_paths(paths, rname, output):
+    refpath = os.path.normpath(paths[-1])
+    rpath = os.path.join(refpath, rname) if rname else None
+
+    n = len(refpath) + 1
+    for root, dirs, files in os.walk(refpath):
+        for x in files:
+            if rpath and root.startswith(rpath):
+                continue
+
+            name = root[n:]
+            destpath = os.path.join(output, name)
+            if not os.path.exists(destpath):
+                os.makedirs(destpath)
+
+            dest = os.path.join(destpath, x)
+            logger.info('handle "%s"', dest)
+            if is_pyscript(x):
+                merge_scripts(os.path.join(name, x), paths, dest)
+            else:
+                shutil.copy2(os.path.join(root, x), dest)
+
+
+def merge_runtimes(paths, rname, output):
+    dest = os.path.join(output, rname)
+    if os.path.exists(dest):
+        shutil.rmtree(dest)
+    os.makedirs(dest)
+
+    shutil.copy2(os.path.join(paths[0], rname, '__init__.py'), dest)
+
+    for p in paths:
+        logger.info('handle runtime package at "%s"', p)
+        rpath = os.path.join(p, rname)
+        if not os.path.exists(rpath):
+            raise RuntimeError('no runtime package found')
+        for x in os.scandir(rpath):
+            if x.is_dir():
+                logger.info('copy runtime files "%s" to "%s"', x.name, dest)
+                shutil.copytree(x.path, os.path.join(dest, x.name))
+
+
+def scan_runtime(paths, marker=None):
+    if marker is None:
+        marker = 'from sys import version_info as py_version'
+    refpath = os.path.normpath(paths[-1])
+    logger.info('scan runtime package in the path "%s"', refpath)
+
+    n = len(refpath) + 1
+
+    for root, dirs, files in os.walk(refpath):
+        for x in files:
+            if x == '__init__.py':
+                filename = os.path.join(root, x)
+                with open(filename) as f:
+                    for line in f:
+                        if line.startswith('#'):
+                            continue
+                        if line.startswith(marker):
+                            return filename[n:-12]
+                        break
+
+    raise RuntimeError('no runtime package found')
+
+
+def excepthook(type, exc, traceback):
+    try:
+        msg = exc.args[0] % exc.args[1:]
+    except Exception:
+        msg = str(exc)
+    logging.error(msg)
+    sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='pyarmor-merge',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='merge Pyarmor 8 obfuscated scripts')
+
+    parser.add_argument('-O', '--output',
+                        default='dist',
+                        help='Default output path: %(default)s)')
+    parser.add_argument('-d', '--debug',
+                        default=False,
+                        action='store_true',
+                        dest='debug',
+                        help='print debug log (default: %(default)s)')
+    group = parser.add_argument_group().add_mutually_exclusive_group()
+    group.add_argument('-n', '--no-runtime', action='store_true',
+                       help='Ignore runtime files')
+    group.add_argument('--runtime-name', help='Runtime package name')
+    parser.add_argument('path', nargs='+',
+                        help="Paths or obfuscated scripts")
+
+    args = parser.parse_args(sys.argv[1:])
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+    else:
+        sys.excepthook = excepthook
+
+    logger.info('start to merge %s...', str(args.path)[1:-1])
+    output = args.output
+
+    runtime_name = args.runtime_name
+
+    if not args.no_runtime:
+        if not runtime_name:
+            runtime_name = scan_runtime(args.path)
+        logger.info('runtime package at "%s"', runtime_name)
+
+        logging.info('merging runtime files...')
+        merge_runtimes(args.path, runtime_name, output)
+        logging.info('merging runtime files OK')
+
+    logging.info('merging obfuscated scripts...')
+    merge_paths(args.path, runtime_name, output)
+    logging.info('merging obfuscated scripts OK')
+
+    logger.info('merge all the scripts to "%s" successfully', output)
+
+
+if __name__ == '__main__':
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(levelname)-8s %(message)s',
+    )
+    main()

pyarmor/cli/mixer.py

@@ -0,0 +1,109 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#############################################################
+#                                                           #
+#      Copyright @ 2023 -  Dashingsoft corp.                #
+#      All rights reserved.                                 #
+#                                                           #
+#      Pyarmor                                              #
+#                                                           #
+#      Version: 8.0.1 -                                     #
+#                                                           #
+#############################################################
+#
+#
+#  @File: cli/mixer.py
+#
+#  @Author: Jondy Zhao (pyarmor@163.com)
+#
+#  @Create Date: 2022-12-06
+#
+import ast
+
+from random import randint
+
+
+class StrNodeTransformer(ast.NodeTransformer):
+
+    def _reform_str(self, s):
+        encoding = getattr(self, 'encoding')
+        value = bytearray(s.encode(encoding) if encoding else s.encode())
+        key = [randint(0, 255)] * len(value)
+        data = [x ^ y for x, y in zip(value, key)]
+        expr = 'bytearray([%s]).decode(%s)' % (
+            ','.join(['%s ^ %s' % k for k in zip(data, key)]),
+            '' if encoding is None else repr(encoding))
+        return ast.parse(expr).body[0].value
+
+    def _reform_value(self, value):
+        if isinstance(value, str):
+            return self._reform_str(value)
+
+        elif isinstance(value, dict):
+            return ast.Dict(**{
+                'keys': [ast.Constant(value=x) for x in value.keys()],
+                'values': [self._reform_str(x) if isinstance(x, str)
+                           else self._reform_value(x) for x in value.values()]
+            })
+
+        elif isinstance(value, (list, tuple, set)):
+            elts = [self._reform_str(x) if isinstance(x, str)
+                    else self._reform_value(x) for x in value]
+            if isinstance(value, set):
+                return ast.Set(elts=elts)
+            else:
+                cls = ast.List if isinstance(value, list) else ast.Tuple
+                return cls(elts=elts, ctx=ast.Load())
+
+        else:
+            return ast.Constant(value=value)
+
+    def reform_node(self, node):
+        value = node.s if isinstance(node, ast.Str) else node.value
+        if not isinstance(value, (list, tuple, set, dict, str)):
+            return node
+
+        obfnode = self._reform_value(value)
+        ast.copy_location(obfnode, node)
+        ast.fix_missing_locations(obfnode)
+        return obfnode
+
+    def filter_node(self, node):
+        return isinstance(node, (ast.Str, ast.Constant))
+
+    def _is_string_value(self, value):
+        return isinstance(value, ast.Str) or (
+            isinstance(value, ast.Constant) and isinstance(value.value, str))
+
+    def ignore_docstring(self, node):
+        return 1 if (
+            isinstance(node, ast.Module) and len(node.body) > 1 and
+            isinstance(node.body[1], ast.ImportFrom) and
+            node.body[1].module == '__future__' and
+            ast.get_docstring(node) is not None) else 0
+
+    def visit(self, node):
+        for field, value in ast.iter_fields(node):
+            if isinstance(value, list):
+                start = self.ignore_docstring(node) if field == 'body' else 0
+                for i in range(start, len(value)):
+                    if self.filter_node(value[i]):
+                        value[i] = self.reform_node(value[i])
+                    elif isinstance(value[i], ast.AST):
+                        self.visit(value[i])
+            elif self.filter_node(value):
+                setattr(node, field, self.reform_node(value))
+            elif isinstance(value, ast.AST):
+                self.visit(value)
+
+
+class StrProtector(object):
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+
+    def process(self, res):
+        snt = StrNodeTransformer()
+        snt.encoding = self.ctx.encoding
+        snt.visit(res.mtree)