Python pyc文件 bytecode的压缩, 加壳和脱壳解析_python代码加壳_qfcy_的博客

1.字节码是什么

PyInstaller, py2exe等库会把编译生成的字节码打包进exe中。掌握字节码(bytecode)的知识, 对于PyInstaller打包exe的反编译是十分有用的。
在Python中, 字节码是一种独特的数据类型, 常存在于用python写成的函数中。先放示例:
>>> import dis
>>> def f(x):print('hello',x)
>>> type(f.__code__)
<class 'code'>
>>> f.__code__.co_code
b't\x00d\x01|\x00\x83\x02\x01\x00d\x00S\x00'
>>> dis.dis(f)
  1           0 LOAD_GLOBAL              0 (print)
              2 LOAD_CONST               1 ('hello')
              4 LOAD_FAST                0 (x)
              6 CALL_FUNCTION            2
              8 POP_TOP
             10 LOAD_CONST               0 (None)
             12 RETURN_VALUE
上述示例中f.__code__就是bytecode对象, f.__code__.co_code就是字节码的二进制部分, 通过dis模块可以反编译、分析这些字节码。
 关于字节码的基础知识, 参见作者的前一篇文章: Python pyc文件 bytecode 字节码解析与插入、编辑 
2.包装字节码
 
在python中, bytecode对象的属性是不可修改的。如: 
>>> def f():pass
>>> f.__code__.co_code = b''
Traceback (most recent call last):
 ... ...
AttributeError: readonly attribute
为了使bytecode对象更易用, 我编写了Code类, 用于包装 (wrap)字节码对象, 使字节码对象变得更易操作。 
# 读者可暂时跳过本代码, 进入下一节
import sys
try:
    from importlib._bootstrap_external import MAGIC_NUMBER
except ImportError:
    from importlib._bootstrap import MAGIC_NUMBER
