Canvas is not supported in your browser.
首页 课程 文章
无痕注入 APC注入 线程注入 读写驱动 注入技术 句柄表 进程线程 系统调用 保护模式 内存管理 远程CALL 软件调试 驱动封装 云下发 驱动开发 FPS数据 方框透视 FPS方框 FPS自瞄 CE D3DHOOK D3D绘制 Imgui绘制 DWM
内核课程 驱动出租 学习路线 聊天室 免责声明 提问技巧

CTF对抗- 第四题 神秘信号 简短writeup

推荐 原创

周杰伦

文章分类 CTF对抗 阅读数 : 97 阅读时长 : 9分钟


【CTF对抗- 第四题 神秘信号 简短writeup】此文章归类为：CTF对抗。

随便写一些吧 这两天看了一眼第四题感觉很有意思 并且没有那种大规模的混淆和逆向适合我这种逆向菜鸟

从下载下来后本题是一个pyinstaller打包的程序,并且通过在线解包或者工具解包后反编译后可以得到其main.py的大部分代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import CrackMe
print('(账号密码由字母大小写、数字、!、空格组成)')
print('请输入账号：')
h = input()
z = CrackMe.main(h)
if len(z) < 20:
    key = 'dZpKdrsiB6cndrGY' + z
else:
    key = z[0:4] + 'dZpK' + z[4:8] + 'drsi' + z[8:12] + 'B6cn' + z[12:16] + 'drGY' + z[16:]
print('请输入验证码：')
h = input()
m = CrackMe.main(h)
if key == m:
    print('Success')
print('Fail')

所以我们不知道CrackMe模块是什么.这里在做题的时候就掉到了一个rabbit hole中.想的是出题人是否魔改了一些pyinstaller的东西导致了一些问题.后来发现并没有.同时由于他的合法输入输出有些规律可循所以我就猜出来了他的一些变换然后经过一些小爆破分割位置和Hello Wolrd!的信息.最后做出来了
当然这个比较非预期,于是下文主要探究下这个题的有趣预期解

经过diff后我把目光转到了_internal\base_library.zip

他的主逻辑入口藏到了_internal\base_library.zip中,由于我们在前文知道了我们没有模块CrackMe而且不是pyinstaller的问题.同时在base_library中其实有些数据的代码和原始文件不太一样,另外可以参考下作者发过的一篇文章关于import过程https://bbs.kanxue.com/thread-276520.htm .从我们的角度上来看_internal\base_library\codecs.pyc确实里面还有一些其他的逻辑比如这里(代码经过pycdump并且手撸)

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
def fun(name):
    a = 0
     
    if len(name) == 7 and name[0] == 'C' and name[1] == 'r' and name[2] == 'a' and \
       name[3] == 'c' and name[4] == 'k' and name[5] == 'M' and name[6] == 'e':
        name = 'base64'
        a = 1
 
    module = sys.modules.get(name, _NEEDS_LOADING)
 
    if module is _NEEDS_LOADING:
        with _ModuleLockManager(name):
            module = sys.modules.get(name, _NEEDS_LOADING)
 
    if module is _NEEDS_LOADING and a == 1:
        m = _find_and_load_unlocked(name, import_)
         
        for i in dir(m):
            if i not in ['__builtins__', '__cached__', '__loader__', '__package__', '__spec__']:
                if len(i) == 4 and i == 'main':
                    delattr(m, i)
                # More checks for attributes 'a', 'i', 'n'
     
    # Cleanup and return
    _lock_unlock_module(name)
    return None
sys.modules['_frozen_importlib']._find_and_load.__code__ = fun.__code__

经过还原后差不多是这样他劫持了import的过程比如name是crackme他会指向base64
并且他还会删除掉已有的base64相关的main函数以防止其他的调用出现冲突
然后sys.modules['_frozen_importlib']._find_and_load.code = fun.__code__就是主要劫持的部分
这个详细可以在https://bbs.kanxue.com/thread-276520.htm 这篇文章中有比较详细的过程说明
然后我们可以翻一下解包后pyinstaller的base64.pyc 并且对其进行反编译发现其还存在这样的一段逻辑

