pyarmor.cli 9.2.6__3-py3-none-any.whl

pyarmor/cli/docker.py

@@ -0,0 +1,192 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#############################################################
+#                                                           #
+#      Copyright @ 2023 -  Dashingsoft corp.                #
+#      All rights reserved.                                 #
+#                                                           #
+#      Pyarmor                                              #
+#                                                           #
+#      Version: 8.3.0 -                                     #
+#                                                           #
+#############################################################
+#
+#
+#  @File: cli/docker.py
+#
+#  @Author: Jondy Zhao (pyarmor@163.com)
+#
+#  @Create Date: Tue Aug 1 09:18:12 CST 2023
+#
+import argparse
+import logging
+import os
+import socketserver
+import struct
+import sys
+
+from .context import Context
+from .generate import Pytransform3
+from .register import Register, MACHFLAGS
+
+
+CONFIG = {
+    'host': '0.0.0.0',
+    'port': 29092,
+    'home': os.path.expanduser(os.path.join('~', '.pyarmor', 'docker')),
+    'machid': None,
+    'ctx': None,
+}
+
+
+class DockerAuthHandler(socketserver.BaseRequestHandler):
+
+    def handle(self):
+        data = self.request.recv(64)
+        logging.info('receive request from %s', self.client_address)
+        try:
+            logging.debug('request data (%d): %s', len(data), data)
+            response = self.process(data)
+            logging.info('send auth result to %s', self.client_address)
+            logging.debug('response data (%d): %s', len(response), response)
+        except Exception as e:
+            logging.error('%s', str(e))
+            msg = 'verification failed, please check host console'.encode()
+            msg += b'\00'
+            self.request.send(struct.pack('!HH', 1, len(msg)) + msg)
+
+    def process(self, packet):
+        cmd = packet[:4]
+        if cmd == b'PADH':
+            response = b'\n'.join(CONFIG['machid']) + b'\x00'
+            self.request.send(response)
+        elif cmd == b'PADI':
+            userdata = packet[4:].decode('utf-8')
+            rtkey = self.generate_outer_key(userdata, outer=False)
+            magic = b'DockerRuntimeKey'
+            response = magic + struct.pack('!HH', 0, len(rtkey)) + rtkey
+            self.request.send(response)
+        elif cmd == b'PADK':
+            userdata = self.parse_packet(packet).decode('utf-8')
+            rtkey = self.generate_runtime_key(userdata)
+            response = struct.pack('!HH', 0, len(rtkey)) + rtkey
+            self.request.send(response)
+        else:
+            raise RuntimeError('unknown packet %r' % packet)
+        return response
+
+    def parse_packet(self, packet):
+        if len(packet) == 32 and packet[:4] == b'PADK':
+            return packet[12:]
+        raise RuntimeError('invalid auth request: %r' % packet)
+
+    def generate_runtime_key(self, userdata):
+        ctx = CONFIG['ctx']
+        ctx.cmd_options['user_data'] = userdata
+        ctx.cmd_options['expired'] = '.3'
+        ctx.cmd_options['outer'] = 0
+        Pytransform3._pytransform3.init_ctx(ctx)
+        return Pytransform3.generate_runtime_key(ctx)
+
+    def generate_outer_key(self, userdata, outer=True):
+        ctx = CONFIG['ctx']
+        ctx.cmd_options['user_data'] = userdata
+        ctx.cmd_options['expired'] = '.3'
+        ctx.cmd_options['outer'] = 1
+        Pytransform3._pytransform3.init_ctx(ctx)
+        return Pytransform3.generate_runtime_key(ctx, outer=outer)
+
+
+def register_pyarmor(ctx, regfile):
+    reg = Register(ctx)
+    logging.info('register "%s"', regfile)
+    reg.register_regfile(regfile)
+    if reg.license_info['features'] < 15:
+        raise RuntimeError('this feature is only for group license')
+    Pytransform3.init(ctx)
+
+
+def main_entry():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-d', '--debug', action='store_true',
+                        help='Enable debug mode')
+    parser.add_argument('--host', type=str, default=CONFIG['host'])
+    parser.add_argument('-p', '--port', type=int, default=CONFIG['port'],
+                        help=argparse.SUPPRESS)
+    parser.add_argument('-s', '--sock', default='/var/run/docker.sock',
+                        help=argparse.SUPPRESS)
+    parser.add_argument('--home', help=argparse.SUPPRESS)
+    parser.add_argument('regfile', nargs=1,
+                        help='group device registration file for this machine')
+    args = parser.parse_args(sys.argv[1:])
+
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+
+    if args.home:
+        CONFIG['home'] = os.path.expandvars(os.path.expanduser(args.home))
+    home = CONFIG['home']
+    logging.info('work path: %s', home)
+
+    # lpath should be non-existent or empty
+    ctx = Context(home=home, lpath=os.path.join(home, 'non-existent'))
+    register_pyarmor(ctx, args.regfile[0])
+    CONFIG['ctx'] = ctx
+
+    CONFIG['machid'] = [Pytransform3.get_hd_info(x) for x in MACHFLAGS]
+    logging.debug('machine id: %s', CONFIG['machid'])
+
+    host, port = args.host, args.port
+    with socketserver.TCPServer((host, port), DockerAuthHandler) as server:
+        logging.info('listen container auth request on %s:%s', host, port)
+        server.serve_forever()
+
+
+def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s: %(message)s',
+    )
+    main_entry()
+
+
+#
+# Deprecrated functions
+#
+def get_docker_gateway(client):
+    filters = {
+        'driver': 'bridge',
+        'type': 'builtin'
+    }
+    networks = client.networks.list(filters=filters)
+    return networks[0].attrs['IPAM']['Config'][0]['Gateway']
+
+
+def get_container(client, ipaddr):
+    filters = {
+        'driver': 'bridge',
+        'type': 'builtin'
+    }
+    networks = client.networks.list(filters=filters, greedy=True)
+    containers = networks[0].attrs.get('Containers')
+    if containers:
+        marker = ipaddr + '/'
+        for dockid, netattr in containers.items():
+            if netattr.get('IPv4Address').startswith(marker):
+                return client.containers.get(dockid)
+    raise RuntimeError('no found countainer with IPv4 %s' % ipaddr)
+
+
+def copy_file_into_docker(containerid, filename):
+    from subprocess import check_call
+    check_call(['docker', 'cp', filename, '%s:/' % containerid])
+
+
+def get_container_info(client, shortid):
+    container = client.container.get(shortid)
+    return container.attrs
+
+
+if __name__ == '__main__':
+    main()

