REVERSE-COMPETITION-HGAME2022-Week4

最新推荐文章于 2023-04-04 22:00:09 发布

P1umH0

最新推荐文章于 2023-04-04 22:00:09 发布

阅读量820

点赞数 3

分类专栏： Reverse-Competition 文章标签：安全系统安全

本文链接：https://blog.csdn.net/weixin_45582916/article/details/122909419

版权

Reverse-Competition 专栏收录该内容

10 篇文章 2 订阅

订阅专栏

REVERSE-COMPETITION-HGAME2022-Week4

( WOW )

32位exe，ida打开
观察伪代码逻辑，上面的红框中，输入经过加密，密文放入Buf2中，然后Buf2和已知的密文res比较
比较完，打印"win"或者"error"
发现下面还有一部分对Buf2处理的代码逻辑，而且几乎和上面对输入加密的结构是一样的
于是猜测下面的红框中就是解密逻辑
wow-main
起调试，随便构造一个长度为32的输入
在调用memcmp前下断，将内存中Buf2的数据patch成已知的密文res
进行下面对Buf2的解密，解密后的input即为flag
wow-flag

server

64位exe，用ida7.7打开
（52pojie上有最新的全插件绿色版ida7.7可供下载）
从main函数中知道监听本地的9090端口
回调函数为main_HttpHandleFunc，调试发现，输入经过main_encrypt处理后，与已知的res比较
server-main
进入main_encrypt函数，伪代码看不出什么，玄机在汇编指令
可以发现main_encrypt的前半部分实际上是个RSA加密，并且已知p，q，e
server-rsa
输入经rsa加密后，将十进制密文的每一个数字转成字符存入rsa_cipher中
然后进行后半部分的两轮异或运算，异或后的结果与已知的res比较
server-xor
这里举一个例子来理解后半部分的两轮异或运算，以便能够更好地逆向

# -*- coding:utf-8 -*-
import gmpy2
num1=92582184765240663364795767694262273105045150785272129481762171937885924776597#p
num2=107310528658039985708896636559112400334262005367649176746429531274300859498993#q
num1_mul_num2=num1*num2#n
num3=950501#e
my_in_s="hgame{abcdefghijklmnopqrstuvwxy}"#构造的输入
my_in=0x6867616d657b6162636465666768696a6b6c6d6e6f707172737475767778797d
my_in_cipher=gmpy2.powmod(my_in,num3,num1_mul_num2)#rsa加密
my_in_cipher_s=str(my_in_cipher)
print("RSA加密后的十进制密文：")
print(my_in_cipher_s)
print("RSA加密后的十进制密文长度：")
print(len(my_in_cipher_s))
#模拟main_encrypt中后半部分的两轮异或运算
res=[]
for i in range(len(my_in_cipher_s)-1):
    res.append(ord(my_in_cipher_s[i]))
print("十进制密文的每一个数字转成字符：")
print(res)
v22=102
index=0
while index<153:
    tmp=res[index]
    res[index]^=v22
    v22=tmp
    index+=1
print("第一轮异或运算结果：")
print(res)
index=0
while index<153:
    tmp=res[index]
    res[index]^=v22
    v22=tmp
    index+=1
