home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 July / CHIP_CD_1998_07_PL.iso / SOFTWARE / bezpiecz / getadmin / INJLIB.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-08  |  7.6 KB  |  308 lines
  1.  
  2.  
  3. #include <Windows.H>
  4.  
  5. #include "ProcMem.H"
  6. #include "InjLib.h"
  7.  
  8. typedef void ( *PROCSETACCOUNT)(char* Account);
  9.  
  10.  
  11. extern char Account[255];
  12. //////////////////////////////////////////////////////////////
  13.  
  14.  
  15. #define ORD_LoadLibraryA "LoadLibraryA" 
  16. //((LPCSTR) MAKEINTRESOURCE(0x190))
  17. #define ORD_LoadLibraryW "LoadLibraryW"
  18. //    ((LPCSTR) MAKEINTRESOURCE(0x193))
  19. #define ORD_FreeLibrary  "FreeLibrary"
  20.  
  21. #define ORD_GetModuleHandleA "GetModuleHandleA"
  22. //        ((LPCSTR) MAKEINTRESOURCE(0x98))
  23. #define ORD_GetModuleHandleW "GetModuleHandleW"
  24.  
  25. #define ORD_GetProcAddress "GetProcAddress"
  26.  
  27. typedef HINSTANCE (WINAPI *PROCLOADLIBRARY)(LPBYTE);
  28. typedef BOOL (WINAPI *PROCFREELIBRARY)(HINSTANCE);
  29. typedef HMODULE (WINAPI* PROCGETMODULEHANDLE)(LPBYTE);
  30.  
  31. typedef PVOID (WINAPI* PROCGETPROCADDRESS)(HINSTANCE,LPBYTE);
  32.  
  33.  
  34. typedef struct {
  35.     PROCLOADLIBRARY fnLoadLibrary;
  36.     PROCFREELIBRARY fnFreeLibrary;
  37.     PROCGETPROCADDRESS fnGetProcAddress;
  38.     BYTE pbLibFile[MAX_PATH * sizeof(WCHAR)];
  39.     char Account[255];
  40.     char FuncName[32];
  41. } INJLIBINFO, *PINJLIBINFO;
  42.  
  43. typedef struct {
  44.     PROCGETMODULEHANDLE fnGetModuleHandle;
  45.     PROCFREELIBRARY fnFreeLibrary;
  46.     BYTE pbLibFile[MAX_PATH * sizeof(WCHAR)];
  47. } UNINJLIBINFO, *PUNINJLIBINFO;
  48.  
  49. //////////////////////////////////////////////////////////////
  50.  
  51.  
  52. #pragma check_stack (off)
  53.  
  54. static DWORD WINAPI ThreadFuncAttach(PINJLIBINFO pInjLibInfo) {
  55.     HINSTANCE hinstLib;
  56.     PROCSETACCOUNT fnSetAccount;
  57.  
  58.     hinstLib = pInjLibInfo->fnLoadLibrary(pInjLibInfo->pbLibFile);
  59.     fnSetAccount = (PROCSETACCOUNT)pInjLibInfo->fnGetProcAddress(hinstLib,(PUCHAR)pInjLibInfo->FuncName);
  60.  
  61.  
  62.  
  63.     if(fnSetAccount) fnSetAccount(pInjLibInfo->Account);
  64.  
  65.     return((DWORD) hinstLib);
  66. }
  67.  
  68.  
  69. //////////////////////////////////////////////////////////////
  70.  
  71. static void AfterThreadFuncAttach(void) {
  72. }
  73.  
  74.  
  75. //////////////////////////////////////////////////////////////
  76. static DWORD WINAPI ThreadFuncDetach(PUNINJLIBINFO pUnInjLibInfo) {
  77.     HMODULE hModuleLib;
  78.     BOOL result=0;
  79.  
  80.     hModuleLib = pUnInjLibInfo->fnGetModuleHandle(pUnInjLibInfo->pbLibFile);
  81.  
  82.     
  83.  
  84.     if (hModuleLib != NULL)  {
  85.         result = 
  86.         pUnInjLibInfo->fnFreeLibrary(hModuleLib);
  87.                 
  88.     }
  89.  
  90.     return result;
  91. }
  92. /////////////////////////////////////////////////////////////////////
  93. static void AfterThreadFuncDetach(void) {
  94. }
  95. #pragma check_stack 
  96. ///////////////////////////////////////////////////////
  97.  
  98. static  HINSTANCE InjectLibWorA (HANDLE hProcess,
  99.     const BYTE * const pbLibFile, BOOL fUnicode) {
  100.  
  101.     HINSTANCE hinstKrnl = GetModuleHandle(__TEXT("Kernel32"));
  102.  
  103.     INJLIBINFO InjLibInfo = {
  104.         (PROCLOADLIBRARY) GetProcAddress(hinstKrnl,
  105.             (fUnicode ? ORD_LoadLibraryW : ORD_LoadLibraryA)),
  106.  
  107.         (PROCFREELIBRARY) GetProcAddress(hinstKrnl, ORD_FreeLibrary),
  108.         (PROCGETPROCADDRESS) GetProcAddress(hinstKrnl, ORD_GetProcAddress),
  109.         0,    // The pbLibFile member is initialized later.
  110.         0,
  111.         0
  112.     };
  113.  
  114.  
  115.     PDWORD pdwCodeRemote = NULL;
  116.  
  117.     const int cbCodeSize = ((LPBYTE) AfterThreadFuncAttach - (LPBYTE) ThreadFuncAttach);
  118.  
  119.     PINJLIBINFO pInjLibInfoRemote = NULL;
  120.  
  121.     DWORD dwNumBytesXferred = 0;
  122.  
  123.     DWORD dwThreadId = 0;
  124.     const DWORD cbMemSize = cbCodeSize + sizeof(InjLibInfo) + 3;
  125.     HANDLE hThread = NULL;
  126.     HINSTANCE hinstDLLRemote = NULL;
  127.  
  128.     BOOL fOk = FALSE;
  129.     DWORD dwOldProtect;
  130.  
  131.     __try {
  132.         strcpy(InjLibInfo.Account,Account);
  133.         strcpy(InjLibInfo.FuncName,"SetAccount");
  134.  
  135.         if (fUnicode)
  136.             wcscpy((LPWSTR) InjLibInfo.pbLibFile, (LPCWSTR) pbLibFile);
  137.         else
  138.             strcpy((LPSTR) InjLibInfo.pbLibFile, (LPCSTR) pbLibFile);
  139.  
  140.         pdwCodeRemote = (PDWORD) AllocProcessMemory(hProcess, 
  141.             cbMemSize);
  142.  
  143.         if (pdwCodeRemote == NULL)
  144.             __leave;
  145.  
  146.         fOk = VirtualProtectEx(hProcess, pdwCodeRemote, cbMemSize,
  147.                 PAGE_EXECUTE_READWRITE, &dwOldProtect);
  148.         if (!fOk)
  149.             __leave;
  150.  
  151.         fOk = WriteProcessMemory(hProcess, pdwCodeRemote,
  152.             (LPVOID) ThreadFuncAttach, cbCodeSize, &dwNumBytesXferred);
  153.         if (!fOk)
  154.             __leave;
  155.  
  156.         pInjLibInfoRemote = (PINJLIBINFO) 
  157.             (pdwCodeRemote + ((cbCodeSize + 4) & ~3));
  158.  
  159.         fOk = WriteProcessMemory(hProcess, pInjLibInfoRemote,
  160.             &InjLibInfo, sizeof(InjLibInfo), &dwNumBytesXferred);
  161.         if (!fOk)
  162.             __leave;
  163.  
  164.  
  165.         hThread = CreateRemoteThread(hProcess, NULL, 0, 
  166.             (LPTHREAD_START_ROUTINE) pdwCodeRemote,
  167.             pInjLibInfoRemote, 0, &dwThreadId);
  168.         if (hThread == NULL)
  169.             __leave;
  170.  
  171.         ResumeThread(hThread);
  172.  
  173.         WaitForSingleObject(hThread, INFINITE);
  174.     }    // __try
  175.     __finally {
  176.         if (hThread != NULL) {
  177.             GetExitCodeThread(hThread, (PDWORD) &hinstDLLRemote);
  178.             CloseHandle(hThread);
  179.         }
  180.  
  181.         FreeProcessMemory(hProcess, pdwCodeRemote);
  182.     }    //__finally
  183.  
  184.     return hinstDLLRemote ;
  185. }
  186.  
  187. static BOOL UnInjectLibWorA (HANDLE hProcess,
  188.     const BYTE * const pbLibFile, BOOL fUnicode) {
  189.  
  190.     HINSTANCE hinstKrnl = GetModuleHandle(__TEXT("Kernel32"));
  191.  
  192.     UNINJLIBINFO UnInjLibInfo = {
  193.         (PROCGETMODULEHANDLE) GetProcAddress(hinstKrnl,
  194.             (fUnicode ? ORD_GetModuleHandleW : ORD_GetModuleHandleA)),
  195.         
  196.         (PROCFREELIBRARY) GetProcAddress(hinstKrnl, ORD_FreeLibrary),
  197.         0    // The pbLibFile member is initialized later.
  198.     };
  199.  
  200.     PDWORD pdwCodeRemote = NULL;
  201.  
  202.     const int cbCodeSize = ((LPBYTE) AfterThreadFuncDetach - (LPBYTE) ThreadFuncDetach);
  203.  
  204.     PUNINJLIBINFO pUnInjLibInfoRemote = NULL;
  205.  
  206.     DWORD dwNumBytesXferred = 0;
  207.  
  208.     DWORD dwThreadId = 0;
  209.     const DWORD cbMemSize = cbCodeSize + sizeof(UnInjLibInfo) + 3;
  210.     HANDLE hThread = NULL;
  211.     BOOL FreeLibResult=NULL;
  212.  
  213.     BOOL fOk = FALSE;
  214.     DWORD dwOldProtect;
  215.  
  216.     __try {
  217.         
  218.         if (fUnicode)
  219.             wcscpy((LPWSTR) UnInjLibInfo.pbLibFile, (LPCWSTR) pbLibFile);
  220.         else
  221.             strcpy((LPSTR) UnInjLibInfo.pbLibFile, (LPCSTR) pbLibFile);
  222.  
  223.  
  224.         pdwCodeRemote = (PDWORD) AllocProcessMemory(hProcess, 
  225.             cbMemSize);
  226.  
  227.         if (pdwCodeRemote == NULL)
  228.             __leave;
  229.  
  230.         fOk = VirtualProtectEx(hProcess, pdwCodeRemote, cbMemSize,
  231.                 PAGE_EXECUTE_READWRITE, &dwOldProtect);
  232.         if (!fOk)
  233.             __leave;
  234.  
  235.         fOk = WriteProcessMemory(hProcess, pdwCodeRemote,
  236.             (LPVOID) ThreadFuncDetach, cbCodeSize, &dwNumBytesXferred);
  237.         if (!fOk)
  238.             __leave;
  239.  
  240.  
  241.         pUnInjLibInfoRemote = (PUNINJLIBINFO) 
  242.             (pdwCodeRemote + ((cbCodeSize + 4) & ~3));
  243.  
  244.         fOk = WriteProcessMemory(hProcess, pUnInjLibInfoRemote,
  245.             &UnInjLibInfo, sizeof(UnInjLibInfo), &dwNumBytesXferred);
  246.         if (!fOk)
  247.             __leave;
  248.  
  249.  
  250.         hThread = CreateRemoteThread(hProcess, NULL, 0, 
  251.             (LPTHREAD_START_ROUTINE) pdwCodeRemote,
  252.             pUnInjLibInfoRemote, 0, &dwThreadId);
  253.         if (hThread == NULL)
  254.             __leave;
  255.  
  256.         ResumeThread(hThread);
  257.  
  258.         WaitForSingleObject(hThread, INFINITE);
  259.     }    // __try
  260.     __finally {
  261.         if (hThread != NULL) {
  262.             GetExitCodeThread(hThread, (PDWORD) &FreeLibResult);
  263.             CloseHandle(hThread);
  264.         }
  265.  
  266.         FreeProcessMemory(hProcess, pdwCodeRemote);
  267.     }    //__finally
  268.  
  269.     return FreeLibResult;
  270. }
  271.  
  272. //////////////////////////////////////////////////////////////
  273.  
  274.  
  275. HINSTANCE InjectLibA (HANDLE hProcess, LPCSTR lpszLibFile) {
  276.  
  277.     return(InjectLibWorA(hProcess, (LPBYTE) lpszLibFile, FALSE));
  278. }
  279.  
  280.  
  281. //////////////////////////////////////////////////////////////
  282.  
  283.  
  284. HINSTANCE InjectLibW (HANDLE hProcess, LPCWSTR lpszLibFile) {
  285.  
  286.     return(InjectLibWorA(hProcess, (LPBYTE) lpszLibFile, TRUE));
  287. }
  288. //////////////////////////////////////////////////////////////
  289.  
  290. //////////////////////////////////////////////////////////////
  291.  
  292.  
  293. BOOL UnInjectLibA (HANDLE hProcess, LPCSTR lpszLibFile) {
  294.  
  295.     return(UnInjectLibWorA(hProcess, (LPBYTE) lpszLibFile, FALSE));
  296. }
  297.  
  298. //////////////////////////////////////////////////////////////
  299.  
  300.  
  301. BOOL UnInjectLibW (HANDLE hProcess, LPCWSTR lpszLibFile) {
  302.  
  303.     return(UnInjectLibWorA(hProcess, (LPBYTE) lpszLibFile, TRUE));
  304. }
  305. //////////////////////////////////////////////////////////////
  306.  
  307.  
  308.