TestDll

  1. // dllmain.cpp : 定义 DLL 应用程序的入口点。
  2. #include "stdafx.h"
  3. #include <windows.h>
  5. extern "C" __declspec(dllexport)
  6. void funA()
  7. {
  8.     MessageBox(0, L"funA", L"", 0);
  9. }
  11. extern "C" __declspec(dllexport)
  12. void funB()
  13. {
  14.     MessageBox(0, L"funB", L"", 0);
  15. }
  19. BOOL APIENTRY DllMain( HMODULE hModule,
  20.                        DWORD  ul_reason_for_call,
  21.                        LPVOID lpReserved
  22.                      )
  23. {
  24.     switch (ul_reason_for_call)
  25.     {
  26.     case DLL_PROCESS_ATTACH:
  27.     case DLL_THREAD_ATTACH:
  28.     case DLL_THREAD_DETACH:
  29.     case DLL_PROCESS_DETACH:
  30.         break;
  31.     }
  32.     return TRUE;
  33. }

导入导出

  1. // win原理Day002.cpp : 定义控制台应用程序的入口点。
  2. //
  4. #include "stdafx.h"
  5. #include <windows.h>
  8. #define DLL "D:\\ProgramVS\\win原理Day002\\Debug\\TestDll.dll"
  9. //1 把文件读到内存中
  10. char* ReadFileToMemory(char* pFilePath)
  11. {
  12.     //1 获取文件句柄
  13.     HANDLE hFile = CreateFileA(pFilePath,
  14.         GENERIC_READ | GENERIC_WRITE,
  15.         FALSE,
  16.         NULL,
  17.         OPEN_EXISTING,
  18.         FILE_ATTRIBUTE_NORMAL,
  19.         NULL);
  20.     if (hFile == INVALID_HANDLE_VALUE)
  21.     {
  22.         printf("文件打开失败\n");
  23.         return 0;
  24.     }
  25.     //2.获取文件大小
  26.     DWORD dwFileSize = GetFileSize(hFile, NULL);
  27.     //3.申请内存空间
  28.     char* pBuf = new char[dwFileSize]{};
  29.     if (!pBuf)
  30.     {
  31.         CloseHandle(hFile);
  32.         printf("内存申请失败\n");
  33.         return 0;
  34.     }
  35.     //4.读取文件内容到内存空间
  36.     DWORD dwRead;
  37.     ReadFile(hFile, pBuf, dwFileSize, &dwRead, NULL);
  38.     //5. 返回内存地址
  39.     return pBuf;
  40. }
  41. //2 是否是PE文件
  42. bool IsPeFile(char* pBuf)
  43. {
  44.     PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)pBuf;
  45.     if (pDos->e_magic != IMAGE_DOS_SIGNATURE)
  46.     {
  47.         printf("不是PE文件\n");
  48.         return false;
  49.     }
  50.     PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)
  51.         (pDos->e_lfanew + pBuf);
  52.     if (pNt->Signature != IMAGE_NT_SIGNATURE)
  53.     {
  54.         printf("不是PE文件\n");
  55.         return false;
  56.     }
  57.     return true;
  58. }
  59. //3 解析PE(头部重要字段)
  60. void ShowImportantHead(char* pBuf)
  61. {
  62.     PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)pBuf;
  63.     PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(pDos->e_lfanew + pBuf);
  64.     //文件默认加载基址
  65.     printf("默认加载基址:0x%08X\n", pNt->OptionalHeader.ImageBase);
  66.     //文件入口点
  67.     printf("文件入口点:0x%08X\n", pNt->OptionalHeader.AddressOfEntryPoint);
  68.     //文件区段个数
  69.     printf("文件区段个数:%d\n", pNt->FileHeader.NumberOfSections);
  70.     //。。。
  71. }
  73. //RVA to FOA
  74. DWORD RVAtoFOA(DWORD dwRVA, char* pBuf)
  75. {
  76.     PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)pBuf;
  77.     PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(pDos->e_lfanew + pBuf);
  78.     //区段个数（文件头第二个字段）
  79.     DWORD dwCount = pNt->FileHeader.NumberOfSections;
  80.     //区段首地址（IMAGE_FIRST_SECTION）
  81.     PIMAGE_SECTION_HEADER pSec = IMAGE_FIRST_SECTION(pNt);
  83.     for (DWORD i = 0; i < dwCount; i++)
  84.     {
  85.         //FOA = RVA - 内存中区段首地址 + 文件中区段首地址
  86.         if (dwRVA >= pSec->VirtualAddress && 
  87.             dwRVA < pSec->VirtualAddress + pSec->SizeOfRawData)
  88.         {
  89.             return dwRVA - pSec->VirtualAddress + pSec->PointerToRawData;
  90.         }
  91.         //下一个区段表
  92.         pSec++;
  93.     }
  94.     return 0;
  95. }
  97. //遍历导出表
  98. void ShowExportTable(char* pBuf)
  99. {
  100.     PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)pBuf;
  101.     PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(pDos->e_lfanew + pBuf);
  102.     //找到导出表（数据目录表第一项）
  103.     PIMAGE_DATA_DIRECTORY pData = &pNt->OptionalHeader.DataDirectory[0];
  104.     //导出表RVA转FOA
  105.     DWORD dwExportFOA = RVAtoFOA(pData->VirtualAddress, pBuf);
  106.     //得到导出表在文件中的具体地址 = FOA + pBuf
  107.     PIMAGE_EXPORT_DIRECTORY pExport = 
  108.         (PIMAGE_EXPORT_DIRECTORY)(dwExportFOA + pBuf);
  109.     //解析导出表
  110.     printf("模块名：%s\n", RVAtoFOA(pExport->Name, pBuf) + pBuf);
  111.     //导出地址表中函数个数
  112.     //pExport->NumberOfFunctions
  113.     //导出名称表中函数名称个数
  114.     //pExport->NumberOfNames;
  115.     DWORD* pFuncAddr = (DWORD*)(RVAtoFOA(pExport->AddressOfFunctions,pBuf)+pBuf);
  116.     DWORD* pFuncNameAddr = (DWORD*)(RVAtoFOA(pExport->AddressOfNames, pBuf) + pBuf);
  117.     WORD*  pFuncOrdinalAddr = (WORD*)(RVAtoFOA(pExport->AddressOfNameOrdinals, pBuf) + pBuf);
  119.     for (int i = 0; i < pExport->NumberOfFunctions;i++)
  120.     {
  121.         if (pFuncAddr[i] == 0)
  122.         {
  123.             continue;
  124.         }
  125.         //检测是否存在函数名称，如果有就输出
  126.         //判断条件：序号表中存在的序号都是有名称的
  127.         bool bFlag = FALSE;
  128.         for (int j = 0; j < pExport->NumberOfNames; j++)
  129.         {
  130.             if (i == pFuncOrdinalAddr[j])
  131.             {
  132.                 //有名称的函数
  133.                 bFlag = TRUE;
  134.                 DWORD dwNameRVA = pFuncNameAddr[j];
  136.                 printf("函数序号：%d 函数名称【%s】\n", 
  137.                     i + pExport->Base,
  138.                     RVAtoFOA(dwNameRVA,pBuf)+pBuf);
  139.                 break;
  141.             }
  142.         }
  143.         if (!bFlag)
  144.         {
  145.             //i+pExport->Base调用号
  146.             printf("函数序号：%d 函数名称【NULL】\n", i+pExport->Base);
  147.         }
  148.     }
  150. }
  151. //遍历导入表
  152. void ShowImportTable(char* pBuf)
  153. {
  154.     PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)pBuf;
  155.     PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)(pDos->e_lfanew + pBuf);
  156.     //找到导入表(数据目录表的第二项)
  157.     DWORD dwImportRVA = pNt->OptionalHeader.DataDirectory[1].VirtualAddress;
  158.     PIMAGE_IMPORT_DESCRIPTOR pImport =
  159.         (PIMAGE_IMPORT_DESCRIPTOR)(RVAtoFOA(dwImportRVA, pBuf) + pBuf);
  160.     //解析导入表(以全0结构为结尾)
  161.     while (pImport->Name)
  162.     {
  163.         //导入模块名
  164.         printf("导入模块名称：%s\n", RVAtoFOA(pImport->Name, pBuf) + pBuf);
  165.         //导入名称表（以0结构为结尾）
  166.         PIMAGE_THUNK_DATA pThunkINT = 
  167.             (PIMAGE_THUNK_DATA)
  168.             (RVAtoFOA(pImport->OriginalFirstThunk, pBuf) + pBuf);
  169.         //导入地址表（以0结构为结尾）
  170.         PIMAGE_THUNK_DATA pThunkIAT =
  171.             (PIMAGE_THUNK_DATA)
  172.             (RVAtoFOA(pImport->FirstThunk, pBuf) + pBuf);
  173.         while (pThunkINT->u1.AddressOfData)
  174.         {
  175.             //判断导入函数的导入方式
  176.             if (IMAGE_SNAP_BY_ORDINAL32(pThunkINT->u1.AddressOfData))
  177.             {
  178.                 //序号导入
  179.                 //LOWORD(pThunkINT->u1.AddressOfData)
  180.                 printf("\t函数序号：【%d】函数名称：【NULL】\n",
  181.                     pThunkINT->u1.AddressOfData & 0xFFFF);
  182.             } 
  183.             else
  184.             {
  185.                 //名称导入
  186.                 DWORD dwNameFOA = RVAtoFOA(pThunkINT->u1.AddressOfData, pBuf);
  187.                 PIMAGE_IMPORT_BY_NAME pName = 
  188.                     (PIMAGE_IMPORT_BY_NAME)
  189.                     (dwNameFOA + pBuf);
  190.                 printf("\t函数序号：【%d】函数名称：【%s】\n",
  191.                     pName->Hint,pName->Name);
  192.             }
  193.             //下一个导入函数
  194.             pThunkINT++;
  195.             //pThunkIAT++;如果是加载到内存中再做遍历，在磁盘上时，与INT是一样的
  196.         }
  197.         //下一个导入表（下一个导入模块）
  198.         pImport++;
  199.     }
  202. }
  204. int _tmain(int argc, _TCHAR* argv[])
  205. {
  206. //     void(*pFun)();
  207. //     HMODULE hMod = LoadLibraryA(DLL);
  208. //     pFun = (void(*)())GetProcAddress(hMod, (char*)1);
  209. //     pFun();
  210.     char* pBuf = ReadFileToMemory("TestDll.dll");
  211.     if (IsPeFile(pBuf))
  212.     {
  213.         //ShowImportantHead(pBuf);
  214.         //ShowExportTable(pBuf);
  215.         ShowImportTable(pBuf);
  216.     }
  217.     //释放内存
  218.     delete pBuf;
  219.     return 0;
  220. }