print("第二轮异或运算结果：")
print(res)
# RSA加密后的十进制密文：
# 2315576653393559402200063691755666172531457200527539170715551199511112051176056764826673635703056993058028383465485142593456001504496707046294726739445446
# RSA加密后的十进制密文长度：
# 154
# 十进制密文的每一个数字转成字符：(后面用cipher表示)
# [50, 51, 49, 53, 53, 55, 54, 54, 53, 51, 51, 57, 51, 53, 53, 57, 52, 48, 50, 50, 48, 48, 48, 54, 51, 54, 57, 49, 55, 53, 53, 54, 54, 54, 49, 55, 50, 53, 51, 49, 52, 53, 55, 50, 48, 48, 53, 50, 55, 53, 51, 57, 49, 55, 48, 55, 49, 53, 53, 53, 49, 49, 57, 57, 53, 49, 49, 49, 49, 50, 48, 53, 49, 49, 55, 54, 48, 53, 54, 55, 54, 52, 56, 50, 54, 54, 55, 51, 54, 51, 53, 55, 48, 51, 48, 53, 54, 57, 57, 51, 48, 53, 56, 48, 50, 56, 51, 56, 51, 52, 54, 53, 52, 56, 53, 49, 52, 50, 53, 57, 51, 52, 53, 54, 48, 48, 49, 53, 48, 52, 52, 57, 54, 55, 48, 55, 48, 52, 54, 50, 57, 52, 55, 50, 54, 55, 51, 57, 52, 52, 53, 52, 52]
# 第一轮异或运算结果：(后面用round_1表示)
# [84, 1, 2, 4, 0, 2, 1, 0, 3, 6, 0, 10, 10, 6, 0, 12, 13, 4, 2, 0, 2, 0, 0, 6, 5, 5, 15, 8, 6, 2, 0, 3, 0, 0, 7, 6, 5, 7, 6, 2, 5, 1, 2, 5, 2, 0, 5, 7, 5, 2, 6, 10, 8, 6, 7, 7, 6, 4, 0, 0, 4, 0, 8, 0, 12, 4, 0, 0, 0, 3, 2, 5, 4, 0, 6, 1, 6, 5, 3, 1, 1, 2, 12, 10, 4, 0, 1, 4, 5, 5, 6, 2, 7, 3, 3, 5, 3, 15, 0, 10, 3, 5, 13, 8, 2, 10, 11, 11, 11, 7, 2, 3, 1, 12, 13, 4, 5, 6, 7, 12, 10, 7, 1, 3, 6, 0, 1, 4, 5, 4, 0, 13, 15, 1, 7, 7, 7, 4, 2, 4, 11, 13, 3, 5, 4, 1, 4, 10, 13, 0, 1, 1, 0]
# 第二轮异或运算结果：(后面用round_2表示)
# [96, 85, 3, 6, 4, 2, 3, 1, 3, 5, 6, 10, 0, 12, 6, 12, 1, 9, 6, 2, 2, 2, 0, 6, 3, 0, 10, 7, 14, 4, 2, 3, 3, 0, 7, 1, 3, 2, 1, 4, 7, 4, 3, 7, 7, 2, 5, 2, 2, 7, 4, 12, 2, 14, 1, 0, 1, 2, 4, 0, 4, 4, 8, 8, 12, 8, 4, 0, 0, 3, 1, 7, 1, 4, 6, 7, 7, 3, 6, 2, 0, 3, 14, 6, 14, 4, 1, 5, 1, 0, 3, 4, 5, 4, 0, 6, 6, 12, 15, 10, 9, 6, 8, 5, 10, 8, 1, 0, 0, 12, 5, 1, 2, 13, 1, 9, 1, 3, 1, 11, 6, 13, 6, 2, 5, 6, 1, 5, 1, 1, 4, 13, 2, 14, 6, 0, 0, 3, 6, 6, 15, 6, 14, 6, 1, 5, 5, 14, 7, 13, 1, 0, 1]

我们可以发现
round_1[0]=102 xor cipher[0]，round_1[1]=cipher[0] xor cipher[1]，依次类推（这里的102是已知的
round_2[0]=52 xor round_1[0]，round_2[1]=round_1[0] xor round_1[1]，依次类推
这里的52实际上等于cipher[len(cipher)-1]，也就是cipher的最后一个值
但是由于cipher是RSA加密后的密文，所以其实cipher[len(cipher)-1]是未知的
想要逆向两轮异或运算从而得到正确的RSA密文
需要爆破cipher[len(cipher)-1]，范围是十进制数字字符

