REVERSE-COMPETITION-HGAME2022-Week4

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!!} 
  • 3
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

P1umH0

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值