TLS

  1. // TLS.cpp : 定义控制台应用程序的入口点。
  2. //
  4. #include "stdafx.h"
  5. #include<windows.h>
  7. #pragma comment(linker, "/INCLUDE:__tls_used")
  9. // TLS变量
  10. __declspec (thread) int  g_nNum = 0x11111111;
  11. __declspec (thread) char g_szStr[] = "TLS g_nNum = 0x%p ...\r\n";
  12. // TLS回调函数A
  13. void NTAPI t_TlsCallBack_A(PVOID DllHandle, DWORD Reason, PVOID Red) {
  14.     if (DLL_THREAD_DETACH == Reason) // 如果线程退出则打印信息
  15.         printf("t_TlsCallBack_A -> ThreadDetach!\r\n");
  16.     return;
  17. }
  18. // TLS回调函数B
  19. void NTAPI t_TlsCallBack_B(PVOID DllHandle, DWORD Reason, PVOID Red) {
  20.     if (DLL_THREAD_DETACH == Reason) // 如果线程退出则打印信息
  21.         printf("t_TlsCallBack_B -> ThreadDetach!\r\n");
  22.     return;
  23. }
  24. /*
  25. * 注册TLS回调函数，".CRT$XLB"的含义是：
  26. * CRT表明使用C RunTime机制
  27. * X表示标识名随机
  28. * L表示TLS callback section
  29. * B其实也可以为B-Y的任意一个字母
  30. */
  31. #pragma data_seg(".CRT$XLB")
  32. PIMAGE_TLS_CALLBACK p_thread_callback[] = {
  33.     t_TlsCallBack_A,
  34.     t_TlsCallBack_B,
  35.     NULL };
  36. #pragma data_seg()
  39. DWORD WINAPI t_ThreadFun(PVOID pParam) {
  40.     printf("t_Thread ->  first printf:");
  41.     printf(g_szStr, g_nNum);
  42.     g_nNum = 0x22222222; // 注意这里
  43.     printf("t_Thread -> second printf:");
  44.     printf(g_szStr, g_nNum);
  45.     return 0;
  46. }
  47. int _tmain(int argc, _TCHAR* argv[]) {
  48.     printf("_tmain -> TlsDemo.exe is runing...\r\n\r\n");
  49.     CreateThread(NULL, 0, t_ThreadFun, NULL, 0, 0);
  50.     Sleep(100);  // 睡眠100毫秒用于确保第一个线程执行完毕
  51.     printf("\r\n");
  52.     CreateThread(NULL, 0, t_ThreadFun, NULL, 0, 0);
  53.     system("pause");
  54.     return 0;
  55. }

延迟加载

  1. // 延迟加载.cpp : 定义控制台应用程序的入口点。
  2. //
  4. #include "stdafx.h"
  5. #include <windows.h>
  6. //包含头文件和库文件
  7. #include <delayimp.h>
  8. #pragma comment(lib, "Delayimp.lib")
  10. //设置“连接器”>“输入”>“延迟加载的DLL”选项
  11. //中的值为我们需要延迟加载的DLL名称（大小写必须完全一致）
  13. int _tmain(int argc, _TCHAR* argv[])
  14. {
  15.     MessageBox(0, 0, 0, 0);
  16.     return 0;
  17. }