# -*- coding:utf-8 -*-
import gmpy2
from Crypto.Util.number import long_to_bytes
# res 相当于 round_2
res=[0x63,0x55,0x4,0x3,0x5,0x5,0x5,0x3,0x7,0x7,0x2,0x8,0x8,0xb,0x1,0x2,0xa,0x4,0x2,0xd,0x8,0x9,0xc,0x9,0x4,0xd,0x8,0x0,0xe,0x0,0xf,0xd,0xe,0xa,0x2,0x2,0x1,0x7,0x3,0x5,0x6,0x4,0x6,0x7,0x6,0x2,0x2,0x5,0x3,0x3,0x9,0x6,0x0,0xb,0xd,0xb,0x0,0x2,0x3,0x8,0x3,0xb,0x7,0x1,0xb,0x5,0xe,0x5,0x0,0xa,0xe,0xf,0xd,0x7,0xd,0x7,0xe,0x1,0xf,0x1,0xb,0x5,0x6,0x2,0xc,0x6,0xa,0x4,0x1,0x7,0x4,0x2,0x6,0x3,0x6,0xc,0x5,0xc,0x3,0xc,0x6,0x0,0x4,0xf,0x2,0xe,0x7,0x0,0xe,0xe,0xc,0x4,0x3,0x4,0x2,0x0,0x0,0x2,0x6,0x2,0x3,0x6,0x4,0x4,0x4,0x7,0x1,0x2,0x3,0x9,0x2,0xc,0x8,0x1,0xc,0x3,0xc,0x2,0x0,0x3,0xe,0x3,0xe,0xc,0x9,0x1,0x7,0xf,0x5,0x7,0x2,0x2,0x4]
p=92582184765240663364795767694262273105045150785272129481762171937885924776597
q=107310528658039985708896636559112400334262005367649176746429531274300859498993
n=p*q
e=950501
phin=(p-1)*(q-1)
d=gmpy2.invert(e,phin)
# i 相当于 cipher[len(cipher)-1]，爆破的目标
for i in range(0x30,0x3a):
    tmp1=[res[0]^i] # tmp1 相当于 round_1
    for j in range(1,len(res)):
        tmp1.append(res[j]^tmp1[j-1])
    tmp2=[tmp1[0]^102]# tmp2 相当于 cipher
    for j in range(1,len(tmp1)):
        tmp2.append(tmp1[j]^tmp2[j-1])
    wrong=0
    for m in tmp2: # cipher 中每个元素都必须是十进制数字字符
        if m<0x30 or m>0x39:
            wrong=1
            break
    if wrong:
        continue
    if i==tmp2[len(tmp2)-1]:# 验证爆破的目标和还原出来的cipher[len(cipher)-1]是否相同
        cipher=""
        for k in tmp2:
            cipher+=chr(k)
        cipher_num=int(cipher)
        m=gmpy2.powmod(cipher_num,d,n)# RSA解密
        print(long_to_bytes(m))
# hgame{g0_and_g0_http_5erv3r_nb}

ezvm

vm，调试确定输入的长度应为32
对输入的处理逻辑为：输入的每个字符，左移1位，和一个值异或，然后比较
构造一个长度为32的输入，得到经程序处理后的结果
逆向对输入的处理逻辑，得到输入的每个字符左移1位后，要去异或的值的集合
最后由真正的密文爆破出flag

# -*- coding:utf-8 -*-
s="hgame{abcdefghijklmnopqrstuvwxy}"

# 对输入的处理逻辑：输入的每个字符，左移1位，和一个值异或，然后比较

print(hex((ord("h")<<1)^0x5e))# 0x8e
print(hex((ord("g")<<1)^0x46))# 0x88

# my_res: 构造的输入s，经过程序处理后的结果
my_res=[0x8e,0x88,0xa3,0x99,0xc4,0xa5,0x8b,0xdb,0x97,0x96,0xfc,0xfb,0xe7,0x91,0xb1,0xef,0xb2,0xe3,0xcf,0xc4,0x85,0xde,0xc0,0xb4,0xa0,0xb6,0xdf,0xa2,0xad,0xd3,0x92,0xc1]
# 逆向对输入的处理逻辑，得到输入的每个字符左移1位后，要去异或的值的集合
xor_box=[]
for i in range(len(s)):
    tmp=(ord(s[i])<<1)&0xff
    xor_box.append(tmp^my_res[i])

# res: 真正的密文
res=[0x8e,0x88,0xa3,0x99,0xc4,0xa5,0xc3,0xdd,0x19,0xec,0x6c,0x9b,0xf3,0x1b,0x8b,0x5b,0x3e,0x9b,0xf1,0x86,0xf3,0xf4,0xa4,0xf8,0xf8,0x98,0xab,0x86,0x89,0x61,0x22,0xc1]
flag=""
for i in range(len(res)):
    for j in range(32,128):
        if (j<<1)^xor_box[i]==res[i]:
            flag+=chr(j)
print(flag)
# hgame{Ea$Y-Vm-t0-PrOTeCT_cOde!!}

hardasm

