创建: 2023-05-10 16:43
更新: 2023-05-12 11:29
https://scz.617.cn/python/202305101643.txt
☆ 背景介绍
☆ pycdc源码浅析
☆ 部分增加/修改的指令示例
1) CALL_FUNCTION_KW
2) CALL_FUNCTION_EX/DICT_MERGE
3) SETUP_FINALLY
4) JUMP_IF_NOT_EXC_MATCH
5) RERAISE
☆ 后记
☆ 背景介绍
pycdc是款C++开发的开源Python反编译器，对Python 3.9有部分支持:
Decompyle++ A Python Byte-code Disassembler/Decompiler
https://github.com/zrax/pycdc
有几次用到它，小打小闹修补过。我不会C++，本文属于备忘笔记，必有谬误，只可借鉴，不可全信。
☆ pycdc源码浅析
查看ASTree.cpp
void decompyle(PycRef<PycCode> code, PycModule* mod)
{
/*
* 在此组织反编译结果
*/
PycRef<ASTNode> source = BuildFromCode(code, mod);
...
/*
* 在此输出反编译结果
*
* NODE_NODELIST (1)
*/
print_src(source, mod);
...
}
void print_src(PycRef<ASTNode> node, PycModule* mod)
{
...
switch (node->type()) {
case ASTNode::NODE_BLOCK:
{
...
/*
* 在此输出try、except这类关键字
*/
fprintf(pyc_output, "%s", blk->type_str());
...
} else if (blk->blktype() == ASTBlock::BLK_EXCEPT &&
blk.cast<ASTCondBlock>()->cond() != NULL) {
fputs(" ", pyc_output);
/*
* 在此输出"except KeyboardInterrupt"中的"KeyboardInterrupt"
*/
print_src(blk.cast<ASTCondBlock>()->cond(), mod);
} else if (blk->blktype() == ASTBlock::BLK_WITH) {
...
fputs(":n", pyc_output);
cur_indent++;
print_block(blk, mod);
cur_indent--;
}
break;
...
}
查看ASTNode.h
有两种重要数据类型，ASTNode、ASTBlock。ASTNode有如下类型
NODE_INVALID, NODE_NODELIST, NODE_OBJECT, NODE_UNARY, NODE_BINARY,
NODE_COMPARE, NODE_SLICE, NODE_STORE, NODE_RETURN, NODE_NAME,
NODE_DELETE, NODE_FUNCTION, NODE_CLASS, NODE_CALL, NODE_IMPORT,
NODE_TUPLE, NODE_LIST, NODE_SET, NODE_MAP, NODE_SUBSCR, NODE_PRINT,
NODE_CONVERT, NODE_KEYWORD, NODE_RAISE, NODE_EXEC, NODE_BLOCK,
NODE_COMPREHENSION, NODE_LOADBUILDCLASS, NODE_AWAITABLE,
NODE_FORMATTEDVALUE, NODE_JOINEDSTR, NODE_CONST_MAP,
NODE_ANNOTATED_VAR, NODE_CHAINSTORE, NODE_TERNARY
ASTBlock有如下类型
BLK_MAIN, BLK_IF, BLK_ELSE, BLK_ELIF, BLK_TRY,
BLK_CONTAINER, BLK_EXCEPT, BLK_FINALLY,
BLK_WHILE, BLK_FOR, BLK_WITH, BLK_ASYNCFOR
有多种ASTNode，反编译结果以ASTNode为基本单位进行组织。有些ASTNode简单，比如ASTReturn，有些ASTNode复杂，比如ASTBlock。ASTReturn、ASTBlock都是ASTNode的派生类。ASTBlock对应try块、except块这些。
RERAISE_test.py
def func () :
try :
x = 51201314
except :
pass
RERAISE_test.pycdump.asm
11 0 SETUP_FINALLY 8 (to 10)
12 2 LOAD_CONST 1 (51201314)
4 STORE_FAST 0 (x)
6 POP_BLOCK
8 JUMP_FORWARD 12 (to 22)
13 >> 10 POP_TOP
12 POP_TOP
14 POP_TOP
14 16 POP_EXCEPT
18 JUMP_FORWARD 2 (to 22)
20 RERAISE
>> 22 LOAD_CONST 0 (None)
24 RETURN_VALUE
组织反编译结果时，大致如此
NODE_NODELIST (1)
NODE_BLOCK (25) - BLK_CONTAINER (5) // func()
NODE_BLOCK (25) - BLK_TRY (4) // try
NODE_BLOCK (25) - BLK_EXCEPT (6) // except
NODE_RETURN (8) // return
最终的反编译输出
def func():
try:
x = 51201314
except:
pass
return None
BuildFromCode()组织反编译结果，具体解析每条指令
PycRef<ASTNode> BuildFromCode(PycRef<PycCode> code, PycModule* mod)
{
...
while (!source.atEof()) {
...
/*
* 修改pos，指向下一条待处理指令
*/
bc_next(source, mod, opcode, operand, pos);
...
switch (opcode) {
...
case Pyc::SETUP_FINALLY_A:
{
...
}
break;
...
default:
fprintf(stderr, "Unsupported opcode: %sn", Pyc::OpcodeName(opcode & 0xFF));
cleanBuild = false;
return new ASTNodeList(defblock->nodes());
}
...
}
if (stack_hist.size()) {
fputs("Warning: Stack history is not empty!n", stderr);
while (stack_hist.size()) {
stack_hist.pop();
}
}
if (blocks.size() > 1) {
fputs("Warning: block stack is not empty!n", stderr);
while (blocks.size() > 1) {
PycRef<ASTBlock> tmp = blocks.top();
blocks.pop();
blocks.top()->append(tmp.cast<ASTNode>());
}
}
cleanBuild = true;
return new ASTNodeList(defblock->nodes());
}
"pycdc some.pyc"若输出"Unsupported opcode: XXX"，表示XXX指令未被支持，该警告由BuildFromCode()发出。
"Unsupported opcode: XXX"中的"XXX"就是opname，假设是带参指令，"XXX"不包含后缀"_A"，但switch/case中带参指令有"_A"后缀。
对"Unsupported opcode: XXX"的修补在BuildFromCode()的switch/case中进行。
BuildFromCode()内部维护名为blocks[]的栈，用于存放解析后组织出来的ASTBlock。
☆ 部分增加/修改的指令示例
pycdc未支持的Python 3.9指令不少；还有一些指令貌似支持，但实际对标更低版本Python，并不对标3.9；这些都需要处理，此间只记录部分。
1) CALL_FUNCTION_KW
在ASTree.cpp中搜
case Pyc::CALL_FUNCTION_A
case Pyc::CALL_FUNCTION_KW_A
原实现对标3.5及更早版本，与3.9不兼容，参看
https://docs.python.org/3.4/library/dis.html
https://docs.python.org/3.9/library/dis.html
"case Pyc::CALL_FUNCTION_A"事实上可以不修改，因为operand不会很大，此时kwparams为0，测3.9也行。
"case Pyc::CALL_FUNCTION_KW_A"需要修改，下面是简单示例
case Pyc::CALL_FUNCTION_KW_A :
{
ASTCall::kwparam_t kwparamList;
ASTCall::pparam_t pparamList;
/*
* 当前指令的参数有两部分来源，一是operand，二是stack
*/
PycRef<ASTNode> kw = stack.top();
/*
* top()接pop()相当于汇编的弹栈取值，top()只取值不弹栈
*/
stack.pop();
/*
* 参看ASTNode.h，其中定义了各种NODE_*
*/
if ( kw.type() != ASTNode::NODE_OBJECT )
{
fprintf( stderr, "Unsupported argument found for CALL_FUNCTION_KWn" );
break;
}
/*
* 参看ASTNode.h，ASTObject是ASTNode子类，有各种各样的ASTNode子类
*/
PycRef<PycObject> obj = kw.cast<ASTObject>()->object();
/*
* 为什么是TYPE_SMALL_TUPLE，看Python字节码反汇编结果加强理解
*/
if ( obj->type() != PycObject::TYPE_SMALL_TUPLE )
{
fprintf( stderr, "Unsupported argument type found for CALL_FUNCTION_KWn" );
break;
}
std::vector<PycRef<PycObject>> karray = obj.cast<PycTuple>()->values();
/*
* 在此逆序，以方便后续组织kwparamList
*/
std::reverse( karray.begin(), karray.end() );
/*
* 3.6及以上版本，获取kwparams的方式不同于低版本
*/
int kwparams = (int)karray.size();
int pparams = operand - kwparams;
for ( auto& k : karray )
{
PycRef<ASTNode> val = stack.top();
stack.pop();
PycRef<ASTNode> key = new ASTObject( k );
kwparamList.push_front( std::make_pair( key, val ) );
}
for ( int i = 0; i < pparams; i++ )
{
/*
* the right-most positional parameter on top
*/
pparamList.push_front( stack.top() );
stack.pop();
}
/*
* Below the arguments is a callable object to call.
*/
PycRef<ASTNode> func = stack.top();
stack.pop();
PycRef<ASTNode> call = new ASTCall( func, pparamList, kwparamList );
// call.cast<ASTCall>()->setKW( kw );
/*
* 不着急输出，先压栈，以后随ASTBlock一起输出
*/
stack.push( call );
}
break;
CALL_FUNCTION_KW_test.py
import dis
def func () :
func_4( 0, b=1 )
dis.dis( func )
func()的反汇编
11 0 LOAD_GLOBAL 0 (func_4)
2 LOAD_CONST 1 (0)
4 LOAD_CONST 2 (1)
6 LOAD_CONST 3 (('b',))
8 CALL_FUNCTION_KW 2
10 POP_TOP
12 LOAD_CONST 0 (None)
14 RETURN_VALUE
假设读者具有Python字节码功底，不多解释。
2) CALL_FUNCTION_EX/DICT_MERGE
CALL_FUNCTION_EX_test.py
import dis
def func () :
func_6_0( 0, **{"a":1, "b":2} )
func_6_1( *[1, 2, 3] )
dis.dis( func )
11 0 LOAD_GLOBAL 0 (func_6_0)
2 LOAD_CONST 6 ((0,))
4 BUILD_MAP 0
6 LOAD_CONST 2 (1)
8 LOAD_CONST 3 (2)
10 LOAD_CONST 4 (('a', 'b'))
12 BUILD_CONST_KEY_MAP 2
14 DICT_MERGE 1
16 CALL_FUNCTION_EX 1
18 POP_TOP
12 20 LOAD_GLOBAL 1 (func_6_1)
22 BUILD_LIST 0
24 LOAD_CONST 5 ((1, 2, 3))
26 LIST_EXTEND 1
28 CALL_FUNCTION_EX 0
30 POP_TOP
32 LOAD_CONST 0 (None)
34 RETURN_VALUE
DICT_MERGE、CALL_FUNCTION_EX未被支持，需要增加
/*
* DICT_MERGE(i) calls dict.update(TOS1[-i], TOS), raises an exception for
* duplicate keys. Used to build dicts. New in version 3.9.
*/
case Pyc::DICT_MERGE_A :
{
/*
* 简单处理operand，暂不考虑非1情形
*/
if ( operand != 1 )
{
fprintf( stderr, "Unsupported operand found for DICT_MERGEn" );
break;
}
PycRef<ASTNode> dict = stack.top();
stack.pop();
if ( dict.type() != ASTNode::NODE_CONST_MAP )
{
fprintf( stderr, "Unsupported argument found for DICT_MERGEn" );
break;
}
/*
* 本来是dict.update(TOS1[-i], TOS)，但暂时只处理i=1的情形
*/
stack.pop();
stack.push( dict );
}
break;
case Pyc::CALL_FUNCTION_EX_A :
{
ASTCall::kwparam_t kwparamList;
ASTCall::pparam_t pparamList;
PycRef<ASTNode> kw;
if ( ( operand & 0x1 ) != 0 )
{
kw = stack.top();
stack.pop();
if ( kw.type() != ASTNode::NODE_CONST_MAP )
{
fprintf( stderr, "Unsupported argument found for CALL_FUNCTION_EXn" );
break;
}
}
PycRef<ASTNode> var = stack.top();
stack.pop();
if ( var.type() == ASTNode::NODE_OBJECT )
{
PycRef<PycObject> obj = var.cast<ASTObject>()->object();
if ( obj->type() != PycObject::TYPE_SMALL_TUPLE )
{
fprintf( stderr, "Unsupported argument type found for CALL_FUNCTION_EXn" );
break;
}
std::vector<PycRef<PycObject>> varray = obj.cast<PycTuple>()->values();
for ( auto& v : varray )
{
PycRef<ASTNode> val = new ASTObject( v );
pparamList.push_front( val );
}
}
PycRef<ASTNode> func = stack.top();
stack.pop();
PycRef<ASTNode> call = new ASTCall( func, pparamList, kwparamList );
// fprintf( stderr, "var.type()=%dn", var.type() );
// NODE_OBJECT(2)
// NODE_LIST(16)
if ( var.type() != ASTNode::NODE_OBJECT )
{
/*
* 对应"*[1, 2, 3]"这种参数
*/
call.cast<ASTCall>()->setVar( var );
}
if ( ( operand & 0x1 ) != 0 )
{
/*
* 对应"**{"a":1, "b":2}"这种参数
*/
call.cast<ASTCall>()->setKW( kw );
}
stack.push( call );
}
break;
3) SETUP_FINALLY
3.9没有SETUP_EXCEPT，全部揉进SETUP_FINALLY。在ASTree.cpp中合并这两个case
case Pyc::SETUP_EXCEPT_A
case Pyc::SETUP_FINALLY_A
只是应急方案，有一堆后遗症。
4) JUMP_IF_NOT_EXC_MATCH
case Pyc::JUMP_IF_NOT_EXC_MATCH_A :
{
PycRef<ASTNode> name = stack.top();
stack.pop();
stack.pop();
/*
* 并不完备，仅为示例，组织"except KeyboardInterrupt"中的
* "KeyboardInterrupt"
*/
if ( name->type() == ASTNode::NODE_NAME && !blocks.empty() && blocks.top()->blktype() == ASTBlock::BLK_EXCEPT )
{
PycRef<ASTBlock> prev = blocks.top();
blocks.pop();
PycRef<ASTBlock> next = new ASTCondBlock( prev->blktype(), prev->end(), name, prev.cast<ASTCondBlock>()->negative() );
next->init();
blocks.push( next );
curblock = blocks.top();
}
}
break;
pycdc需做大量模式匹配，基于经验结论组织反编译结果，JUMP_IF_NOT_EXC_MATCH的前导指令不一定是LOAD_NAME，上例只处理了这一种情形。
5) RERAISE
case Pyc::RERAISE :
{
// stack.pop();
// stack.pop();
// stack.pop();
PycRef<ASTBlock> prev = blocks.top();
/*
* 并不完备，仅为示例
*/
if
(
!blocks.empty() &&
prev->nodes().size() &&
prev->nodes().back().type() == ASTNode::NODE_BLOCK &&
prev->nodes().back().cast<ASTBlock>()->blktype() == ASTBlock::BLK_EXCEPT
)
{
blocks.pop();
blocks.top()->append( prev.cast<ASTNode>() );
}
}
break;
一上来就弹了三次栈，这个操作可能不对，毕竟这是反编译过程，而非执行过程，反编译时POP_EXCEPT就啥也没干，但实在懒得测试各种情形，将就对付吧。
☆ 后记
pycdc将各种Python版本的指令放在一起处理，这样干的坏处太多。比如某指令在几个Python版本之间发生变化，pycdc很可能未测试到此情形，但又不发出警告，最后反编译结果一乱糟，很难定位root cause。pycdc已为向后兼容性所拖累，其代码可维护性越来越差，感觉作者只是在垂死挣扎。
开发Python反编译器，最大困难是CFG模式识别，纯体力活，需要精心准备各种测试用例，一不留神就覆盖不到，这得是靠爱发电的人干的事儿。
我没有大修过pycdc。
原文始发于微信公众号（青衣十三楼飞花堂）：针对Python 3.9修改pycdc源码示例
免责声明:文章中涉及的程序(方法)可能带有攻击性，仅供安全研究与教学之用，读者将其信息做其他用途，由读者承担全部法律及连带责任，本站不承担任何法律及连带责任；如有问题可邮件联系(建议使用企业邮箱或有效邮箱,避免邮件被拦截，联系方式见首页)，望知悉。
- 左青龙
- 微信扫一扫
-
- 右白虎
- 微信扫一扫
-
评论