1837 lines
58 KiB
C++
1837 lines
58 KiB
C++
//--------------------------------------------------------------------------
|
|
// Sicily.cpp
|
|
//--------------------------------------------------------------------------
|
|
#include "pch.hxx"
|
|
#include "imnxport.h"
|
|
#include "sicily.h"
|
|
#include "dllmain.h"
|
|
#include "resource.h"
|
|
#include "imnxport.h"
|
|
#include "strconst.h"
|
|
#include <shlwapi.h>
|
|
#include "demand.h"
|
|
|
|
//--------------------------------------------------------------------------
|
|
// NTLMSSP_SIGNATURE
|
|
//--------------------------------------------------------------------------
|
|
#define NTLMSSP_SIGNATURE "NTLMSSP"
|
|
|
|
//--------------------------------------------------------------------------
|
|
// NegotiateFlags
|
|
//--------------------------------------------------------------------------
|
|
#define NTLMSSP_NEGOTIATE_UNICODE 0x0001 // Text strings are in unicode
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Security Buffer Counts
|
|
//--------------------------------------------------------------------------
|
|
#define SEC_BUFFER_NUM_NORMAL_BUFFERS 1
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Security Buffer Indexes
|
|
//--------------------------------------------------------------------------
|
|
#define SEC_BUFFER_CHALLENGE_INDEX 0
|
|
#define SEC_BUFFER_USERNAME_INDEX 1
|
|
#define SEC_BUFFER_PASSWORD_INDEX 2
|
|
#define SEC_BUFFER_NUM_EXTENDED_BUFFERS 3
|
|
|
|
//--------------------------------------------------------------------------
|
|
// NTLM_MESSAGE_TYPE
|
|
//--------------------------------------------------------------------------
|
|
typedef enum {
|
|
NtLmNegotiate = 1,
|
|
NtLmChallenge,
|
|
NtLmAuthenticate,
|
|
NtLmUnknown
|
|
} NTLM_MESSAGE_TYPE;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// STRING
|
|
//--------------------------------------------------------------------------
|
|
typedef struct _STRING {
|
|
USHORT Length;
|
|
USHORT MaximumLength;
|
|
PWCHAR Buffer;
|
|
} STRING, *PSTRING;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// AUTHENTICATE_MESSAGE
|
|
//--------------------------------------------------------------------------
|
|
typedef struct _AUTHENTICATE_MESSAGE {
|
|
UCHAR Signature[sizeof(NTLMSSP_SIGNATURE)];
|
|
NTLM_MESSAGE_TYPE MessageType;
|
|
STRING LmChallengeResponse;
|
|
STRING NtChallengeResponse;
|
|
STRING DomainName;
|
|
STRING UserName;
|
|
STRING Workstation;
|
|
STRING SessionKey;
|
|
ULONG NegotiateFlags;
|
|
} AUTHENTICATE_MESSAGE, *PAUTHENTICATE_MESSAGE;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Constants
|
|
//--------------------------------------------------------------------------
|
|
#define CCHMAX_NTLM_DOMAIN 255
|
|
#define LOGON_OK 10000
|
|
|
|
//--------------------------------------------------------------------------
|
|
// String Constants
|
|
//--------------------------------------------------------------------------
|
|
static const CHAR c_szSecurityDLL[] = "security.dll";
|
|
static const CHAR c_szSecur32DLL[] = "secur32.dll";
|
|
|
|
//--------------------------------------------------------------------------
|
|
// MSN/DPA CleareCredentialsCache Function Prototype
|
|
//--------------------------------------------------------------------------
|
|
typedef BOOL (WINAPI * PFNCLEANUPCREDENTIALCACHE)(void);
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CREDENTIAL
|
|
//--------------------------------------------------------------------------
|
|
typedef struct tagCREDENTIAL *LPCREDENTIAL;
|
|
typedef struct tagCREDENTIAL {
|
|
CHAR szServer[CCHMAX_SERVER_NAME];
|
|
CHAR szUserName[CCHMAX_USERNAME];
|
|
CHAR szPassword[CCHMAX_PASSWORD];
|
|
CHAR szDomain[CCHMAX_NTLM_DOMAIN];
|
|
DWORD cRetry;
|
|
LPCREDENTIAL pNext;
|
|
} CREDENTIAL;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIPROMPTINFO
|
|
//--------------------------------------------------------------------------
|
|
typedef struct tagSSPIPROMPTINFO {
|
|
HRESULT hrResult;
|
|
LPSSPICONTEXT pContext;
|
|
ULONG fContextAttrib;
|
|
PSecBufferDesc pInDescript;
|
|
PSecBufferDesc pOutDescript;
|
|
TimeStamp tsExpireTime;
|
|
PCtxtHandle phCtxCurrent;
|
|
DWORD dwFlags;
|
|
} SSPIPROMPTINFO, *LPSSPIPROMPTINFO;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPILOGON
|
|
//--------------------------------------------------------------------------
|
|
typedef struct tagSSPILOGON {
|
|
LPCREDENTIAL pCredential;
|
|
LPSSPICONTEXT pContext;
|
|
} SSPILOGON, *LPSSPILOGON;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPILOGONFLAGS
|
|
//--------------------------------------------------------------------------
|
|
typedef DWORD SSPILOGONFLAGS;
|
|
#define SSPI_LOGON_RETRY 0x00000001
|
|
#define SSPI_LOGON_FLUSH 0x00000002
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Globals
|
|
//--------------------------------------------------------------------------
|
|
static PSecurityFunctionTable g_pFunctions = NULL;
|
|
static HINSTANCE g_hInstSSPI = NULL;
|
|
static LPCREDENTIAL g_pCredentialHead=NULL;
|
|
static LPSSPIPACKAGE g_prgPackage=NULL;
|
|
static DWORD g_cPackages=0;
|
|
|
|
//--------------------------------------------------------------------------
|
|
// base642six
|
|
//--------------------------------------------------------------------------
|
|
static const int base642six[256] = {
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,62,64,64,64,63,
|
|
52,53,54,55,56,57,58,59,60,61,64,64,64,64,64,64,64,0,1,2,3,4,5,6,7,8,9,
|
|
10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,64,64,64,64,64,64,26,27,
|
|
28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64
|
|
};
|
|
|
|
//--------------------------------------------------------------------------
|
|
// six2base64
|
|
//--------------------------------------------------------------------------
|
|
static const char six2base64[64] = {
|
|
'A','B','C','D','E','F','G','H','I','J','K','L','M',
|
|
'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
|
|
'a','b','c','d','e','f','g','h','i','j','k','l','m',
|
|
'n','o','p','q','r','s','t','u','v','w','x','y','z',
|
|
'0','1','2','3','4','5','6','7','8','9','+','/'
|
|
};
|
|
|
|
//--------------------------------------------------------------------------
|
|
// uu2six
|
|
//--------------------------------------------------------------------------
|
|
const int uu2six[256] = {
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
|
|
16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,
|
|
40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,
|
|
0,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,64,
|
|
64,64,64,64,64,64,64,64,64,64,64,64,64
|
|
};
|
|
|
|
//--------------------------------------------------------------------------
|
|
// six2uu
|
|
//--------------------------------------------------------------------------
|
|
static const char six2uu[64] = {
|
|
'`','!','"','#','$','%','&','\'','(',')','*','+',',',
|
|
'-','.','/','0','1','2','3','4','5','6','7','8','9',
|
|
':',';','<','=','>','?','@','A','B','C','D','E','F',
|
|
'G','H','I','J','K','L','M','N','O','P','Q','R','S',
|
|
'T','U','V','W','X','Y','Z','[','\\',']','^','_'
|
|
};
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Prototypes
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIFlushMSNCredentialCache(void);
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPISetBuffer
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPISetBuffer(LPCSTR pszString, SSPIBUFFERTYPE tyBuffer,
|
|
DWORD cbBuffer, LPSSPIBUFFER pBuffer)
|
|
{
|
|
// Trace
|
|
TraceCall("SSPISetBuffer");
|
|
|
|
// No Length Passed In ?
|
|
if (SSPI_STRING == tyBuffer)
|
|
{
|
|
// Get the Length
|
|
pBuffer->cbBuffer = lstrlen(pszString) + 1;
|
|
|
|
// Too Long
|
|
if (pBuffer->cbBuffer > CBMAX_SSPI_BUFFER)
|
|
pBuffer->cbBuffer = CBMAX_SSPI_BUFFER;
|
|
|
|
// Copy the data
|
|
CopyMemory(pBuffer->szBuffer, pszString, pBuffer->cbBuffer);
|
|
|
|
// Stuff a Null
|
|
pBuffer->szBuffer[pBuffer->cbBuffer - 1] = '\0';
|
|
|
|
// Loop
|
|
while (pBuffer->cbBuffer >= 2)
|
|
{
|
|
// Not a CRLF
|
|
if ('\r' != pBuffer->szBuffer[pBuffer->cbBuffer - 2] && '\n' != pBuffer->szBuffer[pBuffer->cbBuffer - 2])
|
|
break;
|
|
|
|
// Decrement Length
|
|
pBuffer->cbBuffer--;
|
|
|
|
// Null Terminate
|
|
pBuffer->szBuffer[pBuffer->cbBuffer - 1] = '\0';
|
|
}
|
|
}
|
|
|
|
// Otherwise, set cbBuffer
|
|
else
|
|
{
|
|
// Set cbBuffer
|
|
pBuffer->cbBuffer = min(cbBuffer + 1, CBMAX_SSPI_BUFFER);
|
|
|
|
// Null Terminate
|
|
pBuffer->szBuffer[pBuffer->cbBuffer - 1] = '\0';
|
|
|
|
// Copy the data
|
|
CopyMemory(pBuffer->szBuffer, pszString, pBuffer->cbBuffer);
|
|
}
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// GetCredentialDlgProc
|
|
//--------------------------------------------------------------------------
|
|
INT_PTR CALLBACK GetCredentialDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
// Locals
|
|
LPSSPILOGON pLogon=(LPSSPILOGON)GetWndThisPtr(hwnd);
|
|
CHAR szRes[CCHMAX_RES];
|
|
CHAR szTitle[CCHMAX_RES + CCHMAX_SERVER_NAME];
|
|
|
|
// Trace
|
|
TraceCall("GetCredentialDlgProc");
|
|
|
|
// Handle Message
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Get the pointer
|
|
pLogon = (LPSSPILOGON)lParam;
|
|
Assert(pLogon);
|
|
|
|
// Set pContext hwndLogon
|
|
pLogon->pContext->hwndLogon = hwnd;
|
|
|
|
// Set myself to the foreground
|
|
SetForegroundWindow(hwnd);
|
|
|
|
// Center remember location
|
|
CenterDialog(hwnd);
|
|
|
|
// Limit Text
|
|
Edit_LimitText(GetDlgItem(hwnd, IDE_USERNAME), CCHMAX_USERNAME - 1);
|
|
Edit_LimitText(GetDlgItem(hwnd, IDE_PASSWORD), CCHMAX_PASSWORD - 1);
|
|
Edit_LimitText(GetDlgItem(hwnd, IDE_DOMAIN), CCHMAX_NTLM_DOMAIN - 1);
|
|
|
|
// Set Window Title
|
|
GetWindowText(hwnd, szRes, ARRAYSIZE(szRes));
|
|
wnsprintf(szTitle, ARRAYSIZE(szTitle), "%s - %s", szRes, pLogon->pCredential->szServer);
|
|
SetWindowText(hwnd, szTitle);
|
|
|
|
// Set User Name
|
|
Edit_SetText(GetDlgItem(hwnd, IDE_USERNAME), pLogon->pCredential->szUserName);
|
|
Edit_SetText(GetDlgItem(hwnd, IDE_PASSWORD), pLogon->pCredential->szPassword);
|
|
Edit_SetText(GetDlgItem(hwnd, IDE_DOMAIN), pLogon->pCredential->szDomain);
|
|
|
|
// Focus
|
|
if (pLogon->pCredential->szUserName[0] == '\0')
|
|
SetFocus(GetDlgItem(hwnd, IDE_USERNAME));
|
|
else
|
|
SetFocus(GetDlgItem(hwnd, IDE_PASSWORD));
|
|
|
|
// Save the pointer
|
|
SetWndThisPtr(hwnd, pLogon);
|
|
|
|
// Done
|
|
return(FALSE);
|
|
|
|
case WM_COMMAND:
|
|
switch(GET_WM_COMMAND_ID(wParam,lParam))
|
|
{
|
|
case IDCANCEL:
|
|
if (pLogon)
|
|
pLogon->pContext->hwndLogon = NULL;
|
|
EndDialog(hwnd, IDCANCEL);
|
|
return(TRUE);
|
|
|
|
case IDOK:
|
|
Assert(pLogon);
|
|
if (pLogon)
|
|
{
|
|
Edit_GetText(GetDlgItem(hwnd, IDE_USERNAME), pLogon->pCredential->szUserName, CCHMAX_USERNAME);
|
|
Edit_GetText(GetDlgItem(hwnd, IDE_PASSWORD), pLogon->pCredential->szPassword, CCHMAX_PASSWORD);
|
|
Edit_GetText(GetDlgItem(hwnd, IDE_DOMAIN), pLogon->pCredential->szDomain, CCHMAX_NTLM_DOMAIN);
|
|
pLogon->pContext->hwndLogon = NULL;
|
|
}
|
|
EndDialog(hwnd, LOGON_OK);
|
|
return(TRUE);
|
|
}
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
// This is here because when OE shuts down and this dialog is displayed, a WM_QUIT is posted to the thread
|
|
// that this dialog lives on. WM_QUIT causes a WM_DESTROY dialog to get sent to this dialog, but the parent
|
|
// doesn't seem to get re-enabled
|
|
EnableWindow(GetParent(hwnd), TRUE);
|
|
|
|
// Null out the this pointer
|
|
SetWndThisPtr(hwnd, NULL);
|
|
|
|
// Set pContext hwndLogon
|
|
if (pLogon)
|
|
pLogon->pContext->hwndLogon = NULL;
|
|
|
|
// Done
|
|
return(FALSE);
|
|
}
|
|
|
|
// Done
|
|
return(FALSE);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIFillAuth
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIFillAuth(LPCSTR pszUserName, LPCSTR pszPassword, LPCSTR pszDomain,
|
|
SEC_WINNT_AUTH_IDENTITY *pAuth)
|
|
{
|
|
// Set Flags
|
|
pAuth->Flags = SEC_WINNT_AUTH_IDENTITY_ANSI;
|
|
|
|
// Fill It
|
|
pAuth->User = (unsigned char *)(pszUserName ? pszUserName : c_szEmpty);
|
|
pAuth->UserLength = lstrlen((LPSTR)pAuth->User);
|
|
pAuth->Domain = (unsigned char *)(pszDomain ? pszDomain : c_szEmpty);
|
|
pAuth->DomainLength = lstrlen((LPSTR)pAuth->Domain);
|
|
pAuth->Password = (unsigned char *)(pszPassword ? pszPassword : c_szEmpty);
|
|
pAuth->PasswordLength = lstrlen((LPSTR)pAuth->Password);
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIAuthFromCredential
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIAuthFromCredential(LPCREDENTIAL pCredential, SEC_WINNT_AUTH_IDENTITY *pAuth)
|
|
{
|
|
// Fill It
|
|
SSPIFillAuth(pCredential->szUserName, pCredential->szPassword, pCredential->szDomain, pAuth);
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIFindCredential
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIFindCredential(LPSSPICONTEXT pContext, ITransportCallback *pCallback)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
LPCREDENTIAL pCurrent;
|
|
LPCREDENTIAL pPrevious=NULL;
|
|
LPCREDENTIAL pNew=NULL;
|
|
SSPILOGON Logon;
|
|
HWND hwndParent=NULL;
|
|
ITransportCallbackService *pService=NULL;
|
|
|
|
// Trace
|
|
TraceCall("SSPIFindCredential");
|
|
|
|
// Invalid Arg
|
|
Assert(pContext->pszServer && pCallback);
|
|
|
|
// No Callback
|
|
if (NULL == pCallback)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Thread Safety
|
|
EnterCriticalSection(&g_csDllMain);
|
|
|
|
// Search the list for cached credentials...
|
|
for (pCurrent=g_pCredentialHead; pCurrent!=NULL; pCurrent=pCurrent->pNext)
|
|
{
|
|
// Is this It ?
|
|
if (lstrcmpi(pContext->pszServer, pCurrent->szServer) == 0)
|
|
break;
|
|
|
|
// Save Previous
|
|
pPrevious = pCurrent;
|
|
}
|
|
|
|
// If we found one and there are no retries...
|
|
if (pCurrent)
|
|
{
|
|
// If no retries, then use this
|
|
if (0 == pCurrent->cRetry)
|
|
{
|
|
// Reset pContext ?
|
|
SafeMemFree(pContext->pszUserName);
|
|
SafeMemFree(pContext->pszPassword);
|
|
SafeMemFree(pContext->pszDomain);
|
|
|
|
// Duplicate the good stuff
|
|
IF_NULLEXIT(pContext->pszUserName = PszDupA((LPSTR)pCurrent->szUserName));
|
|
IF_NULLEXIT(pContext->pszDomain = PszDupA((LPSTR)pCurrent->szDomain));
|
|
IF_NULLEXIT(pContext->pszPassword = PszDupA((LPSTR)pCurrent->szPassword));
|
|
|
|
// Increment retry count
|
|
pCurrent->cRetry++;
|
|
|
|
// Thread Safety
|
|
LeaveCriticalSection(&g_csDllMain);
|
|
|
|
// Done
|
|
goto exit;
|
|
}
|
|
|
|
// Unlink pCurrent from the list
|
|
if (pPrevious)
|
|
{
|
|
Assert(pPrevious->pNext == pCurrent);
|
|
pPrevious->pNext = pCurrent->pNext;
|
|
}
|
|
else
|
|
{
|
|
Assert(g_pCredentialHead == pCurrent);
|
|
g_pCredentialHead = pCurrent->pNext;
|
|
}
|
|
}
|
|
|
|
// Thread Safety
|
|
LeaveCriticalSection(&g_csDllMain);
|
|
|
|
// Didn't find anything...allocate one
|
|
if (NULL == pCurrent)
|
|
{
|
|
// Allocate
|
|
IF_NULLEXIT(pNew = (LPCREDENTIAL)g_pMalloc->Alloc(sizeof(CREDENTIAL)));
|
|
|
|
// Zero
|
|
ZeroMemory(pNew, sizeof(CREDENTIAL));
|
|
|
|
// Set pCurrent
|
|
pCurrent = pNew;
|
|
|
|
// Store the Server Name
|
|
StrCpyN(pCurrent->szServer, pContext->pszServer, ARRAYSIZE(pCurrent->szServer));
|
|
}
|
|
|
|
// No pNext
|
|
pCurrent->pNext = NULL;
|
|
|
|
// QI pTransport for ITransportCallbackService
|
|
hr = pCallback->QueryInterface(IID_ITransportCallbackService, (LPVOID *)&pService);
|
|
if (FAILED(hr))
|
|
{
|
|
// Raid-69382 (2/5/99): CDO: loop in ISMTPTransport/INNTPTransport when Sicily authentication fails
|
|
// Clients who don't support this interface, I will treat them as a cancel.
|
|
pContext->fPromptCancel = TRUE;
|
|
TraceResult(hr);
|
|
goto exit;
|
|
}
|
|
|
|
// Get a Window Handle
|
|
hr = pService->GetParentWindow(0, &hwndParent);
|
|
if (FAILED(hr))
|
|
{
|
|
// Raid-69382 (2/5/99): CDO: loop in ISMTPTransport/INNTPTransport when Sicily authentication fails
|
|
// Clients who don't support this interface, I will treat them as a cancel.
|
|
pContext->fPromptCancel = TRUE;
|
|
TraceResult(hr);
|
|
goto exit;
|
|
}
|
|
|
|
// No Parent...
|
|
if (NULL == hwndParent || FALSE == IsWindow(hwndParent))
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Bring to the foreground
|
|
ShowWindow(hwndParent, SW_SHOW);
|
|
SetForegroundWindow(hwndParent);
|
|
|
|
// Clear the password
|
|
*pCurrent->szPassword = '\0';
|
|
|
|
// Initialize Current...
|
|
if (pContext->pszUserName)
|
|
StrCpyN(pCurrent->szUserName, pContext->pszUserName, ARRAYSIZE(pCurrent->szUserName));
|
|
if (pContext->pszDomain)
|
|
StrCpyN(pCurrent->szDomain, pContext->pszDomain, ARRAYSIZE(pCurrent->szDomain));
|
|
|
|
// Set Logon
|
|
Logon.pCredential = pCurrent;
|
|
Logon.pContext = pContext;
|
|
|
|
// Do the Dialog Box
|
|
if (LOGON_OK != DialogBoxParam(g_hLocRes, MAKEINTRESOURCE(IDD_NTLMPROMPT), hwndParent, GetCredentialDlgProc, (LPARAM)&Logon))
|
|
{
|
|
pContext->fPromptCancel = TRUE;
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Not cancel
|
|
pContext->fPromptCancel = FALSE;
|
|
|
|
// Reset pContext ?
|
|
SafeMemFree(pContext->pszUserName);
|
|
SafeMemFree(pContext->pszPassword);
|
|
SafeMemFree(pContext->pszDomain);
|
|
|
|
// Duplicate the good stuff
|
|
IF_NULLEXIT(pContext->pszUserName = PszDupA((LPSTR)pCurrent->szUserName));
|
|
IF_NULLEXIT(pContext->pszDomain = PszDupA((LPSTR)pCurrent->szDomain));
|
|
IF_NULLEXIT(pContext->pszPassword = PszDupA((LPSTR)pCurrent->szPassword));
|
|
|
|
// Set Next
|
|
pCurrent->pNext = g_pCredentialHead;
|
|
|
|
// Reset Head
|
|
g_pCredentialHead = pCurrent;
|
|
|
|
// Set Retry Count
|
|
pCurrent->cRetry++;
|
|
|
|
// Don't Free It
|
|
pNew = NULL;
|
|
|
|
exit:
|
|
// Cleanup
|
|
SafeMemFree(pNew);
|
|
SafeRelease(pService);
|
|
|
|
// Done
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIFreeCredentialList
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIFreeCredentialList(void)
|
|
{
|
|
// Locals
|
|
LPCREDENTIAL pCurrent;
|
|
LPCREDENTIAL pNext;
|
|
|
|
// Trace
|
|
TraceCall("SSPIFreeCredentialList");
|
|
|
|
// Thread Safety
|
|
EnterCriticalSection(&g_csDllMain);
|
|
|
|
// Set pCurrent
|
|
pCurrent = g_pCredentialHead;
|
|
|
|
// While we have a node
|
|
while (pCurrent)
|
|
{
|
|
// Save pNext
|
|
pNext = pCurrent->pNext;
|
|
|
|
// Free pCurrent
|
|
g_pMalloc->Free(pCurrent);
|
|
|
|
// Goto Next
|
|
pCurrent = pNext;
|
|
}
|
|
|
|
// Clear the header
|
|
g_pCredentialHead = NULL;
|
|
|
|
// Thread Safety
|
|
LeaveCriticalSection(&g_csDllMain);
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIUninitialize
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIUninitialize(void)
|
|
{
|
|
// Trace
|
|
TraceCall("SSPIUninitialize");
|
|
|
|
// If we have loaded the dll...
|
|
if (g_hInstSSPI)
|
|
{
|
|
// Free the Lib
|
|
FreeLibrary(g_hInstSSPI);
|
|
}
|
|
|
|
// Free Credential List
|
|
SSPIFreeCredentialList();
|
|
|
|
// Free Packages
|
|
if (g_prgPackage)
|
|
{
|
|
// Loop through Packages
|
|
for (DWORD i = 0; i < g_cPackages; i++)
|
|
{
|
|
// Free pszName
|
|
SafeMemFree(g_prgPackage[i].pszName);
|
|
|
|
// Free pszComment
|
|
SafeMemFree(g_prgPackage[i].pszComment);
|
|
}
|
|
|
|
// Free packages
|
|
SafeMemFree(g_prgPackage);
|
|
|
|
// No Packages
|
|
g_cPackages = 0;
|
|
}
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIIsInstalled
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIIsInstalled(void)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_FALSE;
|
|
INIT_SECURITY_INTERFACE addrProcISI = NULL;
|
|
|
|
// Trace
|
|
TraceCall("SSPIIsInstalled");
|
|
|
|
// Thread Safety
|
|
EnterCriticalSection(&g_csDllMain);
|
|
|
|
// Already Loaded ?
|
|
if (g_hInstSSPI)
|
|
{
|
|
hr = S_OK;
|
|
goto exit;
|
|
}
|
|
|
|
// Load Security DLL
|
|
if (S_OK == IsPlatformWinNT())
|
|
g_hInstSSPI = LoadLibrary(c_szSecurityDLL);
|
|
else
|
|
g_hInstSSPI = LoadLibrary(c_szSecur32DLL);
|
|
|
|
// Could not be loaded
|
|
if (NULL == g_hInstSSPI)
|
|
{
|
|
TraceInfo("SSPI: LoadLibrary failed.");
|
|
goto exit;
|
|
}
|
|
|
|
// Load the function table
|
|
addrProcISI = (INIT_SECURITY_INTERFACE)GetProcAddress(g_hInstSSPI, SECURITY_ENTRYPOINT);
|
|
if (NULL == addrProcISI)
|
|
{
|
|
TraceInfo("SSPI: GetProcAddress failed failed.");
|
|
goto exit;
|
|
}
|
|
|
|
// Get the SSPI function table
|
|
g_pFunctions = (*addrProcISI)();
|
|
|
|
// If the didn't work
|
|
if (NULL == g_pFunctions)
|
|
{
|
|
// Free the library
|
|
FreeLibrary(g_hInstSSPI);
|
|
|
|
// Null the handle
|
|
g_hInstSSPI = NULL;
|
|
|
|
// Failed to get the function table
|
|
TraceInfo("SSPI: Load Function Table failed.");
|
|
|
|
// Done
|
|
goto exit;
|
|
}
|
|
|
|
// Woo-hoo
|
|
hr = S_OK;
|
|
|
|
exit:
|
|
// Thread Safety
|
|
LeaveCriticalSection(&g_csDllMain);
|
|
|
|
// Done
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIGetPackages
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIGetPackages(LPSSPIPACKAGE *pprgPackage, LPDWORD pcPackages)
|
|
{
|
|
// Locals
|
|
SECURITY_STATUS hr=SEC_E_OK;
|
|
PSecPkgInfo prgPackage=NULL;
|
|
ULONG i;
|
|
|
|
// Trace
|
|
TraceCall("SSPIGetPackages");
|
|
|
|
// Check Params
|
|
if (NULL == pprgPackage || NULL == pcPackages)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Not Initialized
|
|
if (NULL == g_hInstSSPI || NULL == g_pFunctions)
|
|
return TraceResult(E_UNEXPECTED);
|
|
|
|
// Init
|
|
*pprgPackage = NULL;
|
|
*pcPackages = 0;
|
|
|
|
// Already have packages ?
|
|
EnterCriticalSection(&g_csDllMain);
|
|
|
|
// Do I already have the packages ?
|
|
if (NULL == g_prgPackage)
|
|
{
|
|
// Enumerate security packages
|
|
IF_FAILEXIT(hr = (*(g_pFunctions->EnumerateSecurityPackages))(&g_cPackages, &prgPackage));
|
|
|
|
// RAID - 29645 - EnumerateSecurityPackages seems to return cSec = Rand and pSec == NULL, so, I need to return at this point if cSec == 0 or pSec == NULL
|
|
if (0 == g_cPackages || NULL == prgPackage)
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Allocate pprgPackage
|
|
IF_NULLEXIT(g_prgPackage = (LPSSPIPACKAGE)ZeroAllocate(g_cPackages * sizeof(SSPIPACKAGE)));
|
|
|
|
// Copy data into ppPackages
|
|
for (i = 0; i < g_cPackages; i++)
|
|
{
|
|
g_prgPackage[i].ulCapabilities = prgPackage[i].fCapabilities;
|
|
g_prgPackage[i].wVersion = prgPackage[i].wVersion;
|
|
g_prgPackage[i].cbMaxToken = prgPackage[i].cbMaxToken;
|
|
g_prgPackage[i].pszName = PszDupA(prgPackage[i].Name);
|
|
g_prgPackage[i].pszComment = PszDupA(prgPackage[i].Comment);
|
|
}
|
|
}
|
|
|
|
// Return Global
|
|
*pprgPackage = g_prgPackage;
|
|
*pcPackages = g_cPackages;
|
|
|
|
exit:
|
|
// Already have packages ?
|
|
LeaveCriticalSection(&g_csDllMain);
|
|
|
|
// Free the package
|
|
if (prgPackage)
|
|
{
|
|
// Free the Array
|
|
(*(g_pFunctions->FreeContextBuffer))(prgPackage);
|
|
}
|
|
|
|
// Done
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPILogon
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPILogon(LPSSPICONTEXT pContext, BOOL fRetry, BOOL fBase64,
|
|
LPCSTR pszPackage, LPINETSERVER pServer, ITransportCallback *pCallback)
|
|
{
|
|
// Locals
|
|
SECURITY_STATUS hr = SEC_E_OK;
|
|
TimeStamp tsLifeTime;
|
|
SEC_WINNT_AUTH_IDENTITY *pAuth = NULL;
|
|
SEC_WINNT_AUTH_IDENTITY Auth={0};
|
|
|
|
// Trace
|
|
TraceCall("SSPILogon");
|
|
|
|
// Validate
|
|
Assert(pCallback);
|
|
|
|
// Invalid Args
|
|
if (NULL == pContext || NULL == pszPackage || NULL == pCallback)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Not Initialized
|
|
if (NULL == g_hInstSSPI || NULL == g_pFunctions)
|
|
return TraceResult(E_UNEXPECTED);
|
|
|
|
// Already have credential
|
|
if (pContext->fCredential && SSPI_STATE_USE_CACHED == pContext->tyState)
|
|
goto exit;
|
|
|
|
// Installed ?
|
|
if (S_FALSE == SSPIIsInstalled())
|
|
{
|
|
hr = TraceResult(IXP_E_LOAD_SICILY_FAILED);
|
|
goto exit;
|
|
}
|
|
|
|
// Reset fPropmtCancel
|
|
pContext->fPromptCancel = FALSE;
|
|
|
|
// No retry
|
|
if (NULL == pContext->pCallback)
|
|
{
|
|
// Locals
|
|
ITransportCallbackService *pService;
|
|
|
|
// Validate
|
|
Assert(!pContext->pszPackage && !pContext->pszServer && !pContext->pCallback && !pContext->pszUserName && !pContext->pszPassword);
|
|
|
|
// Save fBase64
|
|
pContext->fBase64 = fBase64;
|
|
|
|
// Copy Some Strings
|
|
IF_NULLEXIT(pContext->pszPackage = PszDupA(pszPackage));
|
|
IF_NULLEXIT(pContext->pszServer = PszDupA(pServer->szServerName));
|
|
IF_NULLEXIT(pContext->pszUserName = PszDupA(pServer->szUserName));
|
|
|
|
// Empty Password
|
|
if (FALSE == FIsEmptyA(pServer->szPassword))
|
|
{
|
|
// Copy It
|
|
IF_NULLEXIT(pContext->pszPassword = PszDupA(pServer->szPassword));
|
|
}
|
|
|
|
// Assume Callback
|
|
pContext->pCallback = pCallback;
|
|
pContext->pCallback->AddRef();
|
|
|
|
// Supports Callback Service
|
|
if (SUCCEEDED(pContext->pCallback->QueryInterface(IID_ITransportCallbackService, (LPVOID *)&pService)))
|
|
{
|
|
// This object supports the Service
|
|
pContext->fService = TRUE;
|
|
|
|
// Release
|
|
pService->Release();
|
|
}
|
|
|
|
// Otherwise
|
|
else
|
|
pContext->fService = FALSE;
|
|
}
|
|
|
|
// Clear current credential
|
|
if (pContext->fCredential)
|
|
{
|
|
// Free Credential Handle
|
|
(*(g_pFunctions->FreeCredentialHandle))(&pContext->hCredential);
|
|
|
|
// No Credential
|
|
pContext->fCredential = FALSE;
|
|
}
|
|
|
|
// Use Cached
|
|
if (SSPI_STATE_USE_CACHED == pContext->tyState)
|
|
{
|
|
// If not a retry...
|
|
if (FALSE == fRetry)
|
|
{
|
|
// No Retries
|
|
pContext->cRetries = 0;
|
|
|
|
// Thread Safety
|
|
EnterCriticalSection(&g_csDllMain);
|
|
|
|
// Search the list for cached credentials...
|
|
for (LPCREDENTIAL pCurrent=g_pCredentialHead; pCurrent!=NULL; pCurrent=pCurrent->pNext)
|
|
{
|
|
// Is this It ?
|
|
if (lstrcmpi(pContext->pszServer, pCurrent->szServer) == 0)
|
|
{
|
|
pCurrent->cRetry = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Thread Safety
|
|
LeaveCriticalSection(&g_csDllMain);
|
|
}
|
|
|
|
// Otherwise, assume we will need to force a prompt...
|
|
else
|
|
{
|
|
// Increment Retry Count
|
|
pContext->cRetries++;
|
|
|
|
// Valid Retry States...
|
|
Assert(SSPI_STATE_USE_CACHED == pContext->tyRetryState || SSPI_STATE_PROMPT_USE_PACKAGE == pContext->tyRetryState);
|
|
|
|
// The next phase may be to tell the package to prompt...
|
|
pContext->tyState = pContext->tyRetryState;
|
|
}
|
|
}
|
|
|
|
// Use Supplied
|
|
else if (SSPI_STATE_USE_SUPPLIED == pContext->tyState)
|
|
{
|
|
// Locals
|
|
CredHandle hCredential;
|
|
|
|
// Next State...
|
|
pContext->tyState = SSPI_STATE_USE_CACHED;
|
|
|
|
// Fill It
|
|
SSPIFillAuth(NULL, NULL, NULL, &Auth);
|
|
|
|
// Do some security stuff
|
|
if (SUCCEEDED((*(g_pFunctions->AcquireCredentialsHandle))(NULL, (LPSTR)pContext->pszPackage, SECPKG_CRED_OUTBOUND, NULL, &Auth, NULL, NULL, &hCredential, &tsLifeTime)))
|
|
{
|
|
// Free the Handle
|
|
(*(g_pFunctions->FreeCredentialHandle))(&hCredential);
|
|
}
|
|
|
|
// Use Supplied Credentials...
|
|
SSPIFillAuth(pContext->pszUserName, pContext->pszPassword, pContext->pszDomain, &Auth);
|
|
|
|
// Set pAuth
|
|
pAuth = &Auth;
|
|
}
|
|
|
|
// Otherwise, try to get cached credentials
|
|
else if (SSPI_STATE_PROMPT_USE_OWN == pContext->tyState)
|
|
{
|
|
// Next State...
|
|
pContext->tyState = SSPI_STATE_USE_CACHED;
|
|
|
|
// Failure
|
|
IF_FAILEXIT(hr = SSPIFindCredential(pContext, pCallback));
|
|
|
|
// Fill and return credentials
|
|
SSPIFillAuth(pContext->pszUserName, pContext->pszPassword, pContext->pszDomain, &Auth);
|
|
|
|
// Set Auth Information
|
|
pAuth = &Auth;
|
|
}
|
|
|
|
// Do some security stuff
|
|
IF_FAILEXIT(hr = (*(g_pFunctions->AcquireCredentialsHandle))(NULL, (LPSTR)pContext->pszPackage, SECPKG_CRED_OUTBOUND, NULL, pAuth, NULL, NULL, &pContext->hCredential, &tsLifeTime));
|
|
|
|
// We have a credential
|
|
pContext->fCredential = TRUE;
|
|
|
|
exit:
|
|
// Done
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIGetNegotiate
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIGetNegotiate(LPSSPICONTEXT pContext, LPSSPIBUFFER pNegotiate)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
|
|
// Trace
|
|
TraceCall("SSPIGetNegotiate");
|
|
|
|
// Invalid Args
|
|
if (NULL == pContext || NULL == pNegotiate)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Not Initialized
|
|
if (NULL == g_hInstSSPI || NULL == g_pFunctions)
|
|
return TraceResult(E_UNEXPECTED);
|
|
|
|
// If the context is currently initialized
|
|
if (pContext->fContext)
|
|
{
|
|
// Delete this context
|
|
(*(g_pFunctions->DeleteSecurityContext))(&pContext->hContext);
|
|
|
|
// No Context
|
|
pContext->fContext = FALSE;
|
|
}
|
|
|
|
// Reset this state.
|
|
pContext->fUsedSuppliedCreds = FALSE;
|
|
|
|
// Build Negotiation String
|
|
IF_FAILEXIT(hr = SSPIMakeOutboundMessage(pContext, 0, pNegotiate, NULL));
|
|
|
|
exit:
|
|
// Done
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIResponseFromChallenge
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIResponseFromChallenge(LPSSPICONTEXT pContext, LPSSPIBUFFER pChallenge,
|
|
LPSSPIBUFFER pResponse)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
DWORD nBytesReceived;
|
|
DWORD dwFlags=0;
|
|
SecBufferDesc Descript;
|
|
SecBuffer Buffer[SEC_BUFFER_NUM_EXTENDED_BUFFERS];
|
|
|
|
// Trace
|
|
TraceCall("SSPIResponseFromChallenge");
|
|
|
|
// Invalid Args
|
|
if (NULL == pContext || NULL == pChallenge || NULL == pResponse)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Not Initialized
|
|
if (NULL == g_hInstSSPI || NULL == g_pFunctions)
|
|
return TraceResult(E_UNEXPECTED);
|
|
|
|
// More Unexpected Stuff
|
|
if (FALSE == pContext->fContext || FALSE == pContext->fCredential)
|
|
return TraceResult(E_UNEXPECTED);
|
|
|
|
// Decode the Challenge Buffer
|
|
IF_FAILEXIT(hr == SSPIDecodeBuffer(pContext->fBase64, pChallenge));
|
|
|
|
// Fill SecBufferDesc
|
|
Descript.ulVersion = 0;
|
|
Descript.pBuffers = Buffer;
|
|
Descript.cBuffers = 1;
|
|
|
|
// Setup the challenge input buffer always (0th buffer)
|
|
Buffer[SEC_BUFFER_CHALLENGE_INDEX].pvBuffer = pChallenge->szBuffer;
|
|
Buffer[SEC_BUFFER_CHALLENGE_INDEX].cbBuffer = pChallenge->cbBuffer - 1;
|
|
Buffer[SEC_BUFFER_CHALLENGE_INDEX].BufferType = SECBUFFER_TOKEN;
|
|
|
|
// If Digest
|
|
if (FALSE == pContext->fUsedSuppliedCreds && lstrcmpi(pContext->pszPackage, "digest") == 0)
|
|
{
|
|
// If we have a user, setup the user buffer (1st buffer)
|
|
Buffer[SEC_BUFFER_USERNAME_INDEX].pvBuffer = pContext->pszUserName ? pContext->pszUserName : NULL;
|
|
Buffer[SEC_BUFFER_USERNAME_INDEX].cbBuffer = pContext->pszUserName ? lstrlen(pContext->pszUserName) : NULL;
|
|
Buffer[SEC_BUFFER_USERNAME_INDEX].BufferType = SECBUFFER_TOKEN;
|
|
|
|
// If we have a password, setup the password buffer (2nd buffer for
|
|
// a total of 3 buffers passed in (challenge + user + pass)
|
|
Buffer[SEC_BUFFER_PASSWORD_INDEX].pvBuffer = pContext->pszPassword ? pContext->pszPassword : NULL;
|
|
Buffer[SEC_BUFFER_PASSWORD_INDEX].cbBuffer = pContext->pszPassword ? lstrlen(pContext->pszPassword) : NULL;
|
|
Buffer[SEC_BUFFER_PASSWORD_INDEX].BufferType = SECBUFFER_TOKEN;
|
|
|
|
// If either or both user and pass passed in, set num input buffers to 3 // (SEC_BUFFER_NUM_EXTENDED_BUFFERS)
|
|
if (pContext->pszUserName || pContext->pszPassword)
|
|
Descript.cBuffers = SEC_BUFFER_NUM_EXTENDED_BUFFERS;
|
|
|
|
// else we're just passing in the one challenge buffer (0th buffer as usual)
|
|
else
|
|
Descript.cBuffers = SEC_BUFFER_NUM_NORMAL_BUFFERS;
|
|
|
|
// We are supplying creds
|
|
pContext->fUsedSuppliedCreds = TRUE;
|
|
|
|
// Set dwFlags
|
|
dwFlags = ISC_REQ_USE_SUPPLIED_CREDS;
|
|
}
|
|
|
|
// Prepare for OutMsg
|
|
IF_FAILEXIT(hr = SSPIMakeOutboundMessage(pContext, dwFlags, pResponse, &Descript));
|
|
|
|
exit:
|
|
// Done
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIReleaseContext
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIReleaseContext(LPSSPICONTEXT pContext)
|
|
{
|
|
// Was Context Initialized
|
|
if (pContext->fContext)
|
|
{
|
|
// Delete the Security Context
|
|
(*(g_pFunctions->DeleteSecurityContext))(&pContext->hContext);
|
|
|
|
// No context
|
|
pContext->fContext = FALSE;
|
|
}
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIFreeContext
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIFreeContext(LPSSPICONTEXT pContext)
|
|
{
|
|
// Locals
|
|
SSPICONTEXTSTATE tyState;
|
|
SSPICONTEXTSTATE tyRetryState;
|
|
DWORD cRetries;
|
|
|
|
// Trace
|
|
TraceCall("SSPIFreeContext");
|
|
|
|
// Is the context initialized
|
|
if (pContext->fContext)
|
|
{
|
|
// Delete It
|
|
(*(g_pFunctions->DeleteSecurityContext))(&pContext->hContext);
|
|
|
|
// No Context
|
|
pContext->fContext = FALSE;
|
|
}
|
|
|
|
// Credential Handle Initialized
|
|
if (pContext->fCredential)
|
|
{
|
|
// Free Credential Handle
|
|
(*(g_pFunctions->FreeCredentialHandle))(&pContext->hCredential);
|
|
|
|
// No Context
|
|
pContext->fCredential = FALSE;
|
|
}
|
|
|
|
// Free Package, Server and Callback
|
|
SafeMemFree(pContext->pszPackage);
|
|
SafeMemFree(pContext->pszUserName);
|
|
SafeMemFree(pContext->pszPassword);
|
|
SafeMemFree(pContext->pszServer);
|
|
SafeRelease(pContext->pCallback);
|
|
|
|
// Close hMutexUI
|
|
if (pContext->hwndLogon)
|
|
{
|
|
// Nuke the Window
|
|
DestroyWindow(pContext->hwndLogon);
|
|
|
|
// Null
|
|
pContext->hwndLogon = NULL;
|
|
}
|
|
|
|
// Save It
|
|
tyState = (SSPICONTEXTSTATE)pContext->tyState;
|
|
tyRetryState = (SSPICONTEXTSTATE)pContext->tyRetryState;
|
|
cRetries = pContext->cRetries;
|
|
|
|
// Zero It Out
|
|
ZeroMemory(pContext, sizeof(SSPICONTEXT));
|
|
|
|
// Do Prompt
|
|
pContext->tyState = tyState;
|
|
pContext->tyRetryState = tyRetryState;
|
|
pContext->cRetries = cRetries;
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// SSPIPromptThreadEntry
|
|
// --------------------------------------------------------------------------------
|
|
DWORD SSPIPromptThreadEntry(LPDWORD pdwParam)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
LPSSPIPROMPTINFO pPrompt=(LPSSPIPROMPTINFO)pdwParam;
|
|
|
|
// Trace
|
|
TraceCall("SSPIPromptThreadEntry");
|
|
|
|
// Validate
|
|
Assert(pPrompt && pPrompt->pContext);
|
|
|
|
// Fixup pInDescript
|
|
if (pPrompt->pInDescript && pPrompt->pInDescript->cBuffers >= 3 && lstrcmpi(pPrompt->pContext->pszPackage, "digest") == 0)
|
|
{
|
|
// Raid-66013: Make sure the password is empty or digest will crash
|
|
pPrompt->pInDescript->pBuffers[SEC_BUFFER_PASSWORD_INDEX].pvBuffer = NULL;
|
|
pPrompt->pInDescript->pBuffers[SEC_BUFFER_PASSWORD_INDEX].cbBuffer = 0;
|
|
//pPrompt->pInDescript->cBuffers = 2;
|
|
}
|
|
|
|
// Try to get the package to prompt for credentials...
|
|
pPrompt->hrResult = (*(g_pFunctions->InitializeSecurityContext))(
|
|
&pPrompt->pContext->hCredential,
|
|
pPrompt->phCtxCurrent,
|
|
pPrompt->pContext->pszServer,
|
|
pPrompt->dwFlags | ISC_REQ_PROMPT_FOR_CREDS,
|
|
0,
|
|
SECURITY_NATIVE_DREP,
|
|
pPrompt->pInDescript,
|
|
0,
|
|
&pPrompt->pContext->hContext,
|
|
pPrompt->pOutDescript,
|
|
&pPrompt->fContextAttrib,
|
|
&pPrompt->tsExpireTime);
|
|
|
|
// Trace
|
|
TraceResultSz(pPrompt->hrResult, "SSPIPromptThreadEntry");
|
|
|
|
// Done
|
|
return(0);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPISetAccountUserName
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPISetAccountUserName(LPCSTR pszName, LPSSPICONTEXT pContext)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
DWORD dwServerType;
|
|
IImnAccount *pAccount=NULL;
|
|
ITransportCallbackService *pService=NULL;
|
|
|
|
// Trace
|
|
TraceCall("SSPISetAccountUserName");
|
|
|
|
// Validate Args
|
|
Assert(pszName);
|
|
Assert(pContext);
|
|
Assert(pContext->pCallback);
|
|
|
|
// Get ITransportCallbackService
|
|
IF_FAILEXIT(hr = pContext->pCallback->QueryInterface(IID_ITransportCallbackService, (LPVOID *)&pService));
|
|
|
|
// Get the Account
|
|
IF_FAILEXIT(hr = pService->GetAccount(&dwServerType, &pAccount));
|
|
|
|
// SRV_POP3
|
|
if (ISFLAGSET(dwServerType, SRV_POP3))
|
|
{
|
|
// Set the UserName
|
|
IF_FAILEXIT(hr = pAccount->SetPropSz(AP_POP3_USERNAME, (LPSTR)pszName));
|
|
}
|
|
|
|
// SRV_SMTP
|
|
else if (ISFLAGSET(dwServerType, SRV_SMTP))
|
|
{
|
|
// Set the UserName
|
|
IF_FAILEXIT(hr = pAccount->SetPropSz(AP_SMTP_USERNAME, (LPSTR)pszName));
|
|
}
|
|
|
|
// SRV_IMAP
|
|
else if (ISFLAGSET(dwServerType, SRV_IMAP))
|
|
{
|
|
// Set the UserName
|
|
IF_FAILEXIT(hr = pAccount->SetPropSz(AP_IMAP_USERNAME, (LPSTR)pszName));
|
|
}
|
|
|
|
// SRV_NNTP
|
|
else if (ISFLAGSET(dwServerType, SRV_NNTP))
|
|
{
|
|
// Set the UserName
|
|
IF_FAILEXIT(hr = pAccount->SetPropSz(AP_NNTP_USERNAME, (LPSTR)pszName));
|
|
}
|
|
|
|
// Save Changes
|
|
pAccount->SaveChanges();
|
|
|
|
exit:
|
|
// Cleanup
|
|
SafeRelease(pService);
|
|
SafeRelease(pAccount);
|
|
|
|
// Done
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// SSPIMakeOutboundMessage
|
|
//--------------------------------------------------------------------------
|
|
HRESULT SSPIMakeOutboundMessage(LPSSPICONTEXT pContext, DWORD dwFlags,
|
|
LPSSPIBUFFER pBuffer, PSecBufferDesc pInDescript)
|
|
{
|
|
// Locals
|
|
SECURITY_STATUS hr=S_OK;
|
|
SSPIPROMPTINFO Prompt={0};
|
|
SecBuffer OutBuffer;
|
|
SecBufferDesc OutDescript;
|
|
ULONG fContextAttrib;
|
|
TimeStamp tsExpireTime;
|
|
HANDLE hPromptThread;
|
|
DWORD dwThreadId;
|
|
DWORD dwWait;
|
|
MSG msg;
|
|
PCtxtHandle phCtxCurrent=NULL;
|
|
PAUTHENTICATE_MESSAGE pAuthMsg;
|
|
LPSTR pszName=NULL;
|
|
|
|
// Invalid Args
|
|
if (NULL == pContext || NULL == pBuffer)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Bad Context
|
|
if (NULL == pContext->pszPackage)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Bad Context
|
|
if (NULL == pContext->pszServer)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Bad Context
|
|
if (NULL == pContext->pCallback)
|
|
return TraceResult(E_INVALIDARG);
|
|
|
|
// Not Initialized
|
|
if (NULL == g_hInstSSPI || NULL == g_pFunctions)
|
|
return TraceResult(E_UNEXPECTED);
|
|
|
|
// Bad State
|
|
if (FALSE == pContext->fCredential)
|
|
return TraceResult(E_UNEXPECTED);
|
|
|
|
// Validate
|
|
Assert(pInDescript == NULL ? FALSE == pContext->fContext : TRUE);
|
|
|
|
// Initialize Out Descriptor
|
|
OutDescript.ulVersion = 0;
|
|
OutDescript.cBuffers = 1;
|
|
OutDescript.pBuffers = &OutBuffer;
|
|
|
|
// Initialize Output Buffer
|
|
OutBuffer.cbBuffer = CBMAX_SSPI_BUFFER - 1;
|
|
OutBuffer.BufferType = SECBUFFER_TOKEN;
|
|
OutBuffer.pvBuffer = pBuffer->szBuffer;
|
|
|
|
// phCtxCurrent
|
|
if (pInDescript)
|
|
{
|
|
// Set Current Context
|
|
phCtxCurrent = &pContext->hContext;
|
|
}
|
|
|
|
// First Retry ?
|
|
if (SSPI_STATE_PROMPT_USE_PACKAGE == pContext->tyState && (0 != lstrcmpi(pContext->pszPackage, "digest") || pInDescript))
|
|
{
|
|
// Force failure to do the prompt
|
|
hr = SEC_E_NO_CREDENTIALS;
|
|
}
|
|
|
|
// Otherwise, do the next security context
|
|
else
|
|
{
|
|
// Generate a negotiate/authenticate message to be sent to the server.
|
|
hr = (*(g_pFunctions->InitializeSecurityContext))(&pContext->hCredential, phCtxCurrent, pContext->pszServer, dwFlags, 0, SECURITY_NATIVE_DREP, pInDescript, 0, &pContext->hContext, &OutDescript, &fContextAttrib, &tsExpireTime);
|
|
}
|
|
|
|
// Set Retry State...
|
|
pContext->tyRetryState = SSPI_STATE_PROMPT_USE_PACKAGE;
|
|
|
|
// Failure
|
|
if (FAILED(hr))
|
|
{
|
|
// Trace
|
|
TraceResult(hr);
|
|
|
|
// No credentials ? lets do it again and get some credentials
|
|
if (SEC_E_NO_CREDENTIALS != hr)
|
|
goto exit;
|
|
|
|
// If no retries yet...
|
|
if (TRUE == pContext->fService && 0 == lstrcmpi(pContext->pszPackage, "MSN") && 0 == pContext->cRetries)
|
|
{
|
|
// Don't retry again...
|
|
pContext->tyState = SSPI_STATE_USE_SUPPLIED;
|
|
|
|
// Do the logon Now...
|
|
hr = SSPILogon(pContext, FALSE, pContext->fBase64, pContext->pszPackage, NULL, pContext->pCallback);
|
|
|
|
// Cancel ?
|
|
Assert(FALSE == pContext->fPromptCancel);
|
|
|
|
// Success
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Try Again
|
|
hr = (*(g_pFunctions->InitializeSecurityContext))(&pContext->hCredential, NULL, pContext->pszServer, 0, 0, SECURITY_NATIVE_DREP, NULL, 0, &pContext->hContext, &OutDescript, &fContextAttrib, &tsExpireTime);
|
|
}
|
|
}
|
|
|
|
// Still Failed ?
|
|
if (FAILED(hr))
|
|
{
|
|
// Fill up the prompt info...
|
|
Assert(dwFlags == 0 || dwFlags == ISC_REQ_USE_SUPPLIED_CREDS);
|
|
Prompt.pContext = pContext;
|
|
Prompt.pInDescript = pInDescript;
|
|
Prompt.pOutDescript = &OutDescript;
|
|
Prompt.phCtxCurrent = phCtxCurrent;
|
|
Prompt.dwFlags = dwFlags;
|
|
|
|
// Create the Thread
|
|
IF_NULLEXIT(hPromptThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)SSPIPromptThreadEntry, &Prompt, 0, &dwThreadId));
|
|
|
|
// Wait for the thread to finish
|
|
WaitForSingleObject(hPromptThread, INFINITE);
|
|
|
|
// This is what I tried to do so that the spooler window would paint, but it caused all sorts of voodo
|
|
#if 0
|
|
// Wait for the thread to finish
|
|
while (1)
|
|
{
|
|
// Wait
|
|
dwWait = MsgWaitForMultipleObjects(1, &hPromptThread, FALSE, INFINITE, QS_PAINT);
|
|
|
|
// Done ?
|
|
if (dwWait != WAIT_OBJECT_0 + 1)
|
|
break;
|
|
|
|
// Pump Messages
|
|
while (PeekMessage(&msg, NULL, WM_PAINT, WM_PAINT, PM_REMOVE))
|
|
{
|
|
// Translate the Message
|
|
TranslateMessage(&msg);
|
|
|
|
// Dispatch the Message
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Close the Thread
|
|
CloseHandle(hPromptThread);
|
|
|
|
// Set hr
|
|
hr = Prompt.hrResult;
|
|
|
|
// If that failed
|
|
if (FAILED(hr))
|
|
{
|
|
// Decide when its no longer needed to continue...
|
|
if (SEC_E_NO_CREDENTIALS == hr)
|
|
goto exit;
|
|
|
|
// Only do this if on negotiate phase otherwise NTLM prompt comes up twice
|
|
if (NULL == pInDescript)
|
|
{
|
|
// Do Prompt
|
|
pContext->tyState = SSPI_STATE_PROMPT_USE_OWN;
|
|
|
|
// Do the logon Now...
|
|
hr = SSPILogon(pContext, TRUE, pContext->fBase64, pContext->pszPackage, NULL, pContext->pCallback);
|
|
|
|
// Cancel ?
|
|
if (pContext->fPromptCancel)
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Success
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Try Again
|
|
hr = (*(g_pFunctions->InitializeSecurityContext))(&pContext->hCredential, phCtxCurrent, pContext->pszServer, 0, 0, SECURITY_NATIVE_DREP, pInDescript, 0, &pContext->hContext, &OutDescript, &fContextAttrib, &tsExpireTime);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Success
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// We have a context
|
|
pContext->fContext = TRUE;
|
|
|
|
// If MSN or NTLM...
|
|
if (TRUE == pContext->fService && 0 == lstrcmpi(pContext->pszPackage, "MSN"))
|
|
{
|
|
// Look at the buffer...
|
|
pAuthMsg = (PAUTHENTICATE_MESSAGE)pBuffer->szBuffer;
|
|
|
|
// Validate Signature
|
|
Assert(0 == StrCmpNI((LPCSTR)pAuthMsg->Signature, NTLMSSP_SIGNATURE, sizeof(NTLMSSP_SIGNATURE)));
|
|
|
|
// Right Phase ?
|
|
if (NtLmAuthenticate == pAuthMsg->MessageType)
|
|
{
|
|
// Allocate
|
|
IF_NULLEXIT(pszName = (LPSTR)g_pMalloc->Alloc(pAuthMsg->UserName.Length + sizeof(CHAR)));
|
|
|
|
// Copy the name
|
|
CopyMemory(pszName, (LPBYTE)pBuffer->szBuffer + PtrToUlong(pAuthMsg->UserName.Buffer), pAuthMsg->UserName.Length);
|
|
|
|
// Stuff a Null....
|
|
pszName[pAuthMsg->UserName.Length] = '\0';
|
|
|
|
// If Context UserName is empty, lets store pszName into the account
|
|
if ('\0' == *pContext->pszUserName)
|
|
{
|
|
// Put pszName as the username for this account
|
|
if (SUCCEEDED(SSPISetAccountUserName(pszName, pContext)))
|
|
{
|
|
// Reset the UserName
|
|
SafeMemFree(pContext->pszUserName);
|
|
|
|
// Copy the new username
|
|
IF_NULLEXIT(pContext->pszUserName = PszDupA(pszName));
|
|
}
|
|
}
|
|
|
|
// Name Change
|
|
if (lstrcmpi(pszName, pContext->pszUserName) != 0)
|
|
{
|
|
// Don't retry again...
|
|
pContext->tyState = SSPI_STATE_USE_SUPPLIED;
|
|
|
|
// Set Retry State...
|
|
pContext->tyRetryState = SSPI_STATE_USE_CACHED;
|
|
|
|
// Do the logon Now...
|
|
hr = SSPILogon(pContext, FALSE, pContext->fBase64, pContext->pszPackage, NULL, pContext->pCallback);
|
|
|
|
// Cancel ?
|
|
Assert(FALSE == pContext->fPromptCancel);
|
|
|
|
// Success
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Try Again
|
|
hr = (*(g_pFunctions->InitializeSecurityContext))(&pContext->hCredential, NULL, pContext->pszServer, 0, 0, SECURITY_NATIVE_DREP, NULL, 0, &pContext->hContext, &OutDescript, &fContextAttrib, &tsExpireTime);
|
|
}
|
|
|
|
// Fail, but continue...
|
|
if (FAILED(hr))
|
|
{
|
|
// We are going to need to prompt...
|
|
pContext->tyState = SSPI_STATE_PROMPT_USE_PACKAGE;
|
|
|
|
// Trace
|
|
TraceResult(hr);
|
|
|
|
// Always Succeed, but cause authentication to fail...
|
|
hr = S_OK;
|
|
|
|
// Reset Length
|
|
OutBuffer.cbBuffer = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Otherwise...
|
|
else
|
|
{
|
|
// Trace
|
|
TraceResult(hr);
|
|
|
|
// Always Succeed, but cause authentication to fail...
|
|
hr = S_OK;
|
|
|
|
// Reset Length
|
|
OutBuffer.cbBuffer = 0;
|
|
}
|
|
|
|
// Continue required
|
|
pBuffer->fContinue = (SEC_I_CONTINUE_NEEDED == hr) ? TRUE : FALSE;
|
|
|
|
// Set cbBuffer
|
|
pBuffer->cbBuffer = OutBuffer.cbBuffer + 1;
|
|
|
|
// Null Terminate
|
|
pBuffer->szBuffer[pBuffer->cbBuffer - 1] = '\0';
|
|
|
|
// need to encode the blob before send out
|
|
IF_FAILEXIT(hr == SSPIEncodeBuffer(pContext->fBase64, pBuffer));
|
|
|
|
// All Good
|
|
hr = S_OK;
|
|
|
|
exit:
|
|
// Cleanup
|
|
SafeMemFree(pszName);
|
|
|
|
// Done
|
|
return(hr);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
// SSPIEncodeBuffer
|
|
//-------------------------------------------------------------------------------------------
|
|
HRESULT SSPIEncodeBuffer(BOOL fBase64, LPSSPIBUFFER pBuffer)
|
|
{
|
|
// Locals
|
|
LPBYTE pbIn=(LPBYTE)pBuffer->szBuffer;
|
|
DWORD cbIn=pBuffer->cbBuffer - 1;
|
|
BYTE rgbOut[CBMAX_SSPI_BUFFER - 1];
|
|
LPBYTE pbOut=rgbOut;
|
|
DWORD i;
|
|
|
|
// Trace
|
|
TraceCall("SSPIEncodeBuffer");
|
|
|
|
// Validate
|
|
Assert(pBuffer->szBuffer[pBuffer->cbBuffer - 1] == '\0');
|
|
|
|
// Set the lookup table to use to encode
|
|
LPCSTR rgchDict = (fBase64 ? six2base64 : six2uu);
|
|
|
|
// Loop
|
|
for (i = 0; i < cbIn; i += 3)
|
|
{
|
|
// Encode
|
|
*(pbOut++) = rgchDict[*pbIn >> 2];
|
|
*(pbOut++) = rgchDict[((*pbIn << 4) & 060) | ((pbIn[1] >> 4) & 017)];
|
|
*(pbOut++) = rgchDict[((pbIn[1] << 2) & 074) | ((pbIn[2] >> 6) & 03)];
|
|
*(pbOut++) = rgchDict[pbIn[2] & 077];
|
|
|
|
// Increment pbIn
|
|
pbIn += 3;
|
|
}
|
|
|
|
// If nbytes was not a multiple of 3, then we have encoded too many characters. Adjust appropriately.
|
|
if (i == cbIn + 1)
|
|
{
|
|
// There were only 2 bytes in that last group
|
|
pbOut[-1] = '=';
|
|
}
|
|
|
|
// There was only 1 byte in that last group
|
|
else if (i == cbIn + 2)
|
|
{
|
|
pbOut[-1] = '=';
|
|
pbOut[-2] = '=';
|
|
}
|
|
|
|
// Null Terminate
|
|
*pbOut = '\0';
|
|
|
|
// Copy Back into pBuffer
|
|
SSPISetBuffer((LPCSTR)rgbOut, SSPI_STRING, 0, pBuffer);
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
// SSPIDecodeBuffer
|
|
//-------------------------------------------------------------------------------------------
|
|
HRESULT SSPIDecodeBuffer(BOOL fBase64, LPSSPIBUFFER pBuffer)
|
|
{
|
|
// Locals
|
|
LPSTR pszStart=pBuffer->szBuffer;
|
|
LPBYTE pbIn=(LPBYTE)pBuffer->szBuffer;
|
|
DWORD cbIn=pBuffer->cbBuffer - 1;
|
|
BYTE rgbOut[CBMAX_SSPI_BUFFER - 1];
|
|
LPBYTE pbOut=rgbOut;
|
|
DWORD cbOutLeft = ARRAYSIZE(rgbOut)-1;
|
|
long cbDecode;
|
|
DWORD cbOut=0;
|
|
|
|
// Trace
|
|
TraceCall("SSPIDecodeBuffer");
|
|
|
|
// Validate
|
|
Assert(pBuffer->szBuffer[pBuffer->cbBuffer - 1] == '\0');
|
|
|
|
// Set the lookup table to use to encode
|
|
const int *rgiDict = (fBase64 ? base642six : uu2six);
|
|
|
|
// Strip leading whitespace
|
|
while (*pszStart == ' ' || *pszStart == '\t')
|
|
pszStart++;
|
|
|
|
// Set pbIn
|
|
pbIn = (LPBYTE)pszStart;
|
|
|
|
// Hmmm, I don't know what this does
|
|
while (rgiDict[*(pbIn++)] <= 63)
|
|
{};
|
|
|
|
// Actual Number of bytes to encode
|
|
cbDecode = (long) ((LPBYTE)pbIn - (LPBYTE)pszStart) - 1;
|
|
|
|
// Computed length of outbound buffer
|
|
cbOut = ((cbDecode + 3) / 4) * 3;
|
|
|
|
// Reset pbIn
|
|
pbIn = (LPBYTE)pszStart;
|
|
|
|
// Decode
|
|
while ((cbDecode > 0) && (3 <= cbOutLeft))
|
|
{
|
|
// Decode
|
|
*(pbOut++) = (unsigned char) (rgiDict[*pbIn] << 2 | rgiDict[pbIn[1]] >> 4);
|
|
*(pbOut++) = (unsigned char) (rgiDict[pbIn[1]] << 4 | rgiDict[pbIn[2]] >> 2);
|
|
*(pbOut++) = (unsigned char) (rgiDict[pbIn[2]] << 6 | rgiDict[pbIn[3]]);
|
|
cbOutLeft -= 3;
|
|
Assert((cbDecode <= 0) || (3 <= cbOutLeft)); // If this happens, then cbDecode was calculated incorrectly and we will overflow the buffer.
|
|
|
|
// Increment pbIn
|
|
pbIn += 4;
|
|
|
|
// Decrement cbDecode
|
|
cbDecode -= 4;
|
|
}
|
|
|
|
// Special termination case
|
|
if (cbDecode & 03)
|
|
{
|
|
if (rgiDict[pbIn[-2]] > 63)
|
|
cbOut -= 2;
|
|
else
|
|
cbOut -= 1;
|
|
}
|
|
|
|
// Set the Outbuffer
|
|
SSPISetBuffer((LPCSTR)rgbOut, SSPI_BLOB, cbOut, pBuffer);
|
|
|
|
// Done
|
|
return(S_OK);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
// SSPIFlushMSNCredentialCache - This code was given to us by kingra/MSN (see csager)
|
|
//-------------------------------------------------------------------------------------------
|
|
HRESULT SSPIFlushMSNCredentialCache(void)
|
|
{
|
|
// Locals
|
|
HRESULT hr=S_OK;
|
|
HKEY hKey=NULL;
|
|
DWORD dwType;
|
|
CHAR szDllName[MAX_PATH];
|
|
CHAR szProviders[1024];
|
|
DWORD cb=ARRAYSIZE(szProviders);
|
|
HINSTANCE hInstDll=NULL;
|
|
PFNCLEANUPCREDENTIALCACHE pfnCleanupCredentialCache;
|
|
|
|
// Open the HKLM Reg Entry
|
|
if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Control\\SecurityProviders", 0, KEY_READ, &hKey))
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Read the Providers
|
|
if (ERROR_SUCCESS != RegQueryValueEx(hKey, "SecurityProviders", NULL, &dwType, (LPBYTE)szProviders, &cb))
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Upper Case the Providers
|
|
CharUpperBuff(szProviders, (DWORD)min(cb,ARRAYSIZE(szProviders)));
|
|
|
|
// Map to something...
|
|
if (StrStrA(szProviders, "MSAPSSPS.DLL"))
|
|
StrCpyN(szDllName, "MSAPSSPS.DLL", ARRAYSIZE(szDllName));
|
|
else if (StrStrA(szProviders, "MSAPSSPC.DLL"))
|
|
StrCpyN(szDllName, "MSAPSSPC.DLL", ARRAYSIZE(szDllName));
|
|
else
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Load the DLL
|
|
hInstDll = LoadLibrary(szDllName);
|
|
|
|
// Failed to Load
|
|
if (NULL == hInstDll)
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Get the ProcAddress
|
|
pfnCleanupCredentialCache = (PFNCLEANUPCREDENTIALCACHE)GetProcAddress(hInstDll, "CleanupCredentialCache");
|
|
|
|
// Failure ?
|
|
if (NULL == pfnCleanupCredentialCache)
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
// Call the function that clears the cache
|
|
if (!pfnCleanupCredentialCache())
|
|
{
|
|
hr = TraceResult(E_FAIL);
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
// Cleanup
|
|
if (hKey)
|
|
RegCloseKey(hKey);
|
|
if (hInstDll)
|
|
FreeLibrary(hInstDll);
|
|
|
|
// Done
|
|
return(hr);
|
|
}
|