记一次手撸CPython bytecode

上周末的0CTF出现了一个pyc的题目,但是Pyopcode损坏,于是手撸了一波

题目: https://github.com/Hcamael/CTF_repo/tree/master/0CTF%202017/Re3%28py%29

通过pyc还原出py网上的资料挺多了,py也有专门的库可以还原,但是0CTF这题却无法还原,目测是opcode损坏,同时根据题目描述,也知道是要修复pyc文件。

这里用到两个库,一个dis,可以把二进制反编译CPython bytecode。一个是marshal,可以把字符串转换成pyopcode对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
>>> import dis, marshal
>>> f = open("crypt.pyc")
>>> f.read(4)
'\x03\xf3\r\n' # magic number
>>> f.read(4) # time
'f4oX'
>>> code = marshal.load(f)
# 对我们有用的属性有:
>>> code.co_argcount # 参数的个数
0
>>> code.co_varnames # 局部变量
()
>>> code.co_consts # 常量
(-1, None, <code object encrypt at 0x7f1987df65b0, file "/Users/hen/Lab/0CTF/py/crypt.py", line 2>, <code object decrypt at 0x7f1987e10430, file "/Users/hen/Lab/0CTF/py/crypt.py", line 10>)
# 从这个常量中我们可以看出,该py文件中定义了两个函数,encrypt和decrypt
>>> code.co_code
'\x99\x00\x00\x99\x01\x00\x86\x00\x00\x91\x00\x00\x99\x02\x00\x88\x00\x00\x91\x01\x00\x99\x03\x00\x88\x00\x00\x91\x02\x00\x99\x01\x00S'
# Cpython bytecode的二进制, 可以通过dis反编译
>>> dis.disassemble_string(code.co_code)
0 <153> 0
3 <153> 1
6 MAKE_CLOSURE 0
9 EXTENDED_ARG 0
12 <153> 2
15 LOAD_DEREF 0
18 EXTENDED_ARG 1
21 <153> 3
24 LOAD_DEREF 0
27 EXTENDED_ARG 2
30 <153> 1
33 RETURN_VALUE
# 发现bytecode损坏,根本无法阅读

二进制对应的bytecode可以参考: https://github.com/python/cpython/blob/2.7/Include/opcode.h

从上面的参考连接可以得知153没有对应的bytecode,所以猜测bytecode损坏

每个bytecode所代表的意义: https://docs.python.org/2/library/dis.html

1
2
3
4
5
>>> code.co_name # 当前对象名
'<module>'
>>> code.co_names # 当前对象中使用的对象名
('rotor', 'encrypt', 'decrypt')
# 从上可以看出,encrypt和decrypt是我们定义的两个函数,那么rotor我们可以猜测是通过import rotor得来的

rotor的使用可以参考: https://docs.python.org/2.0/lib/module-rotor.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 我们可以通过以下方式查看两个函数中的信息
>>> enc = code.co_consts[2]
>>> dec = code.co_consts[3]
>>> enc.co_argcount
1
>>> dec.co_argcount
1
# 两个函数中都有一个传入的参数
>>> enc.co_varnames
('data', 'key_a', 'key_b', 'key_c', 'secret', 'rot')
>>> dec.co_varnames
('data', 'key_a', 'key_b', 'key_c', 'secret', 'rot')
# 两个函数中的局部变量, 我们可以猜测,data是传入的参数,需要加解密的数据
>>> enc.co_consts
(None, '!@#$%^&*', 'abcdefgh', '<>{}:"', 4, '|', 2, 'EOF')
>>> dec.co_consts
(None, '!@#$%^&*', 'abcdefgh', '<>{}:"', 4, '|', 2, 'EOF')
# 两个函数中的常量,我们可以猜测key_a, key_b, key_c三个变量对应的值
>>> enc.co_code
"\x99\x01\x00h\x01\x00\x99\x02\x00h\x02\x00\x99\x03\x00h\x03\x00a\x01\x00\x99\x04\x00F\x99\x05\x00'a\x02\x00a\x01\x00'a\x03\x00'\x99\x06\x00F'\x99\x05\x00'a\x02\x00\x99\x06\x00F'\x99\x07\x00'h\x04\x00\x9b\x00\x00`\x01\x00a\x04\x00\x83\x01\x00h\x05\x00a\x05\x00`\x02\x00a\x00\x00\x83\x01\x00S"
>>> dec.co_code
"\x99\x01\x00h\x01\x00\x99\x02\x00h\x02\x00\x99\x03\x00h\x03\x00a\x01\x00\x99\x04\x00F\x99\x05\x00'a\x02\x00a\x01\x00'a\x03\x00'\x99\x06\x00F'\x99\x05\x00'a\x02\x00\x99\x06\x00F'\x99\x07\x00'h\x04\x00\x9b\x00\x00`\x01\x00a\x04\x00\x83\x01\x00h\x05\x00a\x05\x00`\x02\x00a\x00\x00\x83\x01\x00S"
# 发现两个函数bytecode的二进制是一样的,操作是一样的?
>>> enc.co_name
'encrypt'
>>> enc.co_names
('rotor', 'newrotor', 'encrypt')
>>> dec.co_name
'decrypt'
>>> dec.co_names
('rotor', 'newrotor', 'decrypt')
# 通过研究rotor的用法,猜测两个函数的区别可能是在于rotor.newrotor(key).encrypt(data)和rotor.newrotor(key).decrypt(data)