from types import CodeType, FunctionType
from collections import OrderedDict
import marshal
import dis
import pickle
_py38=hasattr(compile('','','exec'), 'co_posonlyargcount')
class Code:
# 用于doctest
>>> def f():print("Hello")
>>> c=Code.fromfunc(f)
>>> c.co_consts
(None, 'Hello')
>>> c.co_consts=(None, 'Hello World!')
>>> c.exec()
Hello World!
>>> import os,pickle
>>> temp=os.getenv('temp')
>>> with open(os.path.join(temp,"temp.pkl"),'wb') as f:
...     pickle.dump(c,f)
>>> f=open(os.path.join(temp,"temp.pkl"),'rb')
>>> pickle.load(f).to_func()()
Hello World!
>>> c.to_pycfile(os.path.join(temp,"temppyc.pyc"))
>>> sys.path.append(temp)
>>> import temppyc
Hello World!
>>> Code.from_pycfile(os.path.join(temp,"temppyc.pyc")).exec()
Hello World!
# 关于CodeType: 
# 初始化参数
# code(argcount, kwonlyargcount, nlocals, stacksize, flags, codestring,
#    constants, names, varnames, filename, name, firstlineno,
#    lnotab[, freevars[, cellvars]])
    # 按顺序
    _default_args=OrderedDict(
         [('co_argcount',0),
          ('co_kwonlyargcount',0),
          ('co_nlocals',0),
          ('co_stacksize',1),
          # 如果是函数中的code, 则是OPTIMIZED, NEWLOCALS, NOFREE
          ('co_flags',64), # NOFREE
          ('co_code',b'd\x00S\x00'),#1   LOAD_CONST    0 (None)
                                    #2   RETURN_VALUE
          ('co_consts',(None,)),
          ('co_names',()),
          ('co_varnames',()),
          ('co_filename',''),
          ('co_name',''),
          ('co_firstlineno',1),
          ('co_lnotab',b''),
          ('co_freevars',()),
          ('co_cellvars',())
    # 与Python3.8及以上版本兼容
    if _py38:
        _default_args['co_posonlyargcount']=0
        _default_args.move_to_end('co_posonlyargcount', last=False)
        _default_args.move_to_end('co_argcount', last=False)
    _arg_types={key:type(value) for key,value in _default_args.items()}
    def __init__(self,code=None,auto_update=True):
        super().__setattr__('_args',self._default_args.copy())
        if code is not None:
            if isinstance(code,Code):
                self._args = code._args
                self._update_code()
            else:
                self._code=code
                for key in self._args.keys():
                    self._args[key]=getattr(code,key)
        else:
            self._update_code()
        self.auto_update=auto_update
    def __getattr__(self,name):
        _args=object.__getattribute__(self,'_args')
        if name in _args:
            return _args[name]
        else:
            # 调用super()耗时较大, 所以改用object
            return object.__getattribute__(self,name)
    def __setattr__(self,name,value):
        if name not in self._args:
            return object.__setattr__(self,name,value)
        if not isinstance(value,self._arg_types[name]):
            raise TypeError(name,value)
        self._args[name]=value
        if self.auto_update: self._update_code()
    def _update_code(self):
        self._code=CodeType(*self._args.values())
    def exec(self,globals_=None,locals_=None):
        if not self.auto_update: self._update_code()
        default={"__builtins__":__builtins__,"__doc__":None,
                  "__loader__":__loader__,"__name__":"__main__"}
        globals_ = globals_ or default
        if not locals_:locals_ = default.copy()
        return exec(self._code,globals_,locals_)
    def eval(self,globals_=None,locals_=None):
        if not self.auto_update: self._update_code()
        return eval(self._code,globals_,locals_)
    # for pickle
    def __getstate__(self):
        return self._args
    def __setstate__(self,state):
        super().__setattr__('_args',self._default_args.copy())
        self._args.update(state)
        if not _py38 and 'co_posonlyargcount' in state:
            del state['co_posonlyargcount']
        self._update_code()
    def __dir__(self):
        return object.__dir__(self) + list(self._args.keys())
    @classmethod
    def fromfunc(cls,function):
        c=function.__code__
        return cls(c)
    @classmethod
    def fromstring(cls,string,mode='exec',filename=''):
        return cls(compile(string,filename,mode))
    def to_code(self):
        return self._code
    def to_func(self,globals_=None,name=''):
        if globals_ is None:
            import builtins
            globals_=vars(builtins)
        return FunctionType(self._code,globals_,name)
    def pickle(self,filename):
        with open(filename,'wb') as f:
            pickle.dump(self,f)
    def show(self,*args,**kw):
        desc(self._code,*args,**kw)
    view=show
    def info(self):
        dis.show_code(self._code)
    def dis(self,*args,**kw):
        dis.dis(self._code,*args,**kw)
3.压缩字节码
 
压缩字节码的原理是构造一个新的bytecode, 也就是压缩壳, 然后把原先的bytecode用marshal.dumps()转为bytes类型, 然后压缩bytes, 再放入压缩壳中。类似EXE文件的加壳。
 程序运行时, 先解压这个bytes数据, 再使用marshal.loads()重新转换为bytecode, 并执行。




    
 
import sys,marshal,zlib
try:
    from importlib._bootstrap_external import MAGIC_NUMBER
except ImportError:
    from importlib._bootstrap import MAGIC_NUMBER
def dump_to_pyc(pycfilename,code,pycheader=None):
    c=Code() # 构造一个压缩壳
# 反汇编的co_code
##2     0 LOAD_CONST               0 (455)
##      2 LOAD_CONST               1 (None)
##      4 IMPORT_NAME              0 (zlib)
##      6 STORE_NAME               0 (zlib)
##      8 LOAD_CONST               0 (455)
##     10 LOAD_CONST               1 (None)
##     12 IMPORT_NAME              1 (marshal)
##     14 STORE_NAME               1 (marshal)
##3    16 LOAD_NAME                2 (exec)
##     18 LOAD_NAME                1 (marshal)
##     20 LOAD_METHOD              3 (loads)
##     22 LOAD_NAME                0 (zlib)
##     24 LOAD_METHOD              4 (decompress)
##     26 LOAD_CONST               2 (数据)
##     28 CALL_METHOD              1
##     30 CALL_METHOD              1
##     32 CALL_FUNCTION            1
##     34 RETURN_VALUE
    c.co_code=b'''d\x00d\x01l\x00Z\x00d\x00d\x01l\x01Z\x01e\x02\
e\x01\xa0\x03e\x00\xa0\x04d\x02\xa1\x01\xa1\x01\x83\x01\x01\x00d\x01S\x00''' # 仅支持Python 3.7及以上, 因为不同版本Python使用的字节码有微小的差别
    c.co_names=('zlib', 'marshal', 'exec', 'loads', 'decompress')
    #也可换成bz2,lzma等其他压缩模块
    c.co_consts=(0, None,zlib.compress(marshal.dumps(code._code),
                                       zlib.Z_BEST_COMPRESSION))
    c.co_flags=64 # NOFREE
    c.co_stacksize=6
    with open(pycfilename,'wb') as f:
        # 写入 pyc 文件头
        if pycheader is None:
            # 自动生成 pyc 文件头
            if sys.winver >= '3.7':
                pycheader=MAGIC_NUMBER+b'\x00'*12
            else:
                pycheader=MAGIC_NUMBER+b'\x00'*8
        f.write(pycheader)
        # 写入bytecode
        marshal.dump(c._code,f)
if len(sys.argv) == 1:
    print('Usage: %s [filename]' % sys.argv[0])
for file in sys.argv[1:]:
    data=open(file,'rb').read()
    if data[16]==0xe3: #标识pyc文件头的结束, marshal数据的开始
        old_header=data[:16];data=data[16:]
    else:
        old_header=data[:12];data=data[12:]
    co = Code(marshal.loads(data))
    dump_to_pyc(file,co,pycheader=old_header)
    print('Processed:',file)
4.加壳字节码(方法一)：修改co_code
 
加壳字节码与压缩不同, 加壳字节码会阻止字节码被uncompyle6之类的反编译器反编译。
 这种方法在每个bytecode的co_code末尾加上多余的S\x00。
 但co_consts里依然有bytecode, 而这些bytecode又有co_consts, 所以需要递归处理。




    
 
# pyc文件压缩、保护工具
import sys,marshal
from inspect import iscode
try:
    from importlib._bootstrap_external import MAGIC_NUMBER
except ImportError:
    from importlib._bootstrap import MAGIC_NUMBER
def process_code(co):
    # 在`co_code`末尾加上多余的`S\x00'。
    co.co_lnotab = b''
    co.co_code += b'S\x00'
    co.co_filename = ''
    #co.co_name = ''
    co_consts = co.co_consts
    # 递归处理
    for i in range(len(co_consts)):
        obj = co_consts[i]
        if iscode(obj):
            data=process_code(Code(obj))
            co_consts = co_consts[:i] + (data._code,) + co_consts[i+1:]
    co.co_consts = co_consts
    return co
def dump_to_pyc(pycfilename,code,pycheader=None):
    # 制作pyc文件
    with open(pycfilename,'wb') as f:
        # 写入 pyc 文件头
        if pycheader is None:
            # 自动生成 pyc 文件头
            if sys.winver >= '3.7':
                pycheader=MAGIC_NUMBER+b'\x00'*12
            else:
                pycheader=MAGIC_NUMBER+b'\x00'*8
        f.write(pycheader)
        # 写入bytecode
        marshal.dump(code._code,f)
for file in sys.argv[1:]:
    data=open(file,'rb').read()
    if data[16]==0xe3:
        old_header=data[:16];data=data[16:]
    else:old_header=data[:12];data=data[12:]
    co = Code(marshal.loads(data))
    process_code(co)
    dump_to_pyc(file,co,pycheader=old_header)
    print('Processed:',file)
尝试反编译加壳后的pyc文件, 意外发现: 
# --- This code section failed: ---
 L.   2         0  LOAD_CONST               0
                2  LOAD_CONST               None
                4  IMPORT_NAME              sys
                6  STORE_NAME               sys
                8  LOAD_CONST               0
               10  LOAD_CONST               None
               12  IMPORT_NAME              marshal
               14  STORE_NAME               marshal
               ... ... 
              294  LOAD_CONST               None
              296  RETURN_VALUE
              298  RETURN_VALUE
               -1  RETURN_LAST
Parse error at or near `None' instruction at offset -1
说明加壳字节码, 的确能阻止字节码被uncompyle6等反编译器反编译。 
5.加壳字节码(方法二)：混淆变量名
 
还有一种更加彻底的方法, 也就是将字节码中的变量名改成其他名称, 甚至不符合Python语法的变量名都可以。
 这样可以使反编译后的代码难以理解。如果不符合Python语法, 甚至根本无法反编译。
 co_varnames属性包含了该code使用的本地变量的名称。这里将其中的变量名全部修改为"0", “1”, “2”, …。
 基于方法一的代码, 将process_code函数改成下面这样: 
def process_code(co):
    co.co_lnotab = b''
    co.co_code += b'S\x00'
    co.co_filename = ''
    co_consts = co.co_consts
    co.co_varnames=tuple(str(i) for i in range(len(co.co_varnames))) # 这一步修改、混淆变量名
    # 递归处理
    for i in range(len(co_consts)):
        obj = co_consts[i]
        if iscode(obj):
            data=process_code(Code(obj))
            co_consts = co_consts[:i] + (data._code,) + co_consts[i+1:]
    co.co_consts = co_consts
    return co
6.解压缩, 脱壳字节码
 
解压缩, 脱壳字节码, 也就是解压原先压缩壳中的bytes数据, 再使用marshal.loads()重新转换为bytecode, 并写入pyc文件。 
import sys,marshal,traceback
try:
    from importlib._bootstrap_external import MAGIC_NUMBER
except ImportError:
    from importlib._bootstrap import MAGIC_NUMBER
def dump_to_pyc(pycfilename,data,pycheader=None):
    # --snip-- 见前文
for file in sys.argv[1:]:
    try:
        with open(file,'rb') as f:
            d=f.read()
            if d[16]==227:  # 寻找数据开始的'\xe3'标志
                old_header=d[:16];d=d[16:]
            else:
                old_header=d[:12];d=d[12:]
            c=marshal.loads(d)
            modname=c.co_names[0] if len(c.co_names)>=1 else ''
            if modname in ('bz2','lzma','zlib'):
                mod=__import__(modname)
                data=mod.decompress(c.co_consts[2]) # 解压数据
                marshal.loads(data) # 测试解压后数据完整性
                dump_to_pyc(file,data,old_header)
                print('Processed:',file)
            else:
                raise TypeError('不是压缩的pyc文件: '+file)
    except Exception:
        traceback.print_exc()
前面介绍了Python字节码的压缩, 加壳和脱壳, 主要途径是修改字节码的指令, 以及修改、混淆变量名。
 Python 字节码这一特性有广泛的用途, 例如pyc文件加密、结构优化, 防止反编译pyc文件等, 可以用来做PyInstaller等库打包的exe的源码保护。
                                    zip文件的文件头包含 4 个字节的标识符 “PK\x03\x04”，其中 PK 是固定的标识，\x03\x04 是版本号。紧随其后的是版本特定的文件头结构（central directory 或 local file header），用于描述压缩文件的内容，包括文件名、时间戳、压缩方法等信息。tar文件的文件头是100字节的固定长度结构，包含文件名、文件模式、所有者、组、文件大小、修改时间等元数据信息。其后的数据区域包括多个部分，包括gzip文件头、压缩数据和文件尾等元数据信息。
                                    需要在从阿里云获取图片，进行图像处理，然后将生成图压缩到500kb以下上传到oss,不进行文件本地操作但是图片压缩需要用到 Image.save 函数，需要传入一个本地路径，这里可以使用bytesIO解决，不断修改 Image.save 的参数 quality 改变 生成图的大小直到小于 500kbimport oss2import PILclass OssFile(object):def __i...
                                    对.pyc或者.py文件进行保护 
①首先对安装环境 Python 路径下的 python.exe 进行加密。 
将 python.exe 拖入到加壳工具Virbox Protector Standalone中。 
②在加密选项页面将插件的ds按钮打开。 
③点击“立即加壳”，加壳后...
                                    我有一个用Adobe Flex 3和Python 2.5开发的Web应用程序(部署在Google App Engine上).已经在Python中创建了一个RESTful Web服务,其结果目前采用XML格式,Flex正在使用HttpService对象读取该格式.现在主要目标是压缩XML,以便HttpService send()方法和结果事件之间的时间更短.我查找了Python文档并设法使用zlib...
                                    zlib.decompress(data,15 32)应该自动检测是否有gzip数据或zlib数据.zlib.decompress(data,15 16)应该工作,如果gzip和barf如果zlib.这里是Python 2.7.1,创建一个gz文件,读回来,并解压缩它：>>> import gzip, zlib>>> f = gzip.open('foo.gz'...
                                    为了把python发行到没有安装python的Windows环境使用，需要打包成exe可执行文件。现在常见的python打包工具有cx_Freeze、PyInstaller和py2exe，想想我当初接触python的时候，似乎只有py2exe，而且有不少问题时光荏苒，一切过的真快。本文介绍PyInstaller打包的使用。一.准备工作安装PyWin32下载PyInstaller到http://ww...
                                    装壳”是一种保护应用程序，它是在代码中插入一段代码，用于控制、保护、隐藏、加密或修改应用程序的流程。一个经过包装的程序在加壳后不能被直接浏览或修改。攻击者将无法轻易地进行逆向工程或破解出程序的逻辑。Python程序加壳技术是一种可靠安全的保护代码方式，代码混淆和资源文件加壳已经成为了Python代码保护的常用方法。在选择加壳工具时，需要根据程序需求选择合适的加壳工具，同时要注意保持程序的正常运行、安全性和可靠性的平衡。本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是。
                                    最近在使用基于python的单片机pyboard，所以会考虑到单片机内存的问题，希望使用一种可以节省内存空间的数据存储格式，所以进行了相关的研究。
文章目录python内置函数`__sizeof__()`python可用的内置编码格式对比结果结论
python内置函数__sizeof__()
通过__sizeof__()可以对变量的内存进行检查，将不同的编码格式的内存情况打印出，对比得出较好的编码格式。
该方法返回给定对象所占用的内部空间大小(以字节为单位)。
python可用的内置编码格式
直接转换为.
                                    Here is the situation:I get gzipped xml documents from Amazon S3import botofrom boto.s3.connection import S3Connectionfrom boto.s3.key import Keyconn = S3Connection('access Id', 'secret access key')b ...
什么是shellcode
我在这里简单讲一下什么是Shellcode。Shellcode实际是一段代码（也可以是填充数据），是用来发送到服务器利用特定漏洞的代码，一般可以获取权限。另外，Shellcode一般是作为数据发送给受攻击服务的。
今天 让我来教大家如何编写py shellcode并且免杀，注入，以及转换成windows可执行文件
利用生成cpu可执行的代码
msfvenom -p windows/x64/exec