pyarmor/cli/generate.py

@@ -0,0 +1,256 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#############################################################
+#                                                           #
+#      Copyright @ 2023 -  Dashingsoft corp.                #
+#      All rights reserved.                                 #
+#                                                           #
+#      Pyarmor                                              #
+#                                                           #
+#      Version: 8.0.1 -                                     #
+#                                                           #
+#############################################################
+#
+#
+#  @File: cli/generate.py
+#
+#  @Author: Jondy Zhao (pyarmor@163.com)
+#
+#  @Create Date: 2022-12-06
+#
+import os
+import shutil
+
+from pyarmor.cli.core import Pytransform3
+
+from . import logger, CliError
+from .resource import FileResource, PathResource
+
+
+class Finder(object):
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+
+    def _build_resource(self, pathlist):
+        resources = []
+        for path in pathlist:
+            if not os.path.exists(path):
+                raise CliError('argument "%s" doesn\'t exists' % path)
+            if os.path.isfile(path):
+                logger.info('find script %s', path)
+                res = FileResource(path)
+                resources.append(res)
+            else:
+                logger.info('find package at %s', path)
+                res = PathResource(path)
+                resources.append(res)
+                options = self.ctx.get_res_options(res.fullname)
+                res.rebuild(**options)
+        return resources
+
+    def prepare(self, input_paths):
+        self.ctx.resources = self._build_resource(input_paths)
+
+    def process_extra(self, contents):
+        extra_paths = [x for x in contents if x.endswith('.pyc')]
+        for pyz in [x for x in contents if x.endswith('.pyz_extracted')]:
+            extra_paths.extend([os.path.join(pyz, x) for x in os.listdir(pyz)])
+        resnames = [x.pkgname for x in self.ctx.resources]
+        for res in self._build_resource(extra_paths):
+            if res.pkgname not in resnames:
+                self.ctx.obfuscated_modules.add(res.pkgname)
+                self.ctx.extra_resources.append(res)
+
+    def append(self, resources):
+        resnames = [x.pkgname for x in self.ctx.resources]
+        for res in self._build_resource(resources):
+            if res.pkgname not in resnames:
+                self.ctx.obfuscated_modules.add(res.pkgname)
+                self.ctx.resources.append(res)
+
+    def process(self):
+        logger.info('search inputs ...')
+        self.prepare(self.ctx.input_paths)
+        logger.info('find %d top resources', len(self.ctx.resources))
+
+        modules = [x.fullname for res in self.ctx.resources for x in res
+                   if x.is_script()]
+        self.ctx.obfuscated_modules.update(modules)
+
+
+class Builder(object):
+
+    def __init__(self, ctx):
+        self.ctx = ctx
+
+    def format_output(self, outputs, count=0):
+        try:
+            output = outputs[count]
+        except IndexError:
+            output = self.ctx.alias_suffix.format(outputs[0], count)
+        return output
+
+    def generate_runtime_key(self, outer=None):
+        return Pytransform3.generate_runtime_key(self.ctx, outer)
+
+    def generate_runtime_package(self, output):
+        if self.ctx.runtime_key is None:
+            self.ctx.runtime_key = self.generate_runtime_key()
+        Pytransform3.generate_runtime_package(self.ctx, output)
+
+    def _generate_obfuscated_script(self, res):
+        try:
+            return Pytransform3.generate_obfuscated_script(self.ctx, res)
+        except RuntimeError as e:
+            if str(e) != 'out of license':
+                raise
+
+    def _copy_script(self, path, res):
+        logger.warning('%s is not obfuscated because out of license', res)
+        fullpath = os.path.join(path, res.output_filename)
+        output = os.path.dirname(fullpath)
+        os.makedirs(output, exist_ok=True)
+        logger.info('write %s (not obfuscated)', fullpath)
+        shutil.copy2(res.fullpath, output)
+
+    def _obfuscate_scripts(self):
+        rev = self.ctx.version_info()
+        template = self.ctx.bootstrap_template
+        relative = self.ctx.import_prefix
+        pkgname = self.ctx.runtime_package_name
+        bootpath = self.ctx.cfg.get('builder', 'bootstrap_file')
+        encoding = self.ctx.cfg.get('builder', 'encoding')
+
+        plugins = [x for x in self.ctx.plugins if hasattr(x, 'post_script')]
+
+        namelist = []
+        for res in self.ctx.resources + self.ctx.extra_resources:
+            logger.info('process resource "%s"', res.fullname)
+            name = res.name
+            path = self.format_output(self.ctx.outputs, namelist.count(name))
+            namelist.append(name)
+            os.makedirs(path, exist_ok=True)
+
+            for r in res:
+                if not r.is_script():
+                    logger.info('copy data file %s', r.fullpath)
+                    data_path = os.path.join(path, r.output_path)
+                    os.makedirs(data_path, exist_ok=True)
+                    shutil.copy2(r.fullpath, data_path)
+                    continue
+
+                logger.info('obfuscating %s', r)
+                code = Pytransform3.generate_obfuscated_script(self.ctx, r)
+                source = r.generate_output(
+                    template, code, relative=relative, pkgname=pkgname,
+                    bootpath=bootpath, rev=rev
+                )
+
+                fullpath = os.path.join(path, r.output_filename)
+                os.makedirs(os.path.dirname(fullpath), exist_ok=True)
+
+                for plugin in plugins:
+                    patched_source = plugin.post_script(self.ctx, r, source)
+                    if patched_source:
+                        source = patched_source
+
+                logger.info('write %s', fullpath)
+                with open(fullpath, 'w', encoding=encoding) as f:
+                    f.write(source)
+
+    def process(self, options, packer=None):
+        for opt in options['inputs']:
+            if not os.path.exists(opt):
+                raise CliError('no found input "%s"' % opt)
+        self.ctx.input_paths = options['inputs']
+
+        output = options.get('output', 'dist')
+        self.ctx.outputs = output.split(',')
+
+        finder = Finder(self.ctx)
+        finder.process()
+
+        if packer and hasattr(packer, 'analysis'):
+            auto_resources = packer.analysis()
+            logger.info('find extra resources: %s', auto_resources)
+            finder.append(auto_resources)
+
+        Pytransform3.pre_build(self.ctx)
+
+        self.ctx.runtime_key = self.generate_runtime_key()
+        if not options.get('no_runtime'):
+            logger.info('start to generate runtime files')
+            self.generate_runtime_package(self.ctx.outputs[0])
+            logger.info('generate runtime files OK')
+
+        logger.info('start to obfuscate scripts')
+        n = self.ctx.cfg.getint('builder', 'max_workers')
+        async_obfuscate_scripts(self, n) if n else self._obfuscate_scripts()
+        logger.info('obfuscate scripts OK')
+
+        Pytransform3.post_build(self.ctx)
+
+
+def async_obfuscate_scripts(builder, max_workers):
+    from concurrent.futures import ProcessPoolExecutor, wait
+
+    ctx = builder.ctx
+    rev = ctx.version_info()
+    template = ctx.bootstrap_template
+    relative = ctx.import_prefix
+    pkgname = ctx.runtime_package_name
+    bootpath = ctx.cfg.get('builder', 'bootstrap_file')
+    encoding = ctx.cfg.get('builder', 'encoding')
+    max_workers = None if max_workers < 2 else max_workers
+
+    plugins = [x for x in ctx.plugins if hasattr(x, 'post_script')]
+
+    namelist = []
+    futures = []
+
+    with ProcessPoolExecutor(max_workers=max_workers) as executor:
+        for res in ctx.resources + ctx.extra_resources:
+            logger.info('process resource "%s"', res.fullname)
+            name = res.name
+            path = builder.format_output(ctx.outputs, namelist.count(name))
+            namelist.append(name)
+            os.makedirs(path, exist_ok=True)
+
+            for r in res:
+                if not r.is_script():
+                    logger.info('copy data file %s', r.fullpath)
+                    data_path = os.path.join(path, r.output_path)
+                    os.makedirs(data_path, exist_ok=True)
+                    shutil.copy2(r.fullpath, data_path)
+                    continue
+
+                logger.info('obfuscating %s', r)
+                futures.append(executor.submit(aysnc_generate_script, *(
+                    r, path, ctx, template, relative, pkgname, bootpath,
+                    rev, plugins, encoding)))
+
+    wait(futures)
+    for x in futures:
+        x.result()
+
+
+def aysnc_generate_script(r, path, ctx, template, relative,
+                          pkgname, bootpath, rev, plugins, encoding):
+    code = Pytransform3.generate_obfuscated_script(ctx, r)
+    source = r.generate_output(
+        template, code, relative=relative, pkgname=pkgname,
+        bootpath=bootpath, rev=rev
+    )
+
+    fullpath = os.path.join(path, r.output_filename)
+    os.makedirs(os.path.dirname(fullpath), exist_ok=True)
+
+    for plugin in plugins:
+        patched_source = plugin.post_script(ctx, r, source)
+        if patched_source:
+            source = patched_source
+
+    with open(fullpath, 'w', encoding=encoding) as f:
+        f.write(source)