近7000行的汇编指令，应该是有什么地方设计得很巧妙
起调试，构造一个长度为32的输入"hgame{abcdefghijklmnopqrstuvwxy}"
在如下位置下断点
asm-break
程序断下后，观察此时[rsp+70h+var_50]上的数据
可以发现，前6个数据均为非0的0xFF，而后面的数据均为0
这是因为我们构造的输入的前6个字符"hgame{“是正确的，而后面凑长度的字符是错误的
asm-stack
于是我们可以知道
可以通过[rsp+70h+var_50]上连续的0xFF的个数n，确定我们的输入前n个字符是正确的
那么怎么知道[rsp+70h+var_50]上连续的0xFF的个数n呢？我们需要能够打印的函数
程序最后会打印"success"或者"error”，我们可以利用这个打印函数
从框住的汇编指令处可以观察到，我们的目标数据地址是借rcx寄存器传入打印函数的
asm-print
于是我们patch程序，将[rsp+70h+var_50]借rcx传入打印函数，如下
（这里不知道怎么能直接实现lea rcx,[rsp+70h+var_50]，如果有师傅知道，请在评论区留言，谢谢）
asm-patch
这样程序在最后就不会打印"success"或者"error"，而会打印[rsp+70h+var_50]上的数据
将patch应用到程序后，再起调试，同样的输入，在调用打印函数printf后下断，观察打印出的内容
可以看到虽然没有打印出具体的字符（因为0xFF不可见），但是长度是正确的，为6
asm-printf
或者可以用python来确认

import subprocess
flag="hgame{abcdefghijklmnopqrstuvwxy}"
p = subprocess.Popen(["D:\\ctfdownloadfiles\\hardasm.exe"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p.stdin.write(flag.encode())
p.stdin.close()
out = p.stdout.read()
print(len(out))
for c in out:
    print(hex(c))
# 6
# 0xff
# 0xff
# 0xff
# 0xff
# 0xff
# 0xff

最后就是依次爆破每个位置上的字符
根据程序打印出的连续的0xFF的个数来确定某位置上的字符是否正确

# -*- coding:utf-8 -*-
import subprocess
real_flag="hgame{"#绝对正确的前6个字符
cur_index=6#当前爆破的位置
while cur_index<32:
    for i in range(32,128):#当前爆破的位置上的字符
        real_flag_arr = [0] * 32
        for j in range(len(real_flag)):#正确的先复制一下
            real_flag_arr[j]=ord(real_flag[j])
        real_flag_arr[len(real_flag_arr)-1]=ord("}")#最后一个字符"}"固定
        for j in range(len(real_flag_arr)-2,cur_index,-1):#除了当前爆破的位置，其他位置上都设置为32
            real_flag_arr[j]=32
        real_flag_arr[cur_index]=i#设置当前爆破的位置上的字符
        real_flag_arr_s="".join(chr(k) for k in real_flag_arr)#输入到程序中的字符串
        p = subprocess.Popen(["D:\\ctfdownloadfiles\\hardasm.exe"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        p.stdin.write(real_flag_arr_s.encode())
        p.stdin.close()
        out = p.stdout.read()
        if len(out)>cur_index:#判断程序打印出的0xFF的个数是否增加，增加则说明当前爆破的位置上的字符设置的是正确的
            real_flag+=chr(i)
            cur_index+=1
            print(real_flag)
            break
# hgame{r
# hgame{ri
# hgame{rig
# hgame{righ
# hgame{right
# hgame{right_
# hgame{right_y
# hgame{right_yo
# hgame{right_you
# hgame{right_your
# hgame{right_your_
# hgame{right_your_a
# hgame{right_your_as
# hgame{right_your_asm
# hgame{right_your_asm_
# hgame{right_your_asm_i
# hgame{right_your_asm_is
# hgame{right_your_asm_is_
# hgame{right_your_asm_is_g
# hgame{right_your_asm_is_go
# hgame{right_your_asm_is_goo
# hgame{right_your_asm_is_good
# hgame{right_your_asm_is_good!
# hgame{right_your_asm_is_good!!
# hgame{right_your_asm_is_good!!}
# hgame{right_your_asm_is_good!!}

P1umH0

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
REVERSE-COMPETITION-HGAME2022-Week4

REVERSE-COMPETITION-HGAME2022-Week4( WOW )serverezvmhardasm( WOW )32位exe，ida打开观察伪代码逻辑，上面的红框中，输入经过加密，密文放入Buf2中，然后Buf2和已知的密文res比较比较完，打印"win"或者"error"发现下面还有一部分对Buf2处理的代码逻辑，而且几乎和上面对输入加密的结构是一样的于是猜测下面的红框中就是解密逻辑起调试，随便构造一个长度为32的输入在调用memcmp前下断，将内存中Buf2的数据p
复制链接

扫一扫