1
2
a = main.__code__.replace(1, (), b'd%01}%01d%02}%02d%03}%03d%04}%04|%00D%00]%1c}%05|%05d%05A%00}%05|%04|%05%a0%00d%06d%07%a1%02%17%00}%04q%14|%04}%00t%01d%02t%02|%00%83%01d%08%83%03D%00]%90}%05|%00|%05|%05d%08%17%00%85%02%19%00}%06d%01%a0%03d\td\n%84%00|%06D%00%83%01%a1%01}%07t%01d%02t%02|%07%83%01d%0b%83%03D%00]V}%08|%07|%08|%08d%0b%17%00%85%02%19%00}\tt%02|\t%83%01d%0bk%00r%c2|%02d%0bt%02|\t%83%01%18%007%00}%02|\td%0cd%0bt%02|\t%83%01%18%00%14%007%00}\t|%01|%03t%04|\td\r%83%02%19%007%00}%01q~qF|%01d%0e|%02d\r%1a%00%14%007%00}%01t%01t%02|%01%83%01d\r%1a%00%83%01D%00]L}%05|%01|%05d\r%14%00%19%00}\n|%01|%05d\r%14%00d%06%17%00%19%00}%0b|%01d%00|%05d\r%14%00%85%02%19%00|%0b%17%00|\n%17%00|%01|%05d\r%14%00d\r%17%00d%00%85%02%19%00%17%00}%01q%f8|%01S%00', (None, '', 0, 'ZQ+U7tSBEKVzyf5coCwb94Dd6raT0eLNin12Hp8mOxFuvMgIPlhRY3WjksqJAXG/', b'', 85, 1, 'little', 3, compile('', '', 'exec').replace(1, (), b'|%00]%10}%01t%00|%01d%00%83%02V%00%01%00q%02d%01S%00', ('08b', None), '', 19, 115, (), 0, b'', '', ('format',), 2, 0, 4, ('.0', 'byte'), **('co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_kwonlyargcount', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_posonlyargcount', 'co_stacksize', 'co_varnames')), '', 6, '0', 2, '!'), '', 4, 67, (), 0, b'', '', ('to_bytes', 'range', 'len', 'join', 'int'), 12, 0, 7, ('data', 'encoded_str', 'padding', 'base64_chars', 'ww', 'i', 'chunk', 'binary_str', 'j', 'six_bits', 'a', 'b'), **('co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_kwonlyargcount', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_posonlyargcount', 'co_stacksize', 'co_varnames'))
main.__code__ = a

其替换了base64.main的函数并且填充自己的内容,这里我们为了方便可以在该反编译后的目录进行

1
2
3
import base64
import dis
dis.dis(base64.main)

之后我们就可以得到patch后的base64.main的function的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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
  4           0 LOAD_CONST               1 ('')
              2 STORE_FAST               1 (encoded_str)
              4 LOAD_CONST               2 (0)
              6 STORE_FAST               2 (padding)
              8 LOAD_CONST               3 ('ZQ+U7tSBEKVzyf5coCwb94Dd6raT0eLNin12Hp8mOxFuvMgIPlhRY3WjksqJAXG/')
             10 STORE_FAST               3 (base64_chars)
             12 LOAD_CONST               4 (b'')
             14 STORE_FAST               4 (ww)
             16 LOAD_FAST                0 (data)
             18 GET_ITER
        >>   20 FOR_ITER                28 (to 50)
             22 STORE_FAST               5 (i)
             24 LOAD_FAST                5 (i)
             26 LOAD_CONST               5 (85)
             28 BINARY_XOR
             30 STORE_FAST               5 (i)
             32 LOAD_FAST                4 (ww)
             34 LOAD_FAST                5 (i)
             36 LOAD_METHOD              0 (to_bytes)
             38 LOAD_CONST               6 (1)
             40 LOAD_CONST               7 ('little')
             42 CALL_METHOD              2
             44 BINARY_ADD
             46 STORE_FAST               4 (ww)
             48 JUMP_ABSOLUTE           20
        >>   50 LOAD_FAST                4 (ww)
             52 STORE_FAST               0 (data)
             54 LOAD_GLOBAL              1 (range)
             56 LOAD_CONST               2 (0)
             58 LOAD_GLOBAL              2 (len)
             60 LOAD_FAST                0 (data)
             62 CALL_FUNCTION            1
             64 LOAD_CONST               8 (3)
             66 CALL_FUNCTION            3
             68 GET_ITER
        >>   70 FOR_ITER               144 (to 216)
             72 STORE_FAST               5 (i)
             74 LOAD_FAST                0 (data)
             76 LOAD_FAST                5 (i)
             78 LOAD_FAST                5 (i)
             80 LOAD_CONST               8 (3)
             82 BINARY_ADD
             84 BUILD_SLICE              2
             86 BINARY_SUBSCR
             88 STORE_FAST               6 (chunk)
             90 LOAD_CONST               1 ('')
             92 LOAD_METHOD              3 (join)
             94 LOAD_CONST               9 (<code object  at 0x0000029CAAC75920, file "", line 19>)
             96 LOAD_CONST              10 ('')
             98 MAKE_FUNCTION            0
            100 LOAD_FAST                6 (chunk)
            102 GET_ITER
            104 CALL_FUNCTION            1
            106 CALL_METHOD              1
            108 STORE_FAST               7 (binary_str)
            110 LOAD_GLOBAL              1 (range)
            112 LOAD_CONST               2 (0)
            114 LOAD_GLOBAL              2 (len)
            116 LOAD_FAST                7 (binary_str)
            118 CALL_FUNCTION            1
            120 LOAD_CONST              11 (6)
            122 CALL_FUNCTION            3
            124 GET_ITER
        >>  126 FOR_ITER                86 (to 214)
            128 STORE_FAST               8 (j)
            130 LOAD_FAST                7 (binary_str)
            132 LOAD_FAST                8 (j)
            134 LOAD_FAST                8 (j)
            136 LOAD_CONST              11 (6)
            138 BINARY_ADD
            140 BUILD_SLICE              2
            142 BINARY_SUBSCR
            144 STORE_FAST               9 (six_bits)
            146 LOAD_GLOBAL              2 (len)
            148 LOAD_FAST                9 (six_bits)
            150 CALL_FUNCTION            1
            152 LOAD_CONST              11 (6)
            154 COMPARE_OP               0 (<)
            156 POP_JUMP_IF_FALSE      194
            158 LOAD_FAST                2 (padding)
            160 LOAD_CONST              11 (6)
            162 LOAD_GLOBAL              2 (len)
            164 LOAD_FAST                9 (six_bits)
            166 CALL_FUNCTION            1
            168 BINARY_SUBTRACT
            170 INPLACE_ADD
            172 STORE_FAST               2 (padding)
            174 LOAD_FAST                9 (six_bits)
            176 LOAD_CONST              12 ('0')
            178 LOAD_CONST              11 (6)
            180 LOAD_GLOBAL              2 (len)
            182 LOAD_FAST                9 (six_bits)
            184 CALL_FUNCTION            1
            186 BINARY_SUBTRACT
            188 BINARY_MULTIPLY
            190 INPLACE_ADD
            192 STORE_FAST               9 (six_bits)
        >>  194 LOAD_FAST                1 (encoded_str)
            196 LOAD_FAST                3 (base64_chars)
            198 LOAD_GLOBAL              4 (int)
            200 LOAD_FAST                9 (six_bits)
            202 LOAD_CONST              13 (2)
            204 CALL_FUNCTION            2
            206 BINARY_SUBSCR
            208 INPLACE_ADD
            210 STORE_FAST               1 (encoded_str)
            212 JUMP_ABSOLUTE          126
        >>  214 JUMP_ABSOLUTE           70
        >>  216 LOAD_FAST                1 (encoded_str)
            218 LOAD_CONST              14 ('!')
            220 LOAD_FAST                2 (padding)
            222 LOAD_CONST              13 (2)
            224 BINARY_FLOOR_DIVIDE
            226 BINARY_MULTIPLY
            228 INPLACE_ADD
            230 STORE_FAST               1 (encoded_str)
            232 LOAD_GLOBAL              1 (range)
            234 LOAD_GLOBAL              2 (len)
            236 LOAD_FAST                1 (encoded_str)
            238 CALL_FUNCTION            1
            240 LOAD_CONST              13 (2)
            242 BINARY_FLOOR_DIVIDE
            244 CALL_FUNCTION            1
            246 GET_ITER
        >>  248 FOR_ITER                76 (to 326)
            250 STORE_FAST               5 (i)
            252 LOAD_FAST                1 (encoded_str)
            254 LOAD_FAST                5 (i)
            256 LOAD_CONST              13 (2)
            258 BINARY_MULTIPLY
            260 BINARY_SUBSCR
            262 STORE_FAST              10 (a)
            264 LOAD_FAST                1 (encoded_str)
            266 LOAD_FAST                5 (i)
            268 LOAD_CONST              13 (2)
            270 BINARY_MULTIPLY
            272 LOAD_CONST               6 (1)
            274 BINARY_ADD
            276 BINARY_SUBSCR
            278 STORE_FAST              11 (b)
            280 LOAD_FAST                1 (encoded_str)
            282 LOAD_CONST               0 (None)
            284 LOAD_FAST                5 (i)
            286 LOAD_CONST              13 (2)
            288 BINARY_MULTIPLY
            290 BUILD_SLICE              2
            292 BINARY_SUBSCR
            294 LOAD_FAST               11 (b)
            296 BINARY_ADD
            298 LOAD_FAST               10 (a)
            300 BINARY_ADD
            302 LOAD_FAST                1 (encoded_str)
            304 LOAD_FAST                5 (i)
            306 LOAD_CONST              13 (2)
            308 BINARY_MULTIPLY
            310 LOAD_CONST              13 (2)
            312 BINARY_ADD
            314 LOAD_CONST               0 (None)
            316 BUILD_SLICE              2
            318 BINARY_SUBSCR
            320 BINARY_ADD
            322 STORE_FAST               1 (encoded_str)
            324 JUMP_ABSOLUTE          248
        >>  326 LOAD_FAST                1 (encoded_str)
            328 RETURN_VALUE
 
Disassembly of <code object  at 0x0000029CAAC75920, file "", line 19>:
 19           0 LOAD_FAST                0 (.0)
        >>    2 FOR_ITER                16 (to 20)
              4 STORE_FAST               1 (byte)
              6 LOAD_GLOBAL              0 (format)
              8 LOAD_FAST                1 (byte)
             10 LOAD_CONST               0 ('08b')
             12 CALL_FUNCTION            2
             14 YIELD_VALUE
             16 POP_TOP
             18 JUMP_ABSOLUTE            2
        >>   20 LOAD_CONST               1 (None)
             22 RETURN_VALUE

经过一些手撸(gpt)的帮助我们可以得到一个大概的代码

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
40
41
42
43
44
import base64
 
def encode(data):
    encoded_str = ''
    padding = 0
    base64_chars = 'ZQ+U7tSBEKVzyf5coCwb94Dd6raT0eLNin12Hp8mOxFuvMgIPlhRY3WjksqJAXG/'
 
    # Perform XOR with 85 and reassemble bytes
    ww = b''
    for i in data:
        i ^= 85
        ww += i.to_bytes(1, 'little')
     
    data = ww
 
    # Process the data
    for i in range(0, len(data), 3):
        chunk = data[i:i+3]
        binary_str = ''.join(format(byte, '08b') for byte in chunk)
         
        for j in range(0, len(binary_str), 6):
            six_bits = binary_str[j:j+6]
             
            if len(six_bits) < 6:
                padding += (6 - len(six_bits))
                six_bits += '0' * (6 - len(six_bits))
 
            encoded_str += base64_chars[int(six_bits, 2)]
 
    # Add padding characters
    encoded_str += '!' * (padding // 2)
     
    # Process the encoded string in chunks of 2
    for i in range(len(encoded_str) // 2):
        a = encoded_str[i * 2]
        b = encoded_str[i * 2 + 1]
        encoded_str = encoded_str[:i * 2] + b + a + encoded_str[i * 2 + 2:]
 
    return encoded_str
 
# Example usage:
data = b'This is an example data to encode'
encoded = encode(data)
print(encoded)

不过到这里我们并没有将该题目完成因为如果按照之前的操作可以发现他传入是错误的

1
2
3
4
5
>>> base64.main("sss")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "", line 4, in
TypeError: unsupported operand type(s) for ^: 'str' and 'int'

所以我们可以采取'sss'.encode()的操作猜出来其格式但是按照合法的输入输出进行验证发现不能正常通过

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> z = base64.main("D7C4197AF0806891".encode())
>>> z
'D7DED6vCn6boDrp3W6v3Zr!!'
>>> if len(z) < 20:
...     key = 'dZpKdrsiB6cndrGY' + z
... else:
...     key = z[0:4] + 'dZpK' + z[4:8] + 'drsi' + z[8:12] + 'B6cn' + z[12:16] + 'drGY' + z[16:]
...
>>> key
'D7DEdZpKD6vCdrsin6boB6cnDrp3drGYW6v3Zr!!'
>>> m = base64.main("D7CHel419lo 7AFWor080ld!6891".encode())
>>> m
'D7DEbBsZD6vCb53xn6bo2ZmODrp3b5YtW6v3Zr!!'
>>> m == z
False

之后我们继续在base_libaray.zip中进行寻找后我们发现了另外一个可疑的的文件os.pyc对其进行bytecode dump后我们发现了这段可疑的代码
图片描述

通过一些手撸(gpt)后我们可以得到一个大概的代码:

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
import ctypes
 
# Concatenate binary shellcode
buffer = b''.join([
    b'L\x89D$\x18H\x89T$\x10H\x89L$\x08H',
    b'\x81\xech\x02\x00\x00\xe8\xe5\x06\x00\x00H\x8b@`H',
    b'\x8b@\x18H\x89\x84$\xe8\x00\x00\x00\xb8\x08\x00\x00\x00',
    b'Hk\xc0\x01H\x8b\x8c$\xe8\x00\x00\x00H\x8dD\x01',
    b'\x08H\x89\x84$\xd8\x00\x00\x00H\x8b\x84$\xd8\x00\x00',
    b'\x00H\x8b\x00H\x89\x84$\x98\x00\x00\x00H\xc7\x84$',
    b'\xb8\x00\x00\x00\x00\x00\x00\x00H\xc7\x84$\xc0\x00\x00\x00',
    b'\x00\x00\x00\x00H\xc7\x84$\xc8\x00\x00\x00\x00\x00\x00\x00',
    b'H\xc7\x84$\xd0\x00\x00\x00\x00\x00\x00\x00H\xc7\x84$',
    b'\xe0\x00\x00\x00\x00\x00\x00\x00H\x8b\x84$\xd8\x00\x00\x00',
    b'H9\x84$\x98\x00\x00\x00\x0f\x84?\x06\x00\x003\xc0',
    b'\xb9\x08\x00\x00\x00Hk\xc9\x00H\x03\xc1H\x8b\x8c$',
    b'\x98\x00\x00\x00H+\xc8H\x8b\xc1H\x89\x84$\xf0\x00',
    b'\x00\x00H\x8b\x84$\x98\x00\x00\x00H\x8b\x00H\x89\x84',
    b'$\x98\x00\x00\x00H\x8b\x84$\xf0\x00\x00\x00H\x8b@',
    b'0H\x89D$8H\x8bD$8Hc@<H',
    b'\x8bL$8H\x03\xc8H\x8b\xc1H\x89\x84$\xf8\x00',
    b'\x00\x00\xb8\x08\x00\x00\x00Hk\xc0\x00H\x8b\x8c$\xf8',
    b'\x00\x00\x00\x8b\x84\x01\x88\x00\x00\x00\x89\x84$\x90\x00\x00',
    b'\x00\x83\xbc$\x90\x00\x00\x00\x00u\x05\xe9X\xff\xff\xff',
    b'\x8b\x84$\x90\x00\x00\x00H\x8bL$8H\x03\xc8H',
    b'\x8b\xc1H\x89\x84$\x88\x00\x00\x00H\x8b\x84$\x88\x00',
    b'\x00\x00\x83x\x18\x00u\x05\xe9+\xff\xff\xffH\x8b\x84',
    b'$\x88\x00\x00\x00\x8b@\x0cH\x8bL$8H\x03\xc8',
    b'H\x8b\xc1H\x89\x84$\xb0\x00\x00\x00\xb8\x04\x00\x00\x00',
    b'Hk\xc0\x00H\x8b\x8c$\xb0\x00\x00\x00\x8b\x04\x01\r',
    b'    =kernt\x05\xe9\xe8\xfe\xff\xff',
    b'\xb8\x04\x00\x00\x00Hk\xc0\x01H\x8b\x8c$\xb0\x00\x00',
    b'\x00\x8b\x04\x01\r    =el32t\x05',
    b'\xe9\xc3\xfe\xff\xff\xb8\x04\x00\x00\x00Hk\xc0\x02H\x8b',
    b'\x8c$\xb0\x00\x00\x00\x8b\x04\x01\r    =.',
    b'dllt\x05\xe9\x9e\xfe\xff\xffH\x8b\x84$\x88\x00',
    b'\x00\x00\x8b@\x1cH\x8bL$8H\x03\xc8H\x8b\xc1',
    b'H\x89\x84$\xa8\x00\x00\x00H\x8b\x84$\x88\x00\x00\x00',
    b'\x8b@ H\x8bL$8H\x03\xc8H\x8b\xc1H\x89',
    b'\x84$\x00\x01\x00\x00H\x8b\x84$\x88\x00\x00\x00\x8b@',
    b'$H\x8bL$8H\x03\xc8H\x8b\xc1H\x89\x84$',
    b'\xa0\x00\x00\x00\xc7D$4\x00\x00\x00\x00\xeb\n\x8bD',
    b'$4\xff\xc0\x89D$4H\x8b\x84$\x88\x00\x00\x00',
    b'\x8b@\x189D$4\x0f\x83k\x04\x00\x00\x8bD$',
    b'4H\x8b\x8c$\x00\x01\x00\x00\x8b\x04\x81H\x8bL$',
    b'8H\x03\xc8H\x8b\xc1H\x89D$P\xb8\x04\x00\x00',
    b'\x00Hk\xc0\x00H\x8bL$P\x81<\x01Get',
    b'SuE\xb8\x04\x00\x00\x00Hk\xc0\x01H\x8bL$',
    b'P\x81<\x01tdHau.\x8bD$4H\x8b',
    b'\x8c$\xa0\x00\x00\x00\x0f\xb7\x04AH\x8b\x8c$\xa8\x00',
    b'\x00\x00\x8b\x04\x81H\x8bL$8H\x03\xc8H\x8b\xc1',
    b'H\x89\x84$\xb8\x00\x00\x00\xb8\x04\x00\x00\x00Hk\xc0',
    b'\x00H\x8bL$P\x81<\x01ReaduE\xb8',
    b'\x04\x00\x00\x00Hk\xc0\x01H\x8bL$P\x81<\x01',
    b'Consu.\x8bD$4H\x8b\x8c$\xa0\x00',
    b'\x00\x00\x0f\xb7\x04AH\x8b\x8c$\xa8\x00\x00\x00\x8b\x04',
    b'\x81H\x8bL$8H\x03\xc8H\x8b\xc1H\x89\x84$',
    b'\xc0\x00\x00\x00\xb8\x04\x00\x00\x00Hk\xc0\x00H\x8bL',
    b'$P\x81<\x01Loadu\\xb8\x04\x00\x00\x00',
    b'Hk\xc0\x01H\x8bL$P\x81<\x01Libr',
    b'uE\xb8\x04\x00\x00\x00Hk\xc0\x02H\x8bL$P',
    b'\x81<\x01aryAu.\x8bD$4H\x8b\x8c',
    b'$\xa0\x00\x00\x00\x0f\xb7\x04AH\x8b\x8c$\xa8\x00\x00',
    b'\x00\x8b\x04\x81H\x8bL$8H\x03\xc8H\x8b\xc1H',
    b'\x89\x84$\xc8\x00\x00\x00\xb8\x04\x00\x00\x00Hk\xc0\x00',
    b'H\x8bL$P\x81<\x01GetPuE\xb8\x04',
    b'\x00\x00\x00Hk\xc0\x01H\x8bL$P\x81<\x01r',
    b'ocAu.\x8bD$4H\x8b\x8c$\xa0\x00\x00',
    b'\x00\x0f\xb7\x04AH\x8b\x8c$\xa8\x00\x00\x00\x8b\x04\x81',
    b'H\x8bL$8H\x03\xc8H\x8b\xc1H\x89\x84$\xd0',
    b'\x00\x00\x00H\x83\xbc$\xb8\x00\x00\x00\x00\x0f\x84\xb1\x02',
    b'\x00\x00H\x83\xbc$\xc0\x00\x00\x00\x00\x0f\x84\xa2\x02\x00',
    b'\x00H\x83\xbc$\xc8\x00\x00\x00\x00\x0f\x84\x93\x02\x00\x00',
    b'H\x83\xbc$\xd0\x00\x00\x00\x00\x0f\x84\x84\x02\x00\x00\xb9',
    b'\xf6\xff\xff\xff\xff\x94$\xb8\x00\x00\x00H\x89\x84$\x08',
    b'\x01\x00\x00\xc7D$D\x00\x00\x00\x00\xeb\n\x8bD$',
    b'D\xff\xc0\x89D$D\x83|$Dd}\x0fHc',
    b'D$D\xc6\x84\x04 \x01\x00\x00\x00\xeb\xe0\xc7D$',
    b'@\x00\x00\x00\x00H\xc7D$ \x00\x00\x00\x00L\x8d',
    b'L$@A\xb82\x00\x00\x00H\x8d\x94$ \x01\x00',
    b'\x00H\x8b\x8c$\x08\x01\x00\x00\xff\x94$\xc0\x00\x00\x00',
    b'\xc7D$H\x00\x00\x00\x00\xeb\n\x8bD$H\xff\xc0',
    b'\x89D$H\x81|$H\xc8\x00\x00\x00}\x0fHc',
    b'D$H\xc6\x84\x04\x90\x01\x00\x00\x00\xeb\xdd\xb8\x01\x00',
    b'\x00\x00Hk\xc0\x00\xc6\x84\x04\x90\x01\x00\x00s\xc7D',
    b'$0\x00\x00\x00\x00\xeb\n\x8bD$0\xff\xc0\x89D',
    b'$0\x8bD$@9D$0shHcD$',
    b'0\x0f\xbe\x84\x04 \x01\x00\x00\x83\xf8\rt&Hc',
    b'D$0\x0f\xbe\x84\x04 \x01\x00\x00=00x0',
    b't\x12HcD$0\x0f\xbe\x84\x04 \x01\x00\x00\x83',
    b'\xf8\nu\n\x8bD$0\x89D$@\xeb&Hc',
    b'D$0\x0f\xbe\x84\x04 \x01\x00\x00\x83\xf0w\x83\xc0',
    b'\x15\x8bL$0\x83\xc1\x05Hc\xc9\x88\x84\x0c\x90\x01',
    b'\x00\x00\xeb\x84\xb8\x01\x00\x00\x00Hk\xc0\x01\x8bL$',
    b'@\x89\x8c\x04\x90\x01\x00\x00\xc6D$Xp\xc6D$',
    b'Yy\xc6D$Zt\xc6D$[h\xc6D$\',
    b'o\xc6D$]n\xc6D$^3\xc6D$_8',
    b'\xc6D$`.\xc6D$ad\xc6D$bl\xc6',
    b'D$cl\xc6D$d\x00H\x8dL$X\xff\x94',
    b'$\xc8\x00\x00\x00H\x89\x84$\x10\x01\x00\x00\xc6D$',
    b'hP\xc6D$iy\xc6D$jM\xc6D$k',
    b'a\xc6D$lr\xc6D$ms\xc6D$nh',
    b'\xc6D$oa\xc6D$pl\xc6D$q_\xc6',
    b'D$rR\xc6D$se\xc6D$ta\xc6D',
    b'$ud\xc6D$vO\xc6D$wb\xc6D$',
    b'xj\xc6D$ye\xc6D$zc\xc6D${',
    b't\xc6D$|F\xc6D$}r\xc6D$~o',
    b'\xc6D$\x7fm\xc6\x84$\x80\x00\x00\x00S\xc6\x84$',
    b'\x81\x00\x00\x00t\xc6\x84$\x82\x00\x00\x00r\xc6\x84$',
    b'\x83\x00\x00\x00i\xc6\x84$\x84\x00\x00\x00n\xc6\x84$',
    b'\x85\x00\x00\x00g\xc6\x84$\x86\x00\x00\x00\x00H\x8dT',
    b'$hH\x8b\x8c$\x10\x01\x00\x00\xff\x94$\xd0\x00\x00',
    b'\x00H\x89\x84$\xe0\x00\x00\x00\x8bD$@\x83\xc0\x05',
    b'\x8b\xd0H\x8d\x8c$\x90\x01\x00\x00\xff\x94$\xe0\x00\x00',
    b'\x00\xeb\x0c\xe9v\xfb\xff\xff\xe9\xab\xf9\xff\xff3\xc0H',
    b'\x81\xc4h\x02\x00\x00\xc3\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc\xcc',
    b'eH\x8b\x04%0\x00\x00\x00\xc3\xcc\xcc\xcc\xcc\xcc\xcc'
])
 
# Convert buffer to a ctypes c_char_p type
shellcode = ctypes.c_char_p(buffer)
 
# Calculate a1
a1 = ctypes.c_char_p(id(shellcode) + 16).value
 
offset = 0
# Range is replaced by the integer value since the loop depends on a1 length
for i in range(len(a1)):
    offset += a1[len(a1) - i - 1]
    offset *= 256
 
offset //= 256
a1 = ctypes.c_char_p(offset).value
 
offset = 0
for i in range(len(a1)):
    offset += a1[len(a1) - i - 1]
    offset *= 256
 
offset //= 256
w = ctypes.c_char_p(offset).value
 
lib = ctypes.CDLL('kernel32.dll')
old = ctypes.c_long(1)
c = lib.VirtualProtect(
    ctypes.c_int64(offset),
    ctypes.c_int(4096),
    ctypes.c_int(64),
    ctypes.byref(old)
)
 
input_offset = id(input()) + 16
a1 = ctypes.c_char_p(input_offset).value
 
input_offset = 0
for i in range(len(a1)):
    input_offset += a1[len(a1) - i - 1]
    input_offset *= 256
 
input_offset //= 256
input_offset += 8
 
# Process the value (modulo operations with 256)
l1 = offset % 256
offset //= 256
l2 = offset % 256
offset //= 256
l3 = offset % 256
offset //= 256
l4 = offset % 256
offset //= 256
l5 = offset % 256
offset //= 256
l6 = offset % 256
offset //= 256
l7 = offset % 256
offset //= 256
l8 = offset % 256
offset //= 256
 
# Invoke memset with various lengths
ctypes.memset(input_offset, l1, 1)
input_offset += 1
ctypes.memset(input_offset, l2, 1)
input_offset += 1
ctypes.memset(input_offset, l3, 1)
input_offset += 1
ctypes.memset(input_offset, l4, 1)
input_offset += 1
ctypes.memset(input_offset, l5, 1)
input_offset += 1
ctypes.memset(input_offset, l6, 1)
input_offset += 1
ctypes.memset(input_offset, l7, 1)
input_offset += 1
ctypes.memset(input_offset, l8, 1)
input_offset += 1
 
# End of function

我们可以看到其往input的部分注入了其自己的shellcode
也就代表当运行input的时候可以加载自己的shellcode函数
原理可以参考作者的另一篇文章 https://bbs.kanxue.com/thread-276493.htm
提取后shellcode之后我们看到了其真正的逻辑

图片描述

将所有逻辑穿起来后可以正常解密

图片描述



更多【CTF对抗- 第四题 神秘信号 简短writeup】相关视频教程：www.yxfzedu.com




相关文章推荐

记录自己的技术轨迹
文章规则：
1)：文章标题请尽量与文章内容相符
2)：严禁色情、血腥、暴力
3)：严禁发布任何形式的广告贴
4)：严禁发表关于中国的政治类话题
5)：严格遵守中国互联网法律法规
6)：有侵权,疑问可发邮件至service@yxfzedu.com
近期原创 更多
友情链接
内核结构 FAQ
免责声明
课程目录
Windows内核
游戏逆向(FPS)
技术交流QQ群
342478842 215039827 137189196
314055665 159620936
微信公众号
www.yxfzedu.com是一个分享游戏安全,游戏外挂与反外挂,游戏驱动保护的视频网站！
接各种驱动定制如：游戏读写驱动，软件内存保护，防止调试等功能定制。
出租读写驱动，调试驱动，无痕注入支持各种游戏。
邮箱：service@yxfzedu.com
QQ：851920120
特别说明：不接游戏数据分析，外挂编写，登陆协议等类似业务。