pyarmor/cli/hdinfo.py

@@ -0,0 +1,81 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+#############################################################
+#                                                           #
+#      Copyright @ 2023 -  Dashingsoft corp.                #
+#      All rights reserved.                                 #
+#                                                           #
+#      Pyarmor                                              #
+#                                                           #
+#      Version: 8.4.6 -                                     #
+#                                                           #
+#############################################################
+#
+#
+#  @File: cli/hdinfo.py
+#
+#  @Author: Jondy Zhao (pyarmor@163.com)
+#
+#  @Create Date: Fri Dec 15 09:27:30 CST 2023
+#
+import argparse
+import sys
+
+from pyarmor.cli.core import Pytransform3
+
+
+GROUP_LICENSE_MACHINE_FLAG = 22
+HT_HARDDISK, HT_IFMAC, HT_IPV4, HT_IPV6, HT_DOMAIN = range(5)
+
+
+def get_hd_info(hdtype, name=None):
+    try:
+        return repr(Pytransform3.get_hd_info(hdtype, name))
+    except Exception as e:
+        return str(e)
+
+
+def get_all_ifmac():
+    try:
+        buf = Pytransform3.get_hd_info(HT_IFMAC, name='*')
+        i = 0
+        n = len(buf)
+        rlist = []
+        while i < n and buf[i]:
+            j = i + 1 + buf[i]
+            rlist.append(':'.join(['%02x' % x for x in buf[i+1:j]]))
+            i = j
+    except Exception as e:
+        return str(e)
+
+    return '<%s>' % ','.join(set(rlist))
+
+
+def main(argv):
+    parser = argparse.ArgumentParser()
+    parser.add_argument('devname', nargs='*', help=(
+        'In Linux get netcard name like "eth0" '
+        'or harddisk name like "/dev/sda"'))
+    args = parser.parse_args(argv)
+
+    print('Machine ID: %s' % get_hd_info(GROUP_LICENSE_MACHINE_FLAG)[1:])
+
+    if not args.devname:
+        print('Default Harddisk Serial Number: %s' % get_hd_info(HT_HARDDISK))
+        print('Default Mac address: %s' % get_hd_info(HT_IFMAC))
+        print('Default IPv4 address: %s' % get_hd_info(HT_IPV4))
+        print('Multiple Mac addresses: %s' % get_all_ifmac())
+        print('Domain: %s' % get_hd_info(HT_DOMAIN))
+
+    for name in args.devname:
+        if name.startswith('/'):
+            print('Query Harddisk "%s" Serial Number: %s' %
+                  (name, get_hd_info(HT_HARDDISK, name=name)))
+        else:
+            print('Query Netcard "/dev/%s" Mac Address: %s' %
+                  (name, get_hd_info(HT_IFMAC, name=name)))
+
+
+if __name__ == '__main__':
+    main(sys.argv[1:])