signature=edc3f9d42b8728d7aacfa103506e19c4,【wp】HWS计划2021硬件安全冬令营线上选拔赛

逆向手在夹缝中艰难求生系列。

这篇真的存粹是做题笔记了，对内核驱动啥的不太懂，pwn也不会，能做出来的题都是硬逆出来的(

childre最后死活没整出来，后来看大佬的wp才知道对子进程有修改(。)呜呜呜多进程真的不太会啊。

REVERSE

obfu

一堆密码堆起来的题(密码菜鸡卑微落泪

按逻辑来说拿到serial number就能拿到flag了。

通过findcrypt找到三个加密算法的常量，通过交叉引用确定函数用途。

v10和v8相比之下v8更容易出，v8跟输入没有关系，相当于已知字符串(=md5("admin")。

然后就是enctrpy函数。

按照顺序是AES_enc->RC4_dec->循环左移三位复原。

exp：

from binascii import *

from Crypto.Cipher import AES,ARC4

from hashlib import sha256,md5

v8=unhexlify(md5("admin").hexdigest())

admin=[ord(x) for x in unhexlify(sha256("admin").hexdigest())]

tmp=""+chr(admin[0])

for i in range(1,32):

tmp+=chr(admin[i]^admin[i-1])

key=tmp[:16]

iv=tmp[16:]

aes=AES.new(key,AES.MODE_CBC,iv)

cipher=aes.encrypt(v8)

rc4=ARC4.new(key)

input_enc=rc4.decrypt(cipher)

tmps=bin(int(hexlify(input_enc),16))[2:].rjust(16*8,'0')

tmps=tmps[3:]+tmps[:3]

serial=""

for i in range(16):

serial+=hex(int(tmps[i*8:i*8+8],2))[2:].rjust(2,'0')

print(serial)

拿到serial：653b987431e5a2fc7c3d748fba008869

最后拿到flag：0725f66471f85ba9d742eb583c75959c

decryption

送！分！题！泪目了呜呜呜呜呜

加密函数在这里：

懒得逆逻辑了，直接copy算法爆破(毕竟是按字节加密hhh。

arr=[0x12, 0x45, 0x10, 0x47, 0x19, 0x49, 0x49, 0x49, 0x1A, 0x4F, 0x1C, 0x1E, 0x52, 0x66, 0x1D, 0x52, 0x66, 0x67, 0x68, 0x67, 0x65, 0x6F, 0x5F, 0x59, 0x58, 0x5E, 0x6D, 0x70, 0xA1, 0x6E, 0x70, 0xA3]

flag=""

for i in range(32):

for j in range(32,127):

v5=j

v4=i

while True:

v3=2*(v4&v5)

v5^=v4

v4=v3

if v3==0:

break

if v5^0x23==arr[i]:

flag+=chr(j)

break

print(flag)

flag：1e1a6edc1c52e80b539127fccd48f05a

babyre

乍一看主函数逻辑很简单，实际上如果不patch的话是不可能完成的(byte_41A808这里有不可见字符。

看到这篇wp(HWS计划2021硬件安全冬令营线上选拔赛 re wp_20000s的博客-CSDN博客)里说是“内部加载dll，hook了驱动”，好像是这样，不过为啥动态调试的时候没有hook到呢(tcl不懂，选择手动hook

然后注意到了2047这个奇怪的数字，正常来说ZwLoadDriver应该是不会返回这种东西的(吧，所以从左边函数表一个一个翻下来找到了关键函数sub_412A20()

结合前面v9的赋值可以猜测，应该调用这个函数，并且a2是v9，才能对输入的Str调用v4进行加密得到byte_41A808。

所以先直接暴力patch

然后下断点，动态调试，可以看到v4实际上是：

噢，感谢密钥的提示，不用看了hhh，直接sm4解密(从SM4 python_dumpling-cat的博客-CSDN博客抓了脚本改了改)。

# S盒

SboxTable = \

[

0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7, 0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05,

0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3, 0xaa, 0x44, 0x13, 0x26, 0x49, 0x86, 0x06, 0x99,

0x9c, 0x42, 0x50, 0xf4, 0x91, 0xef, 0x98, 0x7a, 0x33, 0x54, 0x0b, 0x43, 0xed, 0xcf, 0xac, 0x62,

0xe4, 0xb3, 0x1c, 0xa9, 0xc9, 0x08, 0xe8, 0x95, 0x80, 0xdf, 0x94, 0xfa, 0x75, 0x8f, 0x3f, 0xa6,

0x47, 0x07, 0xa7, 0xfc, 0xf3, 0x73, 0x17, 0xba, 0x83, 0x59, 0x3c, 0x19, 0xe6, 0x85, 0x4f, 0xa8,

0x68, 0x6b, 0x81, 0xb2, 0x71, 0x64, 0xda, 0x8b, 0xf8, 0xeb, 0x0f, 0x4b, 0x70, 0x56, 0x9d, 0x35,

0x1e, 0x24, 0x0e, 0x5e, 0x63, 0x58, 0xd1, 0xa2, 0x25, 0x22, 0x7c, 0x3b, 0x01, 0x21, 0x78, 0x87,

0xd4, 0x00, 0x46, 0x57, 0x9f, 0xd3, 0x27, 0x52, 0x4c, 0x36, 0x02, 0xe7, 0xa0, 0xc4, 0xc8, 0x9e,

0xea, 0xbf, 0x8a, 0xd2, 0x40, 0xc7, 0x38, 0xb5, 0xa3, 0xf7, 0xf2, 0xce, 0xf9, 0x61, 0x15, 0xa1,

0xe0, 0xae, 0x5d, 0xa4, 0x9b, 0x34, 0x1a, 0x55, 0xad, 0x93, 0x32, 0x30, 0xf5, 0x8c, 0xb1, 0xe3,

0x1d, 0xf6, 0xe2, 0x2e, 0x82, 0x66, 0xca, 0x60, 0xc0, 0x29, 0x23, 0xab, 0x0d, 0x53, 0x4e, 0x6f,

0xd5, 0xdb, 0x37, 0x45, 0xde, 0xfd, 0x8e, 0x2f, 0x03, 0xff, 0x6a, 0x72, 0x6d, 0x6c, 0x5b, 0x51,

0x8d, 0x1b, 0xaf, 0x92, 0xbb, 0xdd, 0xbc, 0x7f, 0x11, 0xd9, 0x5c, 0x41, 0x1f, 0x10, 0x5a, 0xd8,

0x0a, 0xc1, 0x31, 0x88, 0xa5, 0xcd, 0x7b, 0xbd, 0x2d, 0x74, 0xd0, 0x12, 0xb8, 0xe5, 0xb4, 0xb0,

0x89, 0x69, 0x97, 0x4a, 0x0c, 0x96, 0x77, 0x7e, 0x65, 0xb9, 0xf1, 0x09, 0xc5, 0x6e, 0xc6, 0x84,

0x18, 0xf0, 0x7d, 0xec, 0x3a, 0xdc, 0x4d, 0x20, 0x79, 0xee, 0x5f, 0x3e, 0xd7, 0xcb, 0x39, 0x48,

]

# 常数FK

FK = [0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc] ; ENCRYPT = 0 ;DECRYPT = 1

# 固定参数CK

CK = \

[

0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,

0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,

0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,

0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,

0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,

0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,

0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,

0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279

]

def padding(data): #填充

print ("plaintext:\t", bytes (data))

file_data_list = list(data)

lenth = len (file_data_list)

#print ("data lenth:", lenth)

remainder = lenth % 16

if remainder != 0:

i=16-remainder #i为需要填充的位数

#print ("padding numbers = ", i)

for j in range(i):

file_data_list.append(i) #填充 char 0-(i-1)

if remainder == 0:

for k in range(16):

file_data_list.append (0x08) #刚好的话 填充0x08

print("after PKCS5 padding:",file_data_list)

return file_data_list

def list_4_8_to_int32(key_data): # 列表4个8位，组成32位

return int ((key_data[0] << 24) | (key_data[1] << 16) | (key_data[2] << 8) | (key_data[3]))

def n32_to_list4_8(n): #把n分别取32位的每8位放入列表

return [int ((n >> 24) & 0xff), int ((n >> 16) & 0xff), int ((n >> 8) & 0xff), int ((n) & 0xff)]

#循环左移

def shift_left_n(x, n):

return int (int (x << n) & 0xffffffff)

def shift_logical_left(x, n):

return shift_left_n (x, n) | int ((x >> (32 - n)) & 0xffffffff) #两步合在一起实现了循环左移n位

def XOR(a, b):

return list (map (lambda x, y: x ^ y, a, b))

#s盒查找

def sbox(idx):

return SboxTable[idx]

def extended_key_LB(ka): #拓展密钥算法LB

a = n32_to_list4_8 (ka) #a是ka的每8位组成的列表

b = [sbox (i) for i in a] #在s盒中每8位查找后，放入列表b，再组合成int bb

bb = list_4_8_to_int32 (b)

rk = bb ^ (shift_logical_left (bb, 13)) ^ (shift_logical_left (bb, 23))

return rk

def linear_transform_L(ka): #线性变换L

a = n32_to_list4_8 (ka)

b = [sbox (i) for i in a]

bb = list_4_8_to_int32 (b) #bb是经过s盒变换的32位数

return bb ^ (shift_logical_left (bb, 2)) ^ (shift_logical_left (bb, 10)) ^ (shift_logical_left (bb, 18)) ^ (shift_logical_left (bb, 24)) #书上公式

def sm4_round_function(x0, x1, x2, x3, rk): #轮函数

return (x0 ^ linear_transform_L (x1 ^ x2 ^ x3 ^ rk))

class Sm4 (object):

def __init__(self):

self.sk = [0] * 32

self.mode = ENCRYPT

def sm4_set_key(self, key_data, mode): #先算出拓展密钥

self.extended_key_last (key_data, mode)

def extended_key_last(self, key, mode): #密钥扩展算法

MK = [0, 0, 0, 0]

k = [0] * 36

MK[0] = list_4_8_to_int32 (key[0:4])

MK[1] = list_4_8_to_int32 (key[4:8])

MK[2] = list_4_8_to_int32 (key[8:12])

MK[3] = list_4_8_to_int32 (key[12:16])

k[0:4] = XOR (MK, FK)

for i in range (32):

k[i + 4] = k[i] ^ (extended_key_LB (k[i + 1] ^ k[i + 2] ^ k[i + 3] ^ CK[i]))

self.sk = k[4:] #生成的32轮子密钥放到sk中

self.mode = mode

if mode == DECRYPT: #解密时rki逆序

self.sk.reverse ()

def sm4_one_round(self, sk, in_put): #一轮算法 ，4个32位的字=128bit=16个字节(8*16)

item = [list_4_8_to_int32 (in_put[0:4]), list_4_8_to_int32 (in_put[4:8]), list_4_8_to_int32 (in_put[8:12]),

list_4_8_to_int32 (in_put[12:16])] #4字节一个字，把每4个字节变成32位的int

x=item

for i in range (32):

temp=x[3]

x[3] = sm4_round_function (x[0], x[1], x[2], x[3], sk[i]) #x[3]成为x[4]

x[0]=x[1]

x[1]=x[2]

x[2]=temp

print("%dround----->"%(i+1),"key:%-12d\n"%sk[i],"result：",x)

res=x

# res = reduce (lambda x, y: [x[1], x[2], x[3], sm4_round_function (x[0], x[1], x[2], x[3], y)],sk, item) #32轮循环加密

res.reverse ()

rev = map (n32_to_list4_8, res)

out_put = []

[out_put.extend (_) for _ in rev]

return out_put

def encrypt(self, input_data):

# 块加密

output_data = []

tmp = [input_data[i:i + 16] for i in range (0, len (input_data), 16)] #输入数据分块

[output_data.extend (each) for each in map (lambda x: self.sm4_one_round (self.sk, x), tmp)]

return output_data

def encrypt(mode, key, data):

sm4_d = Sm4 ()

sm4_d.sm4_set_key (key, mode)

en_data = sm4_d.encrypt (data)

return en_data

def sm4_crypt_cbc(mode, key, iv, data):

sm4_d = Sm4 ()

sm4_d.sm4_set_key (key, mode)

en_data = sm4_d.sm4_crypt_cbc (iv, data)

return en_data

if __name__ == "__main__":

key_data=[ord(c) for c in "Ez_5M4_C1pH@r!!!"]

en_data=b"\xEA\x63\x58\xB7\x8C\xE2\xA1\xE9\xC5\x29\x8F\x53\xE8\x08\x32\x59\xAF\x1B\x67\xAE\xD9\xDA\xCF\xC4\x72\xFF\xB1\xEC\x76\x73\xF3\x06"

sm4_d = Sm4 ()

sm4_d.sm4_set_key (key_data, DECRYPT)

de_data = sm4_d.encrypt (en_data)

flag=''.join(list(map(chr,de_data)))

print(flag)

flag：42b061b4cb41cfa89ca78047bde1856e

Enigma

逻辑很清晰，直接分析loc_4018F0。

这边有一个SetUnhandledExceptionFilter捕获异常。

一开始以为下面的都是花指令，但每次都是0xC7转不了就很奇怪，异常+0xC7想到了平时用的CC断点，再加上sub_401630看起来像是个虚拟机，感觉0xC7是一个中断号(计组刚学，捕获中断然后用sub_401630处理。

每一个case里sub_4011B0是取值，另一个函数则是处理，v18是指令长度。

通过对ExceptionInfo的查阅发现，v19=*(_DWORD *)(*(_DWORD *)(a1 + 4) + 0xB8)开始是异常发生的地址即0xC7的地址，最后则应该是异常处理完毕后要返回的用户空间代码地址。(这么一推异常应该是0xC7FF才对

opcode是0xC7FF的下一个即v19+2，后面的为操作数。

二级函数里面都是对a1[40]~a1[44]进行操作，猜测是寄存器。

于是可以分析出：

// xx为[1,5]，rx为对应的a1[40]~a1[44]寄存器，是二级函数中的case

// 1->a1[44],2->a1[41],3->a1[43],4->a1[42],5->a1[40]

// imm为立即数

C7 FF 00 xx imm //add rx,imm

C7 FF 01 xx imm //sub rx,imm

C7 FF 02 xx //inc rx

C7 FF 03 xx //dec rx

C7 FF 04 xx imm //and rx,imm

C7 FF 05 xx imm //or rx,imm

C7 FF 06 xx imm //xor rx,imm

C7 FF 07 xx imm //shl rx,imm

C7 FF 08 xx imm //shr rx,imm

然后把下面的机器码中带有C7 FF系列指令以外的先转换成code。

接下来处理这些异常部分的机器码，比如第一个中断翻译出来是and r1,0，即将r1清空，汇编习惯上更常用xor r1,r1，先用注释标注。

然后根据上下文以及上图可以推断出r1-r5分别对应如下：

r1 -> eax;

r2 -> ebx;

r3 -> ecx;

r4 -> edx;

r5 -> esi;

patch程序，多余字节直接nop(因为不记得有些机器码了所以直接用keypatch。

然后得到反编译的加密函数。

根据逻辑逆向写出exp：

from hashlib import md5

dst="938b8f431268f7907a4b6e421301b42120738d68cb19fcf8b26bc4abc89b8d22"

output=[]

for i in range(0,64,2):

output.append(int("0x"+dst[i:i+2],16))

key=[0x42, 0x69, 0x65, 0x72]

tmp2=[output[0]]

for i in range(1,32):

tmp2.append(output[i]^tmp2[i-1]^key[i&3])

tmp1=[]

for i in range(32):

tmp1.append(((tmp2[i]&0xf8)>>3)|((tmp2[(i-1)&0x1F]&0x07)<<5))

v0=0

arr=[]

for _ in range(32):

v0=(v0+17)&0x1F

arr.append(v0)

flag=['-' for _ in range(32)]

for i in range(0,32,2):

flag[arr[i]],flag[arr[i+1]]=chr(tmp1[arr[i+1]]),chr(tmp1[arr[i]])

flag=''.join(flag)

print(md5(flag).hexdigest())

flag：751542a09b8b341dda23ebfc387a5e91

内核安全

easy_kernel

是个ring3调用ring0的题(前半部分。

从ring3看起，v7是flag，走了sub_401005函数。

跳到最后有

int 2E，查了一下是用户模式进入内核模式的中断，于是去看ring0(即DriverXP.sys，调用号是186。

可以看到这里有186，并且参数个数也是6个，猜测sub_401340就是调用的函数。

进一步可以看到，a1==-1，刚好也吻合sub_401005的第一个参数。

findcrypt可以看到DES，并且查交叉引用和反编译代码证实sub_401680就是DES加密过程。

可以看到这边密钥只用了"}aglf_T_ton_5i_sihT_yrroS{galf"的前八字节。

第一层加密确认，从ring3继续往下看。

这个MEMORY[0x5804E8]实在是没看出来是什么，看汇编是call fword ptr，查了一下是个长调用，返回用retf。

gdt表也懒得查，于是在ring3的汇编这里从头开始一个一个往下看retf，准备把碰到的都试一遍。

诶，看到一个，转函数看看。

代到exp里试了一下，发现成了，运气很好hhh，最开始这个就是MEMORY[0x5804E8]。

exp：

from Crypto.Cipher import DES

from hashlib import md5

key='}aglf_T_ton_5i_sihT_yrroS{galf'[:8]

c=[0xB2, 0xC4, 0x86, 0xD5, 0x54, 0x6C, 0x38, 0xAD, 0xBD, 0x69, 0xD4, 0xE9, 0x44, 0x47, 0x36, 0x21, 0x99, 0x91, 0xFB, 0x13, 0x70, 0xD8, 0x6B, 0xE4, 0x80, 0x12, 0xE2, 0x43, 0x2A, 0x4B, 0x49, 0x8E]

for i in range(30,-1,-1):

c[i]^=c[i+1]

cipher=''.join(list(map(chr,c)))

des=DES.new(key)

flag=des.decrypt(cipher)

print(flag)

print(md5(flag).hexdigest())

flag：c1878dfb2b0c23c74ec4e6650d8f7004

固件安全

NodeMCU

strings nodemcu.bin > str.out，导出字符串后直接查找flag即可

flag：6808dcf0-526e-11eb-92de-acde48001122

STM

用bin2hex将bin文件转为hex文件，然后用ida加载hex。

查找STM的datasheet(以常见的STM32F103CB为参照)可知flash映射在0x08000000地址上

于是载入ida的时候还要把基址改成0x08000000。

然后查找字符串，直接看Hello World的交叉引用，找到主函数。

根据相应的函数功能猜测并命名，sub_8000314是加密函数。

逻辑很简单，直接写exp：

arr=[0x7D, 0x77, 0x40, 0x7A, 0x66, 0x30, 0x2A, 0x2F, 0x28, 0x40, 0x7E, 0x30, 0x33, 0x34, 0x2C, 0x2E, 0x2B, 0x28, 0x34, 0x30, 0x30, 0x7C, 0x41, 0x34, 0x28, 0x33, 0x7E, 0x30, 0x34, 0x33, 0x33, 0x30, 0x7E, 0x2F, 0x31, 0x2A, 0x41, 0x7F, 0x2F, 0x28, 0x2E, 0x64]

for x in arr:

print(chr((x^0x1E)+3),end='')

flag{1749ac10-5389-11eb-90c1-001c427bd493}