所以现在的问题就在于,key是怎么来的,然后就开始了手撸CPython bytecode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
>>> dis.disassemble_string(dec.co_code)
0 <153> 1
3 BUILD_SET 1
6 <153> 2
9 BUILD_SET 2
12 <153> 3
15 BUILD_SET 3
18 STORE_GLOBAL 1 (1)
21 <153> 4
24 PRINT_EXPR
25 <153> 5
28 <39>
29 STORE_GLOBAL 2 (2)
32 STORE_GLOBAL 1 (1)
35 <39>
36 STORE_GLOBAL 3 (3)
39 <39>
40 <153> 6
43 PRINT_EXPR
44 <39>
45 <153> 5
48 <39>
49 STORE_GLOBAL 2 (2)
52 <153> 6
55 PRINT_EXPR
56 <39>
57 <153> 7
60 <39>
61 BUILD_SET 4
64 <155> 0
67 DELETE_ATTR 1 (1)
70 STORE_GLOBAL 4 (4)
73 CALL_FUNCTION 1
76 BUILD_SET 5
79 STORE_GLOBAL 5 (5)
82 DELETE_ATTR 2 (2)
85 STORE_GLOBAL 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE

右边的数字为操作数,括号里的是注释

因为题目啥信息也没给我们。。。所以修bytecode只能靠猜

我们先假设这里所有的153为同一个操作符,同理所有的39也为同一个

先看第一部分

1
2
3
4
5
6
0 <153> 1
3 BUILD_SET 1
6 <153> 2
9 BUILD_SET 2
12 <153> 3
15 BUILD_SET 3

这是最容易猜的地方,右边的操作数为123,在看常量和局部变量的tuple,可以猜测是:

1
2
3
key_a = '!@#$%^&*'
key_b = 'abcdefgh'
key_c = '<>{}:"'

然后去上面给的参考文档里,查出对应的bytecode

1
2
3
4
5
6
0 LOAD_CONST 1
3 STORE_FAST 1
6 LOAD_CONST 2
9 STORE_FAST 2
12 LOAD_CONST 3
15 STORE_FAST 3

再去opcode.h中查其对应的值进行替换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
>>> dis.disassemble_string(dec.co_code.replace("\x99","\x64").replace("\x68","\x7d"))
0 LOAD_CONST 1 (1)
3 STORE_FAST 1 (1)
6 LOAD_CONST 2 (2)
9 STORE_FAST 2 (2)
12 LOAD_CONST 3 (3)
15 STORE_FAST 3 (3)
18 STORE_GLOBAL 1 (1)
21 LOAD_CONST 4 (4)
24 PRINT_EXPR
25 LOAD_CONST 5 (5)
28 <39>
29 STORE_GLOBAL 2 (2)
32 STORE_GLOBAL 1 (1)
35 <39>
36 STORE_GLOBAL 3 (3)
39 <39>
40 LOAD_CONST 6 (6)
43 PRINT_EXPR
44 <39>
45 LOAD_CONST 5 (5)
48 <39>
49 STORE_GLOBAL 2 (2)
52 LOAD_CONST 6 (6)
55 PRINT_EXPR
56 <39>
57 LOAD_CONST 7 (7)
60 <39>
61 STORE_FAST 4 (4)
64 <155> 0
67 DELETE_ATTR 1 (1)
70 STORE_GLOBAL 4 (4)
73 CALL_FUNCTION 1
76 STORE_FAST 5 (5)
79 STORE_GLOBAL 5 (5)
82 DELETE_ATTR 2 (2)
85 STORE_GLOBAL 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE

继续,发现肛不动了。。。。然后从底下开始肛

1
2
3
4
5
6
7
8
9
10
64 <155> 0
67 DELETE_ATTR 1 (1)
70 STORE_GLOBAL 4 (4)
73 CALL_FUNCTION 1
76 STORE_FAST 5 (5)
79 STORE_GLOBAL 5 (5)
82 DELETE_ATTR 2 (2)
85 STORE_GLOBAL 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE

根据之前得到的结论,可以猜测这里的代码是:

1
2
xxx = rotor.newrotor(secret)
return xxx.decrypt(data)

所以猜测上面的操作数,0指的是局部变量data,1指的是全局变量newrotor, 2猜测可能是全局变量decrypt, 4指的是局部变量secret, 5指的是局部变量rot,<155>的0可能指的是全局变量rotor

