设为首页收藏一下又不会死！新人公告
切换到窄版

 找回密码
 立即注册→加入我们

QQ登录

只需一步，快速开始

搜索
热搜: 下载 VB C 实现 编写
技术宅的结界»论坛 › 计算机技术 › 技巧探讨 › 实现自己的LoadLibrary
返回列表 发新帖
查看: 6400|回复: 2

实现自己的LoadLibrary

[复制链接]
元始天尊
发表于 2015-6-15 00:05:41 | 显示全部楼层 |阅读模式

欢迎访问技术宅的结界，请注册或者登录吧。

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

×
决定实现自己的loadlibrary，已经实现大部分，然而在模拟执行dllmain时却发生异常，查找发现加载的dll导入表没有初始化。
不明白这段代码在哪里实现的，正在研究中，功亏一篑啊
该代码完全独立于ldr结构，并用map结构一次映射所有函数，不需要getproc一个个进行查找，LoadLibary只需要传入完整dll路径
GetProcAddress只需要dll路径以及函数名即可获得函数地址，这部分功能测试正常，500行代码

而输出表部分，很奇怪，懂得高人指点一下：
  1. #include <windows.h>
  2. #include <winternl.h>
  3. #include <map>
  4. #include <string>
  5. using namespace std;

  7. #if defined(WIN64) || defined(_WIN64)
  8. #pragma comment(lib,"ntdll64.lib")
  9. #else
  10. #pragma comment(lib,"ntdll.lib")
  11. #endif

  13. #if defined(UNICODE) || defined(_UNICODE)
  14. #define GetProcAddressT GetProcAddressTW
  15. #define LoadLibraryT LoadLibraryTW
  16. #define FreeLibraryT FreeLibraryTW
  17. #else
  18. #define GetProcAddressT GetProcAddressTA
  19. #define LoadLibraryT LoadLibraryTA
  20. #define FreeLibraryT FreeLibraryTA
  21. #endif

  23. extern "C"
  24. {
  25.         BOOLEAN WINAPI RtlDosPathNameToNtPathName_U(PCWSTR,PUNICODE_STRING,PCWSTR*,PVOID*);
  26.         NTSTATUS WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,ULONG,ULONG,ULONG);
  27.         BOOLEAN WINAPI RtlFreeHeap(PVOID,ULONG,PVOID);
  28.         NTSTATUS WINAPI NtCreateSection(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PLARGE_INTEGER,ULONG,ULONG,HANDLE);
  29.         NTSTATUS WINAPI NtUnmapViewOfSection(HANDLE,PVOID);
  30.         NTSTATUS WINAPI NtProtectVirtualMemory(HANDLE,PVOID,PSIZE_T,ULONG,PULONG);
  31.         NTSTATUS WINAPI NtFlushInstructionCache(HANDLE,PVOID,ULONG);
  32. };



  36. ULONG NTAPI LdrRelocateImageWithBias(PVOID,PIMAGE_NT_HEADERS,LONGLONG ,PCCH,ULONG,ULONG,ULONG);
  37. NTSTATUS NTAPI LdrpSetProtection(PVOID,PIMAGE_NT_HEADERS,BOOLEAN);


  40. #define STATUS_IMAGE_NOT_AT_BASE ((NTSTATUS)0x40000003L)
  41. #define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
  42. #define STATUS_CONFLICTING_ADDRESSES ((NTSTATUS)0xC0000018L)
  43. #define STATUS_INVALID_IMAGE_FORMAT ((NTSTATUS)0xC000007BL)

  45. typedef struct _CLIENT_ID
  46. {
  47.         HANDLE UniqueProcess;
  48.         HANDLE UniqueThread;
  49. } CLIENT_ID;

  51. typedef struct _MTEB
  52. {
  53.         _NT_TIB NtTib;
  54.         PVOID EnvironmentPointer;
  55.         CLIENT_ID ClientId;
  56.         PVOID ActiveRpcHandle;
  57.         PVOID ThreadLocalStoragePointer;
  58.         PPEB Peb;
  59. }MTEB,*PMTEB;

  61. typedef struct _MPEB
  62. {
  63.         DWORD flags;
  64.         PVOID Mutant;
  65.         PVOID ImageBaseAddress;
  66.         PPEB_LDR_DATA Ldr;
  67.         PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
  68.         PVOID SubSystemData;
  69.         PVOID ProcessHeap;
  70. }MPEB,*PMPEB;

  72. struct DllStruct
  73. {
  74.         PVOID EntryPoint;
  75.         PVOID ViewBase;
  76.         SIZE_T ViewSize;
  77.         std::map<std::wstring,FARPROC> FuncMap;//函数映射
  78. };
  79. std::map<std::wstring,DllStruct> DllMap;
  80. CRITICAL_SECTION DllLock;
  81. #define RtlGetProcessHeap() ( (PMPEB)((PMTEB)NtCurrentTeb())->Peb )->ProcessHeap

  83. BOOL WINAPI LoadLibraryTA(LPCSTR DllPath);
  84. BOOL WINAPI LoadLibraryTW(LPCWSTR DllPath);
  85. FARPROC WINAPI GetProcAddressTA(LPCSTR DllPath,LPCSTR ProcName);
  86. FARPROC WINAPI GetProcAddressTW(LPCWSTR DllPath,LPCWSTR ProcName);
  87. BOOL WINAPI FreeLibraryTA(LPCSTR DllPath);
  88. BOOL WINAPI FreeLibraryTW(LPCWSTR DllPath);

  90. BOOL WINAPI LoadLibraryTA(LPCSTR DllPath)
  91. {
  92.         ANSI_STRING DllPathA;
  93.         UNICODE_STRING DllPathW;
  94.         NTSTATUS status;
  95.         if(!DllPath || DllPath[0] == 0)
  96.                 return FALSE;
  97.         WCHAR tmp[0x1000];
  98.         memset(tmp,0,sizeof(tmp));
  99.         RtlInitAnsiString(&DllPathA,DllPath);
  100.         DllPathW.Buffer = tmp;
  101.         DllPathW.MaximumLength = 0x1000;
  102.         status = RtlAnsiStringToUnicodeString(&DllPathW,&DllPathA,FALSE);
  103.         if(!NT_SUCCESS(status))
  104.                 return FALSE;
  105.         return LoadLibraryTW(DllPathW.Buffer);
  106. }

  108. BOOL WINAPI LoadLibraryTW(LPCWSTR DllPath)
  109. {
  110.         if(!DllPath || DllPath[0] == 0)
  111.                 return FALSE;
  112.         BOOL result = FALSE;
  113.         EnterCriticalSection(&DllLock);
  114.         //查找Map，遍历导出表，更新Map
  115.         std::map<std::wstring,DllStruct>::iterator itor = DllMap.find(DllPath);
  116.         if(itor != DllMap.end())
  117.         {
  118.                 result = FALSE;
  119.                 goto ENDLOAD;
  120.         }

  122.         UNICODE_STRING NtPathDllName;
  123.         OBJECT_ATTRIBUTES ObjectAttributes;
  124.         HANDLE FileHandle = NULL,SectionHandle = NULL;
  125.         IO_STATUS_BLOCK IoStatusBlock;
  126.         NTSTATUS Status;
  127.         if(!RtlDosPathNameToNtPathName_U(DllPath,&NtPathDllName,NULL,NULL))
  128.         {
  129.                 result = FALSE;
  130.                 goto ENDLOAD;
  131.         }
  132.         InitializeObjectAttributes(&ObjectAttributes,&NtPathDllName,OBJ_CASE_INSENSITIVE,NULL,NULL);
  133.         Status = NtOpenFile(&FileHandle,SYNCHRONIZE | FILE_EXECUTE | FILE_READ_DATA,&ObjectAttributes,&IoStatusBlock,
  134.                 FILE_SHARE_READ | FILE_SHARE_DELETE,FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
  135.         if (!NT_SUCCESS(Status))
  136.         {//尝试以只读方式打开
  137.                 Status = NtOpenFile(&FileHandle,SYNCHRONIZE | FILE_EXECUTE,&ObjectAttributes,&IoStatusBlock,
  138.                         FILE_SHARE_READ | FILE_SHARE_DELETE,FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
  139.         }
  140.         if(!NT_SUCCESS(Status))
  141.         {
  142.                 result = FALSE;
  143.                 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathDllName.Buffer);
  144.                 goto ENDLOAD;
  145.         }
  146.         Status = NtCreateSection(&SectionHandle,SECTION_MAP_READ | SECTION_MAP_EXECUTE |SECTION_MAP_WRITE | SECTION_QUERY,
  147.                 NULL,NULL,PAGE_EXECUTE,SEC_IMAGE,FileHandle);
  148.         NtClose(FileHandle);
  149.         if(!NT_SUCCESS(Status))
  150.         {
  151.                 result = FALSE;
  152.                 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathDllName.Buffer);
  153.                 goto ENDLOAD;
  154.         }
  155.         RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathDllName.Buffer);

  157.         PVOID ViewBase = NULL;
  158.         SIZE_T ViewSize = 0;
  159.         PIMAGE_NT_HEADERS NtHeaders = NULL;
  160.         PIMAGE_DOS_HEADER DosHeader = NULL;
  161.         PVOID EntryPoint = NULL;
  162.         Status = NtMapViewOfSection(SectionHandle,(HANDLE)-1/*NtCurrentProcess()*/,&ViewBase,0,0,NULL,&ViewSize,1/*ViewShare*/,0,PAGE_READWRITE);

  164.         if(ViewBase)
  165.         {
  166.                 DosHeader = (PIMAGE_DOS_HEADER)ViewBase;
  167.                 if(DosHeader->e_magic == IMAGE_DOS_SIGNATURE && DosHeader->e_lfanew  && DosHeader->e_lfanew < ViewSize)
  168.                 {
  169.                         NtHeaders = (PIMAGE_NT_HEADERS)((BYTE*)DosHeader + DosHeader->e_lfanew);
  170.                         if(NtHeaders->Signature != IMAGE_NT_SIGNATURE)
  171.                                 NtHeaders = NULL;
  172.                 }
  173.                 if(!NtHeaders || NtHeaders->OptionalHeader.AddressOfEntryPoint == NULL || !(NtHeaders->FileHeader.Characteristics & IMAGE_FILE_DLL))
  174.                 {
  175.                         result = FALSE;
  176.                         goto ENDLOAD;
  177.                 }
  178.                 EntryPoint = (PVOID)(NtHeaders->OptionalHeader.AddressOfEntryPoint + (BYTE*)ViewBase);
  179.         }

  181.         if(Status == STATUS_IMAGE_NOT_AT_BASE)
  182.         {//重定位
  183.                 if(!(NtHeaders->FileHeader.Characteristics & IMAGE_FILE_RELOCS_STRIPPED))
  184.                 {
  185.                         USHORT Directory = IMAGE_DIRECTORY_ENTRY_BASERELOC;
  186.                         ULONG RelocDataSize = 0;
  187.                         PVOID RelocData = NULL;
  188.                         if(NtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)
  189.                         {
  190.                                 PIMAGE_NT_HEADERS32 tpnh = (PIMAGE_NT_HEADERS32)NtHeaders;
  191.                                 if(Directory >= tpnh->OptionalHeader.NumberOfRvaAndSizes)
  192.                                         return NULL;
  193.                                 DWORD VA = tpnh->OptionalHeader.DataDirectory[Directory].VirtualAddress;
  194.                                 if(VA == NULL)
  195.                                         return NULL;
  196.                                 RelocDataSize = tpnh->OptionalHeader.DataDirectory[Directory].Size;
  197.                                 RelocData = (PVOID)((BYTE*)ViewBase + VA);
  198.                         }
  199.                         else
  200.                         {
  201.                                 PIMAGE_NT_HEADERS64 tpnh = (PIMAGE_NT_HEADERS64)NtHeaders;
  202.                                 if(Directory >= tpnh->OptionalHeader.NumberOfRvaAndSizes)
  203.                                         return NULL;
  204.                                 DWORD VA = tpnh->OptionalHeader.DataDirectory[Directory].VirtualAddress;
  205.                                 if(VA == NULL)
  206.                                         return NULL;
  207.                                 RelocDataSize = tpnh->OptionalHeader.DataDirectory[Directory].Size;
  208.                                 RelocData = (PVOID)((BYTE*)ViewBase + VA);
  209.                         }
  210.                         if(RelocData && RelocDataSize)
  211.                         {
  212.                                 Status = LdrpSetProtection(ViewBase,NtHeaders,FALSE);
  213.                                 if(NT_SUCCESS(Status))
  214.                                 {
  215.                                         Status = LdrRelocateImageWithBias(ViewBase, NtHeaders, 0LL, NULL, STATUS_SUCCESS,STATUS_CONFLICTING_ADDRESSES, STATUS_INVALID_IMAGE_FORMAT);
  216.                                         LdrpSetProtection(ViewBase,NtHeaders,TRUE);
  217.                                         if(NT_SUCCESS(Status))
  218.                                         {
  219.                                                 goto ENDLOAD1;
  220.                                         }
  221.                                 }
  222.                         }
  223.                 }
  224.                 if(!NT_SUCCESS(Status) || ViewBase)
  225.                 {
  226.                         NtUnmapViewOfSection((HANDLE)-1/*NtCurrentProcess()*/,ViewBase);
  227.                         result = FALSE;
  228.                 }
  229.         }
  230.         else if(!NT_SUCCESS(Status))
  231.         {
  232.                 result = FALSE;
  233.                 goto ENDLOAD;
  234.         }
  235. ENDLOAD1:
  236.         NtClose(SectionHandle);
  237.         if(NT_SUCCESS(Status))
  238.                 result = TRUE;
  239.         DllStruct& ds = DllMap[DllPath];
  240.         ds.EntryPoint = EntryPoint;
  241.         ds.ViewBase = ViewBase;
  242.         ds.ViewSize = ViewSize;
  243.         {
  244.                 typedef BOOLEAN (WINAPI *PDLL_INIT_ROUTINE)( PVOID DllHandle,ULONG Reason,PCONTEXT Context );
  245. //                ((PDLL_INIT_ROUTINE)EntryPoint)(ViewBase,DLL_PROCESS_ATTACH,NULL);
  246.                 PVOID BaseAddress = ViewBase;
  247.                 USHORT Directory = IMAGE_DIRECTORY_ENTRY_EXPORT;
  248.                 PIMAGE_EXPORT_DIRECTORY ExportDir = NULL;
  249.                 ULONG ExportDirSize = 0;
  250.                 if(NtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)
  251.                 {
  252.                         PIMAGE_NT_HEADERS32 tpnh = (PIMAGE_NT_HEADERS32)NtHeaders;
  253.                         if(Directory >= tpnh->OptionalHeader.NumberOfRvaAndSizes)
  254.                                 return NULL;
  255.                         DWORD VA = tpnh->OptionalHeader.DataDirectory[Directory].VirtualAddress;
  256.                         if(VA == NULL)
  257.                                 return NULL;
  258.                         ExportDirSize = tpnh->OptionalHeader.DataDirectory[Directory].Size;
  259.                         ExportDir = (PIMAGE_EXPORT_DIRECTORY)((BYTE*)ViewBase + VA);
  260.                 }
  261.                 else
  262.                 {
  263.                         PIMAGE_NT_HEADERS64 tpnh = (PIMAGE_NT_HEADERS64)NtHeaders;
  264.                         if(Directory >= tpnh->OptionalHeader.NumberOfRvaAndSizes)
  265.                                 return NULL;
  266.                         DWORD VA = tpnh->OptionalHeader.DataDirectory[Directory].VirtualAddress;
  267.                         if(VA == NULL)
  268.                                 return NULL;
  269.                         ExportDirSize = tpnh->OptionalHeader.DataDirectory[Directory].Size;
  270.                         ExportDir = (PIMAGE_EXPORT_DIRECTORY)((BYTE*)ViewBase + VA);
  271.                 }
  272.                 PULONG NameTable = (PULONG)((ULONG_PTR)BaseAddress + (ULONG_PTR)ExportDir->AddressOfNames);
  273.                 PUSHORT OrdinalTable = (PUSHORT)((ULONG_PTR)BaseAddress + (ULONG_PTR)ExportDir->AddressOfNameOrdinals);
  274.                 PULONG AddressOfFunctions = (PULONG)((ULONG_PTR)BaseAddress + (ULONG_PTR)ExportDir->AddressOfFunctions);
  275.                 USHORT Ordinal = -1;
  276.                 for(LONG i = 0;i < ExportDir->NumberOfNames;i++)
  277.                 {
  278.                         PCHAR FuncName = (PCHAR)((ULONG_PTR)BaseAddress + NameTable[i]);
  279.                         ANSI_STRING FuncNameA;
  280.                         UNICODE_STRING FuncNameW;
  281.                         WCHAR tmp[0x1000];
  282.                         memset(tmp,0,sizeof(tmp));
  283.                         RtlInitAnsiString(&FuncNameA,FuncName);
  284.                         FuncNameW.Buffer = tmp;
  285.                         FuncNameW.MaximumLength = 0x1000;
  286.                         Status = RtlAnsiStringToUnicodeString(&FuncNameW,&FuncNameA,FALSE);
  287.                         if(NT_SUCCESS(Status))
  288.                         {
  289.                                 Ordinal = OrdinalTable[i];
  290.                                 if(Ordinal >=0 && Ordinal < ExportDir->NumberOfFunctions)
  291.                                 {
  292.                                         ULONG_PTR Function = (ULONG_PTR)BaseAddress + AddressOfFunctions[Ordinal];
  293.                                         if(!(Function > (ULONG_PTR)ExportDir && Function < (ULONG_PTR)ExportDir + ExportDirSize))
  294.                                         {
  295.                                                 ds.FuncMap[FuncNameW.Buffer] = (FARPROC)Function;
  296.                                         }
  297.                                 }
  298.                         }
  299.                 }
  300.         }

  302. ENDLOAD:
  303.         LeaveCriticalSection(&DllLock);
  304.         return result;
  305. }

  307. NTSTATUS NTAPI LdrpSetProtection(PVOID ViewBase,PIMAGE_NT_HEADERS NtHeaders,BOOLEAN Restore)
  308. {
  309.         NTSTATUS Status;
  310.         PVOID SectionBase;
  311.         SIZE_T SectionSize;
  312.         ULONG NewProtection, OldProtection, i;
  313. #define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER) ((ULONG_PTR)(ntheader) + FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + ((ntheader))->FileHeader.SizeOfOptionalHeader ))
  314.         PIMAGE_SECTION_HEADER Section = IMAGE_FIRST_SECTION(NtHeaders);
  315.         for (i = 0; i < NtHeaders->FileHeader.NumberOfSections; i++)
  316.         {
  317.                 if ((Section->SizeOfRawData) && !(Section->Characteristics & IMAGE_SCN_MEM_WRITE))
  318.                 {
  319.                         if (Restore)
  320.                         {
  321.                                 if (Section->Characteristics & IMAGE_SCN_MEM_EXECUTE)
  322.                                 {
  323.                                         NewProtection = PAGE_EXECUTE;
  324.                                 }
  325.                                 else
  326.                                 {
  327.                                         NewProtection = PAGE_READONLY;
  328.                                 }

  330.                                 if (Section->Characteristics & IMAGE_SCN_MEM_NOT_CACHED)
  331.                                 {
  332.                                         NewProtection |= PAGE_NOCACHE;
  333.                                 }
  334.                         }
  335.                         else
  336.                         {
  337.                                 NewProtection = PAGE_READWRITE;
  338.                         }

  340.                         SectionBase = (PVOID)((ULONG_PTR)ViewBase + Section->VirtualAddress);
  341.                         SectionSize = Section->SizeOfRawData;
  342.                         if (SectionSize)
  343.                         {
  344.                                 Status = NtProtectVirtualMemory((HANDLE)-1,&SectionBase,&SectionSize,NewProtection,&OldProtection);
  345.                                 if (!NT_SUCCESS(Status)) return Status;
  346.                         }
  347.                 }
  348.                 Section++;
  349.         }
  350.         if (Restore) NtFlushInstructionCache((HANDLE)-1, NULL, 0);
  351.         return STATUS_SUCCESS;
  352. }

  354. ULONG NTAPI LdrRelocateImageWithBias(PVOID BaseAddress,PIMAGE_NT_HEADERS NtHeaders,LONGLONG AdditionalBias,PCCH  LoaderName,ULONG Success,ULONG Conflict,ULONG Invalid)
  355. {
  356. #define SWAPW(x) (x)
  357. #define SWAPD(x) (x)
  358. #define SWAPQ(x) (x)
  359.         PIMAGE_DATA_DIRECTORY RelocationDDir;
  360.         PIMAGE_BASE_RELOCATION RelocationDir, RelocationEnd;
  361.         ULONG Count;
  362.         ULONG_PTR Address;
  363.         PUSHORT TypeOffset;
  364.         LONGLONG Delta;

  366.         if (SWAPW(NtHeaders->FileHeader.Characteristics) & IMAGE_FILE_RELOCS_STRIPPED)
  367.         {
  368.                 return Conflict;
  369.         }
  370.         RelocationDDir = &NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
  371.         if (SWAPD(RelocationDDir->VirtualAddress) == 0 || SWAPD(RelocationDDir->Size) == 0)
  372.         {
  373.                 return Success;
  374.         }
  375.         Delta = (ULONG_PTR)BaseAddress - SWAPD(NtHeaders->OptionalHeader.ImageBase) + AdditionalBias;
  376.         RelocationDir = (PIMAGE_BASE_RELOCATION)((ULONG_PTR)BaseAddress + SWAPD(RelocationDDir->VirtualAddress));
  377.         RelocationEnd = (PIMAGE_BASE_RELOCATION)((ULONG_PTR)RelocationDir + SWAPD(RelocationDDir->Size));
  378.         while (RelocationDir < RelocationEnd && SWAPW(RelocationDir->SizeOfBlock) > 0)
  379.         {
  380.                 SHORT Offset;
  381.                 USHORT Type;
  382.                 ULONG i;
  383.                 PUSHORT ShortPtr;
  384.                 PULONG LongPtr;
  385.                 PULONGLONG LongLongPtr;

  387.                 Count = (SWAPW(RelocationDir->SizeOfBlock) - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(USHORT);
  388.                 Address = (ULONG_PTR)(RelocationDir->VirtualAddress);
  389.                 TypeOffset = (PUSHORT)(RelocationDir + 1);

  391.                 for (ULONG i = 0; i < Count; i++)
  392.                 {
  393.                         Offset = SWAPW(*TypeOffset) & 0xFFF;
  394.                         Type = SWAPW(*TypeOffset) >> 12;
  395.                         ShortPtr = (PUSHORT)Offset;

  397.                         if ((ULONG_PTR)ShortPtr < (ULONG_PTR)RelocationDir || (ULONG_PTR)ShortPtr >= (ULONG_PTR)RelocationEnd)
  398.                                 continue;

  400.                         switch (Type)
  401.                         {
  402.                                 /* case IMAGE_REL_BASED_SECTION : */
  403.                                 /* case IMAGE_REL_BASED_REL32 : */
  404.                         case IMAGE_REL_BASED_ABSOLUTE:
  405.                                 break;
  406.                         case IMAGE_REL_BASED_HIGH:
  407.                                 *ShortPtr = HIWORD(MAKELONG(0, *ShortPtr) + (Delta & 0xFFFFFFFF));
  408.                                 break;
  409.                         case IMAGE_REL_BASED_LOW:
  410.                                 *ShortPtr = SWAPW(*ShortPtr) + LOWORD(Delta & 0xFFFF);
  411.                                 break;
  412.                         case IMAGE_REL_BASED_HIGHLOW:
  413.                                 LongPtr = (PULONG)Offset;
  414.                                 *LongPtr = SWAPD(*LongPtr) + (Delta & 0xFFFFFFFF);
  415.                                 break;
  416.                         case IMAGE_REL_BASED_DIR64:
  417.                                 LongLongPtr = (PUINT64)Offset;
  418.                                 *LongLongPtr = SWAPQ(*LongLongPtr) + Delta;
  419.                                 break;
  420.                         case IMAGE_REL_BASED_HIGHADJ:
  421.                         case IMAGE_REL_BASED_MIPS_JMPADDR:
  422.                         default:
  423.                                 RelocationDir = (PIMAGE_BASE_RELOCATION)NULL;
  424.                         }
  425.                         TypeOffset++;
  426.                 }
  427.                 RelocationDir = (PIMAGE_BASE_RELOCATION)TypeOffset;
  428.                 if (RelocationDir == NULL)
  429.                 {
  430.                         return Invalid;
  431.                 }
  432.         }
  433.         return Success;
  434. }

  436. FARPROC WINAPI GetProcAddressTA(LPCSTR DllPath,LPCSTR ProcName)
  437. {
  438.         ANSI_STRING DllPathA,ProcNameA;
  439.         UNICODE_STRING DllPathW,ProcNameW;
  440.         NTSTATUS status;
  441.         if(!DllPath || !ProcName || DllPath[0] == 0 || ProcName[0] == 0)
  442.                 return NULL;
  443.         WCHAR tmp1[0x1000],tmp2[0x1000];
  444.         memset(tmp1,0,sizeof(tmp1));
  445.         memset(tmp2,0,sizeof(tmp2));
  446.         RtlInitAnsiString(&DllPathA,DllPath);
  447.         RtlInitAnsiString(&ProcNameA,ProcName);
  448.         DllPathW.Buffer = tmp1;
  449.         DllPathW.MaximumLength = 0x1000;
  450.         ProcNameW.Buffer = tmp2;
  451.         ProcNameW.MaximumLength = 0x1000;
  452.         status = RtlAnsiStringToUnicodeString(&DllPathW,&DllPathA,FALSE);
  453.         if(!NT_SUCCESS(status))
  454.                 return FALSE;
  455.         status = RtlAnsiStringToUnicodeString(&ProcNameW,&ProcNameA,FALSE);
  456.         if(!NT_SUCCESS(status))
  457.                 return FALSE;
  458.         return GetProcAddressTW(DllPathW.Buffer,ProcNameW.Buffer);
  459. }

  461. FARPROC WINAPI GetProcAddressTW(LPCWSTR DllPath,LPCWSTR ProcName)
  462. {
  463.         if(!DllPath || !ProcName || DllPath[0] == 0 || ProcName[0] == 0)
  464.                 return NULL;
  465.         FARPROC result = NULL;
  466.         EnterCriticalSection(&DllLock);
  467.         std::map<std::wstring,DllStruct>::iterator itor1 = DllMap.find(DllPath);
  468.         if(itor1 != DllMap.end())
  469.         {
  470.                 std::map<std::wstring,FARPROC>::iterator itor2 = (*itor1).second.FuncMap.find(ProcName);
  471.                 if(itor2 != (*itor1).second.FuncMap.end())
  472.                 {
  473.                         result = (*itor2).second;
  474.                 }
  475.         }
  476.         LeaveCriticalSection(&DllLock);
  477.         return result;
  478. }

  480. BOOL WINAPI FreeLibraryTA(LPCSTR DllPath)
  481. {
  482.         ANSI_STRING DllPathA;
  483.         UNICODE_STRING DllPathW;
  484.         NTSTATUS status;
  485.         if(!DllPath || DllPath[0] == 0)
  486.                 return FALSE;
  487.         WCHAR tmp[0x1000];
  488.         memset(tmp,0,sizeof(tmp));
  489.         RtlInitAnsiString(&DllPathA,DllPath);
  490.         DllPathW.Buffer = tmp;
  491.         DllPathW.MaximumLength = 0x1000;
  492.         status = RtlAnsiStringToUnicodeString(&DllPathW,&DllPathA,FALSE);
  493.         if(!NT_SUCCESS(status))
  494.                 return FALSE;
  495.         return FreeLibraryTW(DllPathW.Buffer);
  496. }

  498. BOOL WINAPI FreeLibraryTW(LPCWSTR DllPath)
  499. {
  500.         BOOL result = FALSE;
  501.         if(!DllPath || DllPath[0] == 0)
  502.                 return FALSE;

  504.         EnterCriticalSection(&DllLock);
  505.         std::map<std::wstring,DllStruct>::iterator itor = DllMap.find(DllPath);
  506.         if(itor == DllMap.end())
  507.         {
  508.                 result = FALSE;
  509.                 goto ENDFREE;
  510.         }

  512.         NTSTATUS Status;
  513.         PVOID BaseAddress = (*itor).second.ViewBase;
  514.         PVOID EntryPoint = (*itor).second.EntryPoint;

  516.         typedef BOOLEAN (WINAPI *PDLL_INIT_ROUTINE)( PVOID DllHandle,ULONG Reason,PCONTEXT Context );
  517.         ((PDLL_INIT_ROUTINE)EntryPoint)(BaseAddress,DLL_PROCESS_ATTACH,NULL);
  518.         Status = NtUnmapViewOfSection((HANDLE)-1, BaseAddress);
  519.         if(NT_SUCCESS(Status))
  520.                 result = TRUE;
  521. ENDFREE:
  522.         LeaveCriticalSection(&DllLock);
  523.         return result;
  524. }

  526. void main()
  527. {
  528.         InitializeCriticalSection(&DllLock);
  529.         LoadLibraryTA("d:\\1.dll");
  530.         FARPROC func=GetProcAddressTA("d:\\1.dll","func");
  531.         ((void (__cdecl *)())func)();
  532. }
复制代码


回复

使用道具 举报

元始天尊
 楼主| 发表于 2015-6-18 23:37:09 | 显示全部楼层
完善后的代码，，可以弹出MessageBox
  1. #undef _WIN32_WINNT
  2. #define _WIN32_WINNT 0x0500

  4. #include <windows.h>
  5. #include <winternl.h>
  6. #include <Shlwapi.h>
  7. #include <map>
  8. #include <string>
  9. using namespace std;

  11. #pragma comment(lib,"user32.lib")
  12. #pragma comment(lib,"Shlwapi.lib")

  14. #if defined(WIN64) || defined(_WIN64)
  15. #pragma comment(lib,"ntdll64.lib")
  16. #else
  17. #pragma comment(lib,"ntdll.lib")
  18. #endif

  20. #if defined(UNICODE) || defined(_UNICODE)
  21. #define GetProcAddressT GetProcAddressTW
  22. #define LoadLibraryT LoadLibraryTW
  23. #define FreeLibraryT FreeLibraryTW
  24. #else
  25. #define GetProcAddressT GetProcAddressTA
  26. #define LoadLibraryT LoadLibraryTA
  27. #define FreeLibraryT FreeLibraryTA
  28. #endif

  30. extern "C"
  31. {
  32.         BOOLEAN WINAPI RtlDosPathNameToNtPathName_U(PCWSTR,PUNICODE_STRING,PCWSTR*,PVOID*);
  33.         NTSTATUS WINAPI NtMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,ULONG,ULONG,ULONG);
  34.         BOOLEAN WINAPI RtlFreeHeap(PVOID,ULONG,PVOID);
  35.         NTSTATUS WINAPI NtCreateSection(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PLARGE_INTEGER,ULONG,ULONG,HANDLE);
  36.         NTSTATUS WINAPI NtUnmapViewOfSection(HANDLE,PVOID);
  37.         NTSTATUS WINAPI NtProtectVirtualMemory(HANDLE,PVOID,PSIZE_T,ULONG,PULONG);
  38.         NTSTATUS WINAPI NtFlushInstructionCache(HANDLE,PVOID,ULONG);
  39. };


  42. void RtlImageDirectoryEntryToData(PIMAGE_NT_HEADERS,USHORT,ULONG*,PVOID*,PVOID) ;
  43. ULONG NTAPI LdrRelocateImageWithBias(PVOID,PIMAGE_NT_HEADERS,LONGLONG ,PCCH,ULONG,ULONG,ULONG);
  44. NTSTATUS NTAPI LdrpSetProtection(PVOID,PIMAGE_NT_HEADERS,BOOLEAN);

  46. #define OBJ_CASE_INSENSITIVE    0x00000040L
  47. #define STATUS_IMAGE_NOT_AT_BASE ((NTSTATUS)0x40000003L)
  48. #define STATUS_SUCCESS ((NTSTATUS)0x00000000L)
  49. #define STATUS_CONFLICTING_ADDRESSES ((NTSTATUS)0xC0000018L)
  50. #define STATUS_INVALID_IMAGE_FORMAT ((NTSTATUS)0xC000007BL)
  51. #define FILE_NON_DIRECTORY_FILE 0x00000040
  52. #define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020

  54. typedef struct _CLIENT_ID
  55. {
  56.         HANDLE UniqueProcess;
  57.         HANDLE UniqueThread;
  58. } CLIENT_ID;

  60. typedef struct _MTEB
  61. {
  62.         _NT_TIB NtTib;
  63.         PVOID EnvironmentPointer;
  64.         CLIENT_ID ClientId;
  65.         PVOID ActiveRpcHandle;
  66.         PVOID ThreadLocalStoragePointer;
  67.         PPEB Peb;
  68. }MTEB,*PMTEB;

  70. typedef struct _MPEB_LDR_DATA
  71. {
  72.         UINT32 Length;
  73.         UCHAR Initialized;
  74.         PVOID SsHandle;
  75.         LIST_ENTRY InLoadOrderModuleList;
  76.         LIST_ENTRY InMemoryOrderModuleList;
  77.         LIST_ENTRY InInitializationOrderModuleList;
  78. }MPEB_LDR_DATA,*PMPEB_LDR_DATA;

  80. typedef struct _LDR_MODULE
  81. {
  82.         LIST_ENTRY InLoadOrderModuleList;
  83.         LIST_ENTRY InMemoryOrderModuleList;
  84.         LIST_ENTRY InInitializationOrderModuleList;
  85.         PVOID BaseAddress;
  86.         PVOID EntryPoint;
  87.         ULONG SizeOfImage;
  88.         UNICODE_STRING FullDllName;
  89. }LDR_MODULE,*PLDR_MODULE;

  91. typedef struct _MPEB
  92. {
  93.         DWORD flags;
  94.         PVOID Mutant;
  95.         PVOID ImageBaseAddress;
  96.         PMPEB_LDR_DATA Ldr;
  97.         PVOID ProcessParameters;
  98.         PVOID SubSystemData;
  99.         PVOID ProcessHeap;
  100. }MPEB,*PMPEB;

  102. struct DllStruct
  103. {
  104.         PVOID EntryPoint;
  105.         PVOID ViewBase;
  106.         SIZE_T ViewSize;
  107.         std::map<std::wstring,FARPROC> FuncMap;//函数映射
  108. };
  109. std::map<std::wstring,DllStruct> DllMap;
  110. CRITICAL_SECTION DllLock;
  111. #define RtlGetProcessHeap() ( (PMPEB)((PMTEB)NtCurrentTeb())->Peb )->ProcessHeap
  112. #define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)
  113. #define InitializeObjectAttributes( p, n, a, r, s ) { (p)->Length = sizeof( OBJECT_ATTRIBUTES ); (p)->RootDirectory = r; (p)->Attributes = a; (p)->ObjectName = n; (p)->SecurityDescriptor = s; (p)->SecurityQualityOfService = NULL; }
  114. #define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER) ((ULONG_PTR)(ntheader) + FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + ((ntheader))->FileHeader.SizeOfOptionalHeader ))

  116. BOOL WINAPI LoadLibraryTA(LPCSTR DllPath);
  117. BOOL WINAPI LoadLibraryTW(LPCWSTR DllPath);
  118. FARPROC WINAPI GetProcAddressTA(LPCSTR DllPath,LPCSTR ProcName);
  119. FARPROC WINAPI GetProcAddressTW(LPCWSTR DllPath,LPCWSTR ProcName);
  120. BOOL WINAPI FreeLibraryTA(LPCSTR DllPath);
  121. BOOL WINAPI FreeLibraryTW(LPCWSTR DllPath);

  123. #define SWAPW(x) (x)
  124. #define SWAPD(x) (x)
  125. #define SWAPQ(x) (x)
  126. #define RVA(m, b) ((PVOID)((ULONG_PTR)(b) + (ULONG_PTR)(m)))

  128. typedef BOOLEAN (WINAPI *PDLL_INIT_ROUTINE)( PVOID DllHandle,ULONG Reason,PCONTEXT Context );

  130. void GetExportFuncs( PIMAGE_NT_HEADERS NtHeaders, PVOID ViewBase, DllStruct* ds)
  131. {
  132.         PIMAGE_EXPORT_DIRECTORY ExportDir = NULL;
  133.         ULONG ExportDirSize = 0;
  134.         if(!NtHeaders && ViewBase)
  135.         {
  136.                 PIMAGE_DOS_HEADER DosHeader = (PIMAGE_DOS_HEADER)ViewBase;
  137.                 NtHeaders = (PIMAGE_NT_HEADERS)((BYTE*)DosHeader + DosHeader->e_lfanew);
  138.         }
  139.         if(!NtHeaders)
  140.                 return;
  141.         RtlImageDirectoryEntryToData(NtHeaders, IMAGE_DIRECTORY_ENTRY_EXPORT, &ExportDirSize, (PVOID*)&ExportDir, ViewBase);
  142.         PULONG NameTable = (PULONG)((ULONG_PTR)ViewBase + (ULONG_PTR)ExportDir->AddressOfNames);
  143.         PUSHORT OrdinalTable = (PUSHORT)((ULONG_PTR)ViewBase + (ULONG_PTR)ExportDir->AddressOfNameOrdinals);
  144.         PULONG AddressOfFunctions = (PULONG)((ULONG_PTR)ViewBase + (ULONG_PTR)ExportDir->AddressOfFunctions);
  145.         USHORT Ordinal = -1;
  146.         for(LONG i = 0;i < ExportDir->NumberOfNames;i++)
  147.         {
  148.                 PCHAR FuncName = (PCHAR)((ULONG_PTR)ViewBase + NameTable[i]);
  149.                 ANSI_STRING FuncNameA;
  150.                 UNICODE_STRING FuncNameW;
  151.                 WCHAR tmp[0x1000];
  152.                 memset(tmp,0,sizeof(tmp));
  153.                 RtlInitAnsiString(&FuncNameA,FuncName);
  154.                 FuncNameW.Buffer = tmp;
  155.                 FuncNameW.MaximumLength = 0x1000;
  156.                 NTSTATUS Status = RtlAnsiStringToUnicodeString(&FuncNameW,&FuncNameA,FALSE);
  157.                 if(NT_SUCCESS(Status))
  158.                 {
  159.                         Ordinal = OrdinalTable[i];
  160.                         if(Ordinal >=0 && Ordinal < ExportDir->NumberOfFunctions)
  161.                         {
  162.                                 ULONG_PTR Function = (ULONG_PTR)ViewBase + AddressOfFunctions[Ordinal];
  163.                                 if(!(Function > (ULONG_PTR)ExportDir && Function < (ULONG_PTR)ExportDir + ExportDirSize))
  164.                                 {
  165.                                         ds->FuncMap[FuncNameW.Buffer] = (FARPROC)Function;
  166.                                 }
  167.                         }
  168.                 }
  169.         }
  170. }

  172. BOOL WINAPI LoadLibraryTA(LPCSTR DllPath)
  173. {
  174.         ANSI_STRING DllPathA;
  175.         UNICODE_STRING DllPathW;
  176.         NTSTATUS status;
  177.         if(!DllPath || DllPath[0] == 0)
  178.                 return FALSE;
  179.         WCHAR tmp[0x1000];
  180.         memset(tmp,0,sizeof(tmp));
  181.         RtlInitAnsiString(&DllPathA,DllPath);
  182.         DllPathW.Buffer = tmp;
  183.         DllPathW.MaximumLength = 0x1000;
  184.         status = RtlAnsiStringToUnicodeString(&DllPathW,&DllPathA,FALSE);
  185.         if(!NT_SUCCESS(status))
  186.                 return FALSE;
  187.         return LoadLibraryTW(DllPathW.Buffer);
  188. }

  190. BOOL LdrpLoadImportModule(LPSTR ImportName, PVOID BaseAddress, LPWSTR pDllPath)
  191. {
  192.         PVOID Address = (PVOID)LoadLibraryA(ImportName);
  193.         Address = (PVOID)((ULONG_PTR)Address&~3);
  194.         //遍历Ldr找到全路径
  195.         PLIST_ENTRY ListHead = &((PMPEB)((PMTEB)NtCurrentTeb())->Peb)->Ldr->InLoadOrderModuleList;
  196.         PLIST_ENTRY Next = ListHead->Flink;
  197.         while(Next != ListHead)
  198.         {
  199.                 PLDR_MODULE Cur = (PLDR_MODULE)Next;
  200.                 if(Cur->BaseAddress == Address)
  201.                 {
  202.                         memset(pDllPath,0,0x1000);
  203.                         wcsncpy(pDllPath,Cur->FullDllName.Buffer,Cur->FullDllName.Length);
  204.                         std::map<std::wstring,DllStruct>::iterator itor = DllMap.find(pDllPath);
  205.                         if(itor == DllMap.end())
  206.                         {
  207.                                 DllStruct& ds= DllMap[pDllPath];
  208.                                 ds.EntryPoint = Cur->EntryPoint;
  209.                                 ds.ViewBase = Cur->BaseAddress;
  210.                                 ds.ViewSize = Cur->SizeOfImage;
  211.                                 GetExportFuncs(NULL,Address,&ds);
  212.                         }
  213.                         return TRUE;
  214.                 }
  215.                 Next = Next->Flink;
  216.         }
  217.         return FALSE;
  218. }

  220. void LdrpSnapThunk( PVOID ExportBase, PVOID ImportBase, PIMAGE_THUNK_DATA OriginalThunk, PIMAGE_THUNK_DATA Thunk, PIMAGE_EXPORT_DIRECTORY ExportEntry, ULONG ExportSize )
  221. {
  222.         PIMAGE_IMPORT_BY_NAME AddressOfData = (PIMAGE_IMPORT_BY_NAME)((ULONG_PTR)ImportBase + ((ULONG_PTR)OriginalThunk->u1.AddressOfData & 0xFFFFFFFF));
  223.         LPSTR ImportName = (LPSTR)AddressOfData->Name;
  224.         PULONG NameTable = (PULONG)((ULONG_PTR)ExportBase + (ULONG_PTR)ExportEntry->AddressOfNames);
  225.         PUSHORT OridinalTable = (PUSHORT)((ULONG_PTR)ExportBase + (ULONG_PTR)ExportEntry->AddressOfNameOrdinals);
  226.         USHORT Hint = AddressOfData->Hint;
  227.        
  228. }

  230. void LdrpSnapIAT(PIMAGE_NT_HEADERS NtHeaders, PIMAGE_IMPORT_DESCRIPTOR IatData, PVOID ViewBase,LPCWSTR DllPathW)
  231. {
  232.         NTSTATUS Status;
  233.         PVOID Iat = NULL;
  234.         SIZE_T ImportSize = 0;
  235.         ULONG IatSize = 0, ExportSize = 0;
  236.         ULONG OldProtect = 0;
  237.         RtlImageDirectoryEntryToData(NtHeaders, IMAGE_DIRECTORY_ENTRY_IAT, &IatSize, &Iat, ViewBase);
  238.         if(!Iat || !IatSize)
  239.         {
  240.                 PIMAGE_SECTION_HEADER SectionHeader = (PIMAGE_SECTION_HEADER)((ULONG_PTR)(NtHeaders) + FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + NtHeaders->FileHeader.SizeOfOptionalHeader );
  241.                 ULONG Rva = NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
  242.                 if(Rva)
  243.                 {
  244.                         for(ULONG i = 0;i < NtHeaders->FileHeader.NumberOfSections;i++)
  245.                         {
  246.                                 if((Rva >= SectionHeader->VirtualAddress) && Rva < (SectionHeader->VirtualAddress + SectionHeader->SizeOfRawData))
  247.                                 {
  248.                                         Iat = (PVOID)((ULONG_PTR)(ViewBase) + SectionHeader->VirtualAddress);
  249.                                         IatSize = SectionHeader->Misc.VirtualSize;
  250.                                         if(!IatSize)
  251.                                                 IatSize = SectionHeader->SizeOfRawData;
  252.                                         break;
  253.                                 }
  254.                                 SectionHeader++;
  255.                         }
  256.                 }
  257.                 else
  258.                         return;
  259.         }
  260.         ImportSize = IatSize;

  262.         Status = NtProtectVirtualMemory(((HANDLE)(LONG_PTR) -1), &Iat, &ImportSize, PAGE_READWRITE, &OldProtect);
  263.         if(!NT_SUCCESS(Status))
  264.                 return;
  265.         if(IatData->FirstThunk)
  266.         {
  267.                 PIMAGE_THUNK_DATA OriginalThunk = NULL;
  268.                 PIMAGE_THUNK_DATA FirstThunk = (PIMAGE_THUNK_DATA)((ULONG_PTR)ViewBase + IatData->FirstThunk);
  269.                 if((IatData->Characteristics < NtHeaders->OptionalHeader.SizeOfHeaders) || (IatData->Characteristics >= NtHeaders->OptionalHeader.SizeOfImage))
  270.                 {
  271.                         OriginalThunk = FirstThunk;
  272.                 }
  273.                 else
  274.                 {
  275.                         OriginalThunk = (PIMAGE_THUNK_DATA)((ULONG_PTR)ViewBase + IatData->OriginalFirstThunk);
  276.                 }
  277.                 LPSTR ImportName = (LPSTR)((ULONG_PTR)ViewBase + IatData->Name);
  278.                 while(OriginalThunk->u1.AddressOfData)
  279.                 {
  280.                         __try
  281.                         {
  282.                                 PIMAGE_IMPORT_BY_NAME AddressOfData = (PIMAGE_IMPORT_BY_NAME)((ULONG_PTR)ViewBase + (ULONG_PTR)OriginalThunk->u1.AddressOfData & 0xFFFFFFFF);
  283.                                 ImportName = (LPSTR)AddressOfData->Name;
  284.                                 ANSI_STRING FuncNameA;
  285.                                 WCHAR FuncName[0x1000];
  286.                                 UNICODE_STRING FuncNameW;
  287.                                 memset(FuncName,0,sizeof(FuncName));
  288.                                 RtlInitAnsiString(&FuncNameA,ImportName);
  289.                                 FuncNameW.Buffer = FuncName;
  290.                                 FuncNameW.MaximumLength = sizeof(FuncName);
  291.                                 RtlAnsiStringToUnicodeString(&FuncNameW,&FuncNameA,FALSE);
  292.                                 FirstThunk->u1.Function = (DWORD)GetProcAddressTW(DllPathW,FuncNameW.Buffer);
  293.                                 OriginalThunk++;
  294.                                 FirstThunk++;
  295.                         }
  296.                         __except(1)
  297.                         {

  299.                         }
  300.                 }
  301.         }
  302.         NtProtectVirtualMemory(((HANDLE)(LONG_PTR) -1),&Iat,&ImportSize,OldProtect,&OldProtect);
  303.         NtFlushInstructionCache(((HANDLE)(LONG_PTR) -1),Iat,IatSize);
  304. }

  306. void RtlImageDirectoryEntryToData(PIMAGE_NT_HEADERS NtHeaders, USHORT Directory, ULONG* RelocDataSize, PVOID* RelocData, PVOID ViewBase)
  307. {
  308.         if(NtHeaders->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)
  309.         {
  310.                 PIMAGE_NT_HEADERS32 tpnh = (PIMAGE_NT_HEADERS32)NtHeaders;
  311.                 if(Directory < tpnh->OptionalHeader.NumberOfRvaAndSizes)
  312.                 {
  313.                         DWORD VA = tpnh->OptionalHeader.DataDirectory[Directory].VirtualAddress;
  314.                         if(VA)
  315.                         {
  316.                                 *RelocDataSize = tpnh->OptionalHeader.DataDirectory[Directory].Size;
  317.                                 *RelocData = (PVOID)((ULONG_PTR)ViewBase + VA);
  318.                         }
  319.                 }
  320.         }
  321.         else
  322.         {
  323.                 PIMAGE_NT_HEADERS64 tpnh = (PIMAGE_NT_HEADERS64)NtHeaders;
  324.                 if(Directory < tpnh->OptionalHeader.NumberOfRvaAndSizes)
  325.                 {
  326.                         DWORD VA = tpnh->OptionalHeader.DataDirectory[Directory].VirtualAddress;
  327.                         if(VA)
  328.                         {
  329.                                 *RelocDataSize = tpnh->OptionalHeader.DataDirectory[Directory].Size;
  330.                                 *RelocData = (PVOID)((BYTE*)ViewBase + VA);
  331.                         }
  332.                 }
  333.         }
  334. }

  336. BOOL WINAPI LoadLibraryTW(LPCWSTR DllPath)
  337. {
  338.         if(!DllPath || DllPath[0] == 0)
  339.                 return FALSE;
  340.         BOOL result = FALSE;

  342.         EnterCriticalSection(&DllLock);
  343.         //查找Map，遍历导出表，更新Map
  344.         std::map<std::wstring,DllStruct>::iterator itor = DllMap.find(DllPath);
  345.         if(itor != DllMap.end())
  346.         {
  347.                 result = FALSE;
  348.                 goto ENDLOAD;
  349.         }

  351.         UNICODE_STRING NtPathDllName;
  352.         OBJECT_ATTRIBUTES ObjectAttributes;
  353.         HANDLE FileHandle = NULL,SectionHandle = NULL;
  354.         IO_STATUS_BLOCK IoStatusBlock;
  355.         NTSTATUS Status;
  356.         if(!RtlDosPathNameToNtPathName_U(DllPath,&NtPathDllName,NULL,NULL))
  357.         {
  358.                 result = FALSE;
  359.                 goto ENDLOAD;
  360.         }
  361.         InitializeObjectAttributes(&ObjectAttributes,&NtPathDllName,OBJ_CASE_INSENSITIVE,NULL,NULL);
  362.         Status = NtOpenFile(&FileHandle,SYNCHRONIZE | FILE_EXECUTE | FILE_READ_DATA,&ObjectAttributes,&IoStatusBlock,
  363.                 FILE_SHARE_READ | FILE_SHARE_DELETE,FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
  364.         if (!NT_SUCCESS(Status))
  365.         {//尝试以只读方式打开
  366.                 Status = NtOpenFile(&FileHandle,SYNCHRONIZE | FILE_EXECUTE,&ObjectAttributes,&IoStatusBlock,
  367.                         FILE_SHARE_READ | FILE_SHARE_DELETE,FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
  368.         }
  369.         if(!NT_SUCCESS(Status))
  370.         {
  371.                 result = FALSE;
  372.                 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathDllName.Buffer);
  373.                 goto ENDLOAD;
  374.         }
  375.         Status = NtCreateSection(&SectionHandle,SECTION_MAP_READ | SECTION_MAP_EXECUTE |SECTION_MAP_WRITE | SECTION_QUERY,
  376.                 NULL,NULL,PAGE_EXECUTE,SEC_IMAGE,FileHandle);
  377.         NtClose(FileHandle);
  378.         if(!NT_SUCCESS(Status))
  379.         {
  380.                 result = FALSE;
  381.                 RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathDllName.Buffer);
  382.                 goto ENDLOAD;
  383.         }
  384.         RtlFreeHeap(RtlGetProcessHeap(), 0, NtPathDllName.Buffer);

  386.         PVOID ViewBase = NULL;
  387.         SIZE_T ViewSize = 0;
  388.         PIMAGE_NT_HEADERS NtHeaders = NULL;
  389.         PIMAGE_DOS_HEADER DosHeader = NULL;
  390.         PVOID EntryPoint = NULL;
  391.         Status = NtMapViewOfSection(SectionHandle,((HANDLE)(LONG_PTR) -1)/*NtCurrentProcess()*/,&ViewBase,0,0,NULL,&ViewSize,1/*ViewShare*/,0,PAGE_READWRITE);

  393.         if(ViewBase)
  394.         {
  395.                 DosHeader = (PIMAGE_DOS_HEADER)ViewBase;
  396.                 if(DosHeader->e_magic == IMAGE_DOS_SIGNATURE && DosHeader->e_lfanew  && DosHeader->e_lfanew < ViewSize)
  397.                 {
  398.                         NtHeaders = (PIMAGE_NT_HEADERS)((BYTE*)DosHeader + DosHeader->e_lfanew);
  399.                         if(NtHeaders->Signature != IMAGE_NT_SIGNATURE)
  400.                                 NtHeaders = NULL;
  401.                 }
  402.                 if(!NtHeaders || !(NtHeaders->FileHeader.Characteristics & IMAGE_FILE_DLL))
  403.                 {
  404.                         result = FALSE;
  405.                         goto ENDLOAD;
  406.                 }
  407.                 if(NtHeaders->OptionalHeader.AddressOfEntryPoint)
  408.                         EntryPoint = (PVOID)(NtHeaders->OptionalHeader.AddressOfEntryPoint + (BYTE*)ViewBase);
  409.         }

  411.         if(Status == STATUS_IMAGE_NOT_AT_BASE)
  412.         {//重定位
  413.                 if(!(NtHeaders->FileHeader.Characteristics & IMAGE_FILE_RELOCS_STRIPPED))
  414.                 {
  415.                         ULONG RelocDataSize = 0;
  416.                         PVOID RelocData = NULL;
  417.                         RtlImageDirectoryEntryToData(NtHeaders, IMAGE_DIRECTORY_ENTRY_BASERELOC, &RelocDataSize, &RelocData, ViewBase);
  418.                         if(RelocData && RelocDataSize)
  419.                         {
  420.                                 Status = LdrpSetProtection(ViewBase,NtHeaders,FALSE);
  421.                                 if(NT_SUCCESS(Status))
  422.                                 {
  423.                                         Status = LdrRelocateImageWithBias(ViewBase, NtHeaders, 0LL, NULL, STATUS_SUCCESS,STATUS_CONFLICTING_ADDRESSES, STATUS_INVALID_IMAGE_FORMAT);
  424.                                         LdrpSetProtection(ViewBase,NtHeaders,TRUE);
  425.                                         if(NT_SUCCESS(Status))
  426.                                         {
  427.                                                 goto ENDLOAD1;
  428.                                         }
  429.                                 }
  430.                         }
  431.                 }
  432.                 if(!NT_SUCCESS(Status) || ViewBase)
  433.                 {
  434.                         NtUnmapViewOfSection(((HANDLE)(LONG_PTR) -1)/*NtCurrentProcess()*/,ViewBase);
  435.                         result = FALSE;
  436.                 }
  437.         }
  438.         else if(!NT_SUCCESS(Status))
  439.         {
  440.                 result = FALSE;
  441.                 goto ENDLOAD;
  442.         }
  443. ENDLOAD1:
  444.         NtClose(SectionHandle);
  445.         if(NT_SUCCESS(Status))
  446.                 result = TRUE;
  447.         DllStruct& ds = DllMap[DllPath];
  448.         ds.EntryPoint = EntryPoint;
  449.         ds.ViewBase = ViewBase;
  450.         ds.ViewSize = ViewSize;
  451.         {
  452.                 //处理导入表
  453.                 ULONG IatDataSize = 0;
  454.                 IMAGE_IMPORT_DESCRIPTOR* IatData = NULL;
  455.                 RtlImageDirectoryEntryToData(NtHeaders, IMAGE_DIRECTORY_ENTRY_IMPORT, &IatDataSize, (PVOID *)&IatData, ViewBase);
  456.                 PVOID BaseAddress = ViewBase;
  457.                 if(IatData && IatDataSize)
  458.                 {
  459.                         while(IatData->Name && IatData->FirstThunk)
  460.                         {
  461.                                 LPSTR ImportName = (LPSTR)((ULONG_PTR)BaseAddress + IatData->Name);
  462.                                 PIMAGE_THUNK_DATA FirstThunk = (PIMAGE_THUNK_DATA)((ULONG_PTR)BaseAddress + IatData->FirstThunk);
  463.                                 if(FirstThunk->u1.Function)
  464.                                 {
  465.                                         WCHAR FuncName[0x1000];
  466.                                         if(LdrpLoadImportModule(ImportName,BaseAddress,FuncName))//否则应该报错
  467.                                                 LdrpSnapIAT(NtHeaders, IatData, ViewBase, FuncName);
  468.                                         else
  469.                                         {
  470.                                                 MessageBoxA(NULL,ImportName,ImportName,MB_OK);
  471. //                                                 LeaveCriticalSection(&DllLock);
  472. //                                                 return FALSE;
  473.                                         }
  474.                                 }
  475.                                 IatData++;
  476.                         }
  477.                 }

  479. //                if(EntryPoint)
  480. //                        ((PDLL_INIT_ROUTINE)EntryPoint)(ViewBase,DLL_PROCESS_ATTACH,NULL);
  481.                 GetExportFuncs(NtHeaders, ViewBase, &ds);
  482.         }

  484. ENDLOAD:
  485.         LeaveCriticalSection(&DllLock);
  486.         return result;
  487. }

  489. NTSTATUS NTAPI LdrpSetProtection(PVOID ViewBase,PIMAGE_NT_HEADERS NtHeaders,BOOLEAN Restore)
  490. {
  491.         NTSTATUS Status;
  492.         PVOID SectionBase;
  493.         SIZE_T SectionSize;
  494.         ULONG NewProtection, OldProtection, i;
  495.         PIMAGE_SECTION_HEADER Section = IMAGE_FIRST_SECTION(NtHeaders);
  496.         for (i = 0; i < NtHeaders->FileHeader.NumberOfSections; i++)
  497.         {
  498.                 if ((Section->SizeOfRawData) && !(Section->Characteristics & IMAGE_SCN_MEM_WRITE))
  499.                 {
  500.                         if (Restore)
  501.                         {
  502.                                 if (Section->Characteristics & IMAGE_SCN_MEM_EXECUTE)
  503.                                 {
  504.                                         NewProtection = PAGE_EXECUTE;
  505.                                 }
  506.                                 else
  507.                                 {
  508.                                         NewProtection = PAGE_READONLY;
  509.                                 }

  511.                                 if (Section->Characteristics & IMAGE_SCN_MEM_NOT_CACHED)
  512.                                 {
  513.                                         NewProtection |= PAGE_NOCACHE;
  514.                                 }
  515.                         }
  516.                         else
  517.                         {
  518.                                 NewProtection = PAGE_READWRITE;
  519.                         }

  521.                         SectionBase = (PVOID)((ULONG_PTR)ViewBase + Section->VirtualAddress);
  522.                         SectionSize = Section->SizeOfRawData;
  523.                         if (SectionSize)
  524.                         {
  525.                                 Status = NtProtectVirtualMemory(((HANDLE)(LONG_PTR) -1)/*NtCurrentProcess*/,&SectionBase,&SectionSize,NewProtection,&OldProtection);
  526.                                 if (!NT_SUCCESS(Status)) return Status;
  527.                         }
  528.                 }
  529.                 Section++;
  530.         }
  531.         if (Restore) NtFlushInstructionCache(((HANDLE)(LONG_PTR) -1)/*NtCurrentProcess*/, NULL, 0);
  532.         return STATUS_SUCCESS;
  533. }

  535. ULONG NTAPI LdrRelocateImageWithBias(PVOID BaseAddress,PIMAGE_NT_HEADERS NtHeaders,LONGLONG AdditionalBias,PCCH  LoaderName,ULONG Success,ULONG Conflict,ULONG Invalid)
  536. {

  538.         PIMAGE_DATA_DIRECTORY RelocationDDir;
  539.         PIMAGE_BASE_RELOCATION RelocationDir, RelocationEnd;
  540.         ULONG Count;
  541.         ULONG_PTR Address;
  542.         PUSHORT TypeOffset;
  543.         LONGLONG Delta;

  545.         if (SWAPW(NtHeaders->FileHeader.Characteristics) & IMAGE_FILE_RELOCS_STRIPPED)
  546.         {
  547.                 return Conflict;
  548.         }
  549.         RelocationDDir = &NtHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC];
  550.         if (SWAPD(RelocationDDir->VirtualAddress) == 0 || SWAPD(RelocationDDir->Size) == 0)
  551.         {
  552.                 return Success;
  553.         }
  554.         Delta = (ULONG_PTR)BaseAddress - SWAPD(NtHeaders->OptionalHeader.ImageBase) + AdditionalBias;
  555.         RelocationDir = (PIMAGE_BASE_RELOCATION)((ULONG_PTR)BaseAddress + SWAPD(RelocationDDir->VirtualAddress));
  556.         RelocationEnd = (PIMAGE_BASE_RELOCATION)((ULONG_PTR)RelocationDir + SWAPD(RelocationDDir->Size));
  557.         while (RelocationDir < RelocationEnd && SWAPW(RelocationDir->SizeOfBlock) > 0)
  558.         {
  559.                 SHORT Offset;
  560.                 USHORT Type;
  561.                 ULONG i;
  562.                 PUSHORT ShortPtr;
  563.                 PULONG LongPtr;
  564.                 PULONGLONG LongLongPtr;
  565.                 Count = (SWAPW(RelocationDir->SizeOfBlock) - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(USHORT);
  566.                 Address = (ULONG_PTR)RVA(BaseAddress,SWAPD(RelocationDir->VirtualAddress));
  567.                 TypeOffset = (PUSHORT)(RelocationDir + 1);
  568.                 for (ULONG i = 0; i < Count; i++)
  569.                 {
  570.                         Offset = SWAPW(*TypeOffset) & 0xFFF;
  571.                         Type = SWAPW(*TypeOffset) >> 12;
  572.                         ShortPtr = (PUSHORT)RVA(Address,Offset);
  573.                         if((ULONG_PTR)ShortPtr >= (ULONG_PTR)RelocationDir && (ULONG_PTR)ShortPtr < (ULONG_PTR)RelocationEnd)
  574.                                 continue;
  575.                         switch (Type)
  576.                         {
  577.                         case IMAGE_REL_BASED_ABSOLUTE:
  578.                                 break;
  579.                         case IMAGE_REL_BASED_HIGH:
  580.                                 *ShortPtr = HIWORD(MAKELONG(0, *ShortPtr) + (Delta & 0xFFFFFFFF));
  581.                                 break;
  582.                         case IMAGE_REL_BASED_LOW:
  583.                                 *ShortPtr = SWAPW(*ShortPtr) + LOWORD(Delta & 0xFFFF);
  584.                                 break;
  585.                         case IMAGE_REL_BASED_HIGHLOW:
  586.                                 LongPtr = (PULONG)RVA(Address,Offset);
  587.                                 *LongPtr = SWAPD(*LongPtr) + (Delta & 0xFFFFFFFF);
  588.                                 break;
  589.                         case IMAGE_REL_BASED_DIR64:
  590.                                 LongLongPtr = (PUINT64)RVA(Address,Offset);
  591.                                 *LongLongPtr = SWAPQ(*LongLongPtr) + Delta;
  592.                                 break;
  593.                         case IMAGE_REL_BASED_HIGHADJ:
  594.                         case IMAGE_REL_BASED_MIPS_JMPADDR:
  595.                         default:
  596.                                 RelocationDir = (PIMAGE_BASE_RELOCATION)NULL;
  597.                         }
  598.                         TypeOffset++;
  599.                 }
  600.                 RelocationDir = (PIMAGE_BASE_RELOCATION)TypeOffset;
  601.                 if (RelocationDir == NULL)
  602.                 {
  603.                         return Invalid;
  604.                 }
  605.         }
  606.         return Success;
  607. }

  609. FARPROC WINAPI GetProcAddressTA(LPCSTR DllPath,LPCSTR ProcName)
  610. {
  611.         ANSI_STRING DllPathA,ProcNameA;
  612.         UNICODE_STRING DllPathW,ProcNameW;
  613.         NTSTATUS status;
  614.         if(!DllPath || !ProcName || DllPath[0] == 0 || ProcName[0] == 0)
  615.                 return NULL;
  616.         WCHAR tmp1[0x1000],tmp2[0x1000];
  617.         memset(tmp1,0,sizeof(tmp1));
  618.         memset(tmp2,0,sizeof(tmp2));
  619.         RtlInitAnsiString(&DllPathA,DllPath);
  620.         RtlInitAnsiString(&ProcNameA,ProcName);
  621.         DllPathW.Buffer = tmp1;
  622.         DllPathW.MaximumLength = 0x1000;
  623.         ProcNameW.Buffer = tmp2;
  624.         ProcNameW.MaximumLength = 0x1000;
  625.         status = RtlAnsiStringToUnicodeString(&DllPathW,&DllPathA,FALSE);
  626.         if(!NT_SUCCESS(status))
  627.                 return FALSE;
  628.         status = RtlAnsiStringToUnicodeString(&ProcNameW,&ProcNameA,FALSE);
  629.         if(!NT_SUCCESS(status))
  630.                 return FALSE;
  631.         return GetProcAddressTW(DllPathW.Buffer,ProcNameW.Buffer);
  632. }

  634. FARPROC WINAPI GetProcAddressTW(LPCWSTR DllPath,LPCWSTR ProcName)
  635. {
  636.         if(!DllPath || !ProcName || DllPath[0] == 0 || ProcName[0] == 0)
  637.                 return NULL;
  638.         FARPROC result = NULL;
  639.         EnterCriticalSection(&DllLock);
  640.         std::map<std::wstring,DllStruct>::iterator itor1 = DllMap.find(DllPath);
  641.         if(itor1 != DllMap.end())
  642.         {
  643.                 std::map<std::wstring,FARPROC>::iterator itor2 = (*itor1).second.FuncMap.find(ProcName);
  644.                 if(itor2 != (*itor1).second.FuncMap.end())
  645.                 {
  646.                         result = (*itor2).second;
  647.                 }
  648.         }
  649.         LeaveCriticalSection(&DllLock);
  650.         return result;
  651. }

  653. BOOL WINAPI FreeLibraryTA(LPCSTR DllPath)
  654. {
  655.         ANSI_STRING DllPathA;
  656.         UNICODE_STRING DllPathW;
  657.         NTSTATUS status;
  658.         if(!DllPath || DllPath[0] == 0)
  659.                 return FALSE;
  660.         WCHAR tmp[0x1000];
  661.         memset(tmp,0,sizeof(tmp));
  662.         RtlInitAnsiString(&DllPathA,DllPath);
  663.         DllPathW.Buffer = tmp;
  664.         DllPathW.MaximumLength = 0x1000;
  665.         status = RtlAnsiStringToUnicodeString(&DllPathW,&DllPathA,FALSE);
  666.         if(!NT_SUCCESS(status))
  667.                 return FALSE;
  668.         return FreeLibraryTW(DllPathW.Buffer);
  669. }

  671. BOOL WINAPI FreeLibraryTW(LPCWSTR DllPath)
  672. {
  673.         BOOL result = FALSE;
  674.         if(!DllPath || DllPath[0] == 0)
  675.                 return FALSE;

  677.         EnterCriticalSection(&DllLock);
  678.         std::map<std::wstring,DllStruct>::iterator itor = DllMap.find(DllPath);
  679.         if(itor == DllMap.end())
  680.         {
  681.                 result = FALSE;
  682.                 goto ENDFREE;
  683.         }

  685.         NTSTATUS Status;
  686.         PVOID BaseAddress = (*itor).second.ViewBase;
  687.         PVOID EntryPoint = (*itor).second.EntryPoint;

  689.         ((PDLL_INIT_ROUTINE)EntryPoint)(BaseAddress,DLL_PROCESS_ATTACH,NULL);
  690.         Status = NtUnmapViewOfSection(((HANDLE)(LONG_PTR) -1)/*NtCurrentProcess*/, BaseAddress);
  691.         if(NT_SUCCESS(Status))
  692.                 result = TRUE;
  693.         DllMap.erase(itor);
  694. ENDFREE:
  695.         LeaveCriticalSection(&DllLock);
  696.         return result;
  697. }

  699. void main()
  700. {
  701.         InitializeCriticalSection(&DllLock);
  702.         LoadLibraryTA("d:\\1.dll");
  703.         FARPROC func=GetProcAddressTA("d:\\1.dll","func");
  704.         ((void (__cdecl *)())func)();
  705. }
复制代码
回复 赞！ 靠！

使用道具 举报

Golden Blonde
发表于 2015-6-23 08:52:44 | 显示全部楼层
你可以去看看memorymodule
回复 赞！ 靠！

使用道具 举报

返回列表 发新帖

本版积分规则

QQ|Archiver|小黑屋|技术宅的结界 ( 滇ICP备16008837号 )|网站地图

GMT+8, 2024-11-25 12:13 , Processed in 0.031486 second(s), 21 queries , Gzip On.

Powered by Discuz! X3.5

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表