然后查找bytecode,改成:

1
2
3
4
5
6
7
8
9
10
64 LOAD_GLOBAL 0
67 LOAD_ATTR 1 (1)
70 LOAD_FAST 4 (4)
73 CALL_FUNCTION 1
76 STORE_FAST 5 (5)
79 LOAD_FAST 5 (5)
82 LOAD_ATTR 2 (2)
85 LOAD_FAST 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE

发现,合情合理,使人姓胡…..

然后和上面一样,整体替换bytecode:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
>>> dis.disassemble_string(dec.co_code.replace("\x99","\x64").replace("\x68","\x7d").replace("\x61","\x7c").replace("\x60","\x6a").replace("\x9b","\x74"))
0 LOAD_CONST 1 (1)
3 STORE_FAST 1 (1)
6 LOAD_CONST 2 (2)
9 STORE_FAST 2 (2)
12 LOAD_CONST 3 (3)
15 STORE_FAST 3 (3)
18 LOAD_FAST 1 (1)
21 LOAD_CONST 4 (4)
24 PRINT_EXPR
25 LOAD_CONST 5 (5)
28 <39>
29 LOAD_FAST 2 (2)
32 LOAD_FAST 1 (1)
35 <39>
36 LOAD_FAST 3 (3)
39 <39>
40 LOAD_CONST 6 (6)
43 PRINT_EXPR
44 <39>
45 LOAD_CONST 5 (5)
48 <39>
49 LOAD_FAST 2 (2)
52 LOAD_CONST 6 (6)
55 PRINT_EXPR
56 <39>
57 LOAD_CONST 7 (7)
60 <39>
61 STORE_FAST 4 (4)
64 LOAD_GLOBAL 0 (0)
67 LOAD_ATTR 1 (1)
70 LOAD_FAST 4 (4)
73 CALL_FUNCTION 1
76 STORE_FAST 5 (5)
79 LOAD_FAST 5 (5)
82 LOAD_ATTR 2 (2)
85 LOAD_FAST 0 (0)
88 CALL_FUNCTION 1
91 RETURN_VALUE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
18 LOAD_FAST 1 (1)
21 LOAD_CONST 4 (4)
24 PRINT_EXPR
25 LOAD_CONST 5 (5)
28 <39>
29 LOAD_FAST 2 (2)
32 LOAD_FAST 1 (1)
35 <39>
36 LOAD_FAST 3 (3)
39 <39>
40 LOAD_CONST 6 (6)
43 PRINT_EXPR
44 <39>
45 LOAD_CONST 5 (5)
48 <39>
49 LOAD_FAST 2 (2)
52 LOAD_CONST 6 (6)
55 PRINT_EXPR
56 <39>
57 LOAD_CONST 7 (7)
60 <39>
61 STORE_FAST 4 (4)

猜测这部分就是局部变量secret计算的方法,最后一句STORE_FAST 4,猜测就是把上面计算后的值储存到secret

整体看看,发现主要就剩<39>PRINT_EXPR不通顺了。。。然后他们都是没操作数的,所以排除了调用函数,调用属性之类的

之后联想到最开头对key_a, key_b, key_c的赋值,然后目前的bytecode中没有任何运算操作

再来看这部分

1
2
3
18 LOAD_FAST 1 ("!@#$%^&*")
21 LOAD_CONST 4 (4)
24 PRINT_EXPR

所以猜测PRINT_EXPR, 是字符串和整型之间的操作运算

1
2
3
29 LOAD_FAST 2 ("abcdefgh")
32 LOAD_FAST 1 ("!@#$%^&*")
35 <39>

这里猜测<39>是字符串和字符串之间的操作运算

到这里,我们来想想,整型和字符串之间的操作有啥?

1
2
3
4
>>> "a"*3
>>> "aaa"[1]
>>> "aaa"[:1]
>>> "aaa"[1:]

字符串和字符串之间呢?

1
>>> "aaa" + "bbb" # 我只想到了这一个

从上面可以猜测出,<39>可能是字符串拼接的操作,然后PRINT_EXPR需要一个一个去试,现在我们可以还原出decrypt函数了:

1
2
3
4
5
6
7
8
9
10
11
# import rotor
def decrypt(data):
key_a = "!@#$%^&*"
key_b = "abcdefgh"
key_c = '<>{}:"'
secret=key_a*4 + "|" + (key_b+key_a+key_c)*2 + "|" + key_b*2 + "EOF"
# secret=key_a[4] + "|" + (key_b+key_a+key_c)[2] + "|" + key_b[2] + "EOF"
# secret=key_a[4:] + "|" + (key_b+key_a+key_c)[2:] + "|" + key_b[2:] + "EOF"
# secret=key_a[:4] + "|" + (key_b+key_a+key_c)[:2] + "|" + key_b[:2] + "EOF"
rot = rotor.newrotor(secret)
return rot.decrypt(data)

简直难受…….

文章目录