1387 lines
37 KiB
C
1387 lines
37 KiB
C
/*++
|
|
|
|
Copyright (c) 2000, Microsoft Corporation
|
|
|
|
Module Name:
|
|
eltrace.c
|
|
|
|
Abstract:
|
|
|
|
Routines for database logging
|
|
|
|
|
|
Revision History:
|
|
|
|
sachins, September 05 2001, Created
|
|
|
|
--*/
|
|
#include "pcheapol.h"
|
|
#pragma hdrstop
|
|
|
|
#define WZCSVC_DLL_PATH L"%SystemRoot%\\system32\\wzcsvc.dll"
|
|
|
|
WCHAR *EAPOLStates[] =
|
|
{
|
|
L"LOGOFF",
|
|
L"DISCONNECTED",
|
|
L"CONNECTING",
|
|
L"ACQUIRED",
|
|
L"AUTHENTICATING",
|
|
L"HELD",
|
|
L"AUTHENTICATED",
|
|
L"UNDEFINED"
|
|
};
|
|
|
|
WCHAR *EAPOLAuthTypes[] =
|
|
{
|
|
L"Guest",
|
|
L"User",
|
|
L"Machine"
|
|
};
|
|
|
|
WCHAR *EAPOLPacketTypes[] =
|
|
{
|
|
L"EAP-Packet",
|
|
L"EAPOL-Start",
|
|
L"EAPOL-Logoff",
|
|
L"EAPOL-Key",
|
|
L"Undefined"
|
|
};
|
|
|
|
WCHAR *EAPOLEAPPacketTypes[] =
|
|
{
|
|
L"", // "0" is undefined EAP Type
|
|
L"EAP-Request",
|
|
L"EAP-Response",
|
|
L"EAP-Success",
|
|
L"EAP-Failure"
|
|
};
|
|
|
|
|
|
DWORD
|
|
DbFormatEAPOLEventVA (
|
|
WCHAR *pwszMessage,
|
|
DWORD dwEventId,
|
|
...
|
|
)
|
|
{
|
|
va_list argList;
|
|
DWORD dwRetCode = NO_ERROR;
|
|
|
|
do
|
|
{
|
|
va_start (argList, dwEventId);
|
|
|
|
if ((dwRetCode = DbFormatEAPOLEvent (
|
|
pwszMessage,
|
|
dwEventId,
|
|
&argList)) != NO_ERROR)
|
|
{
|
|
TRACE1 (ANY, "DbFormatEAPOLEventVA: DbFormatEAPOLEvent failed with error %ld", dwRetCode);
|
|
break;
|
|
}
|
|
}
|
|
while (FALSE);
|
|
|
|
return dwRetCode;
|
|
};
|
|
|
|
|
|
DWORD
|
|
DbFormatEAPOLEvent (
|
|
WCHAR *pwszMessage,
|
|
DWORD dwEventId,
|
|
va_list *pargList
|
|
)
|
|
{
|
|
HMODULE hDll = NULL;
|
|
DWORD dwRetCode = NO_ERROR;
|
|
|
|
do
|
|
{
|
|
hDll = g_hInstance;
|
|
|
|
if (FormatMessage (
|
|
FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_MAX_WIDTH_MASK,
|
|
WZCGetSPResModule(),
|
|
dwEventId,
|
|
0,
|
|
pwszMessage,
|
|
MAX_WMESG_SIZE,
|
|
pargList) == 0)
|
|
{
|
|
dwRetCode = GetLastError();
|
|
TRACE1 (ANY, "DbFormatEAPOLEvent: FormatMessage failed with error %ld", dwRetCode);
|
|
break;
|
|
}
|
|
}
|
|
while (FALSE);
|
|
|
|
return dwRetCode;
|
|
};
|
|
|
|
|
|
DWORD
|
|
DbLogPCBEvent (
|
|
DWORD dwCategory,
|
|
EAPOL_PCB *pPCB,
|
|
DWORD dwEventId,
|
|
...
|
|
)
|
|
{
|
|
WCHAR wszMessage[MAX_WMESG_SIZE];
|
|
WCHAR wszContext[MAX_WMESG_SIZE];
|
|
WCHAR wszSrcAddr[3*SIZE_MAC_ADDR];
|
|
WCHAR wszDstAddr[3*SIZE_MAC_ADDR];
|
|
WCHAR wsSSID[MAX_SSID_LEN+1];
|
|
va_list argList;
|
|
WZC_DB_RECORD dbrecord;
|
|
HMODULE hDll = NULL;
|
|
DWORD dwRetCode = NO_ERROR;
|
|
|
|
do
|
|
{
|
|
BOOL bLogEnabled;
|
|
|
|
EnterCriticalSection(&g_wzcInternalCtxt.csContext);
|
|
bLogEnabled = ((g_wzcInternalCtxt.wzcContext.dwFlags & WZC_CTXT_LOGGING_ON) != 0);
|
|
LeaveCriticalSection(&g_wzcInternalCtxt.csContext);
|
|
|
|
// If the database is not opened or the logging functionality is disabled,
|
|
// do not record any thing
|
|
if (!bLogEnabled || !IsDBOpened())
|
|
break;
|
|
|
|
va_start (argList, dwEventId);
|
|
|
|
ZeroMemory ((PVOID)wszMessage, MAX_WMESG_SIZE*sizeof(WCHAR));
|
|
ZeroMemory ((PVOID)wszContext, MAX_WMESG_SIZE*sizeof(WCHAR));
|
|
ZeroMemory ((PVOID)wszSrcAddr,3*SIZE_MAC_ADDR*sizeof(WCHAR));
|
|
ZeroMemory ((PVOID)wszDstAddr,3*SIZE_MAC_ADDR*sizeof(WCHAR));
|
|
|
|
if ((dwRetCode = DbFormatEAPOLEvent (
|
|
wszMessage,
|
|
dwEventId,
|
|
&argList
|
|
)) != NO_ERROR)
|
|
{
|
|
TRACE1 (ANY, "DbLogPCBEvent: DbFormatEAPOLEvent failed with error %ld", dwRetCode);
|
|
break;
|
|
}
|
|
|
|
|
|
ZeroMemory ((PVOID)&dbrecord, sizeof(WZC_DB_RECORD));
|
|
dbrecord.componentid = DBLOG_COMPID_EAPOL;
|
|
dbrecord.category = dwCategory;
|
|
dbrecord.message.pData = (PBYTE)wszMessage;
|
|
dbrecord.message.dwDataLen = (wcslen(wszMessage) + 1)*sizeof(WCHAR);
|
|
dbrecord.localmac.pData = (PBYTE)wszSrcAddr;
|
|
dbrecord.localmac.dwDataLen = 3*SIZE_MAC_ADDR*sizeof(WCHAR);
|
|
dbrecord.remotemac.pData = (PBYTE)wszDstAddr;
|
|
dbrecord.remotemac.dwDataLen = 3*SIZE_MAC_ADDR*sizeof(WCHAR);
|
|
dbrecord.ssid.pData = NULL;
|
|
dbrecord.ssid.dwDataLen = 0;
|
|
dbrecord.context.pData = NULL;
|
|
dbrecord.context.dwDataLen = 0;
|
|
|
|
if (pPCB != NULL)
|
|
{
|
|
if ((dwRetCode = ElFormatPCBContext (
|
|
pPCB,
|
|
wszContext
|
|
)) != NO_ERROR)
|
|
{
|
|
TRACE1 (ANY, "DbLogPCBEvent: ElFormatPCBContext failed with error %ld", dwRetCode);
|
|
break;
|
|
}
|
|
dbrecord.context.pData = (CHAR *)wszContext;
|
|
dbrecord.context.dwDataLen = (wcslen(wszContext) + 1)*sizeof(WCHAR);
|
|
MACADDR_BYTE_TO_WSTR(pPCB->bSrcMacAddr, wszSrcAddr);
|
|
MACADDR_BYTE_TO_WSTR(pPCB->bDestMacAddr, wszDstAddr);
|
|
|
|
// Append the network-name / SSID
|
|
if (pPCB->pSSID != NULL)
|
|
{
|
|
ZeroMemory ((PVOID)wsSSID, (MAX_SSID_LEN+1)*sizeof(WCHAR));
|
|
if (0 == MultiByteToWideChar (
|
|
CP_ACP,
|
|
0,
|
|
pPCB->pSSID->Ssid,
|
|
pPCB->pSSID->SsidLength,
|
|
wsSSID,
|
|
MAX_SSID_LEN+1))
|
|
{
|
|
dwRetCode = GetLastError();
|
|
TRACE1 (ANY, "DbLogPCBEvent: MultiByteToWideChar failed with error %ld",
|
|
dwRetCode);
|
|
break;
|
|
}
|
|
dbrecord.ssid.pData = (PBYTE)wsSSID;
|
|
dbrecord.ssid.dwDataLen = (pPCB->pSSID->SsidLength+1)*sizeof(WCHAR);
|
|
}
|
|
}
|
|
|
|
// Create a new record
|
|
if ((dwRetCode = AddWZCDbLogRecord(NULL, 0, &dbrecord, NULL)) != NO_ERROR)
|
|
{
|
|
TRACE1 (ANY, "DbLogPCBEvent: AppMonAppendRecord failed with error %ld",
|
|
dwRetCode);
|
|
}
|
|
}
|
|
while (FALSE);
|
|
|
|
if (hDll != NULL)
|
|
{
|
|
FreeLibrary(hDll);
|
|
}
|
|
|
|
return dwRetCode;
|
|
}
|
|
|
|
|
|
//
|
|
// ElParsePacket
|
|
//
|
|
// Description:
|
|
//
|
|
// Function called to parse an ethernet 802.1X packet
|
|
//
|
|
// Arguments:
|
|
// pbPkt - pointer to packet
|
|
// dwLength - packet length
|
|
// fReceived - Y=>Received packet, N=>Sending packet
|
|
//
|
|
// Return Values:
|
|
//
|
|
|
|
DWORD
|
|
ElParsePacket (
|
|
IN PBYTE pbPkt,
|
|
IN DWORD dwLength,
|
|
IN BOOLEAN fReceived
|
|
)
|
|
{
|
|
EAPOL_BUFFER *pEapolBuffer = NULL;
|
|
ETH_HEADER *pEthHdr = NULL;
|
|
EAPOL_PACKET *pEapolPkt = NULL;
|
|
PPP_EAP_PACKET *pEapPkt = NULL;
|
|
BYTE *pBuffer = NULL;
|
|
BOOLEAN ReqId = FALSE; // EAPOL state machine local variables
|
|
DWORD i, j;
|
|
WCHAR wszSrcAddr[3*SIZE_MAC_ADDR];
|
|
WCHAR wszDstAddr[3*SIZE_MAC_ADDR];
|
|
DWORD dwRetCode = NO_ERROR;
|
|
|
|
pBuffer = (BYTE *)pbPkt;
|
|
|
|
do
|
|
{
|
|
// Validate packet length
|
|
// Should be atleast ETH_HEADER and first 4 required bytes of
|
|
// EAPOL_PACKET
|
|
if (dwLength < (sizeof(ETH_HEADER) + 4))
|
|
{
|
|
break;
|
|
}
|
|
|
|
// If the source address is same as the local MAC address, it is a
|
|
// multicast packet copy sent out being received
|
|
pEthHdr = (ETH_HEADER *)pBuffer;
|
|
|
|
|
|
ZeroMemory (wszSrcAddr,3*SIZE_MAC_ADDR*sizeof(WCHAR));
|
|
ZeroMemory (wszDstAddr,3*SIZE_MAC_ADDR*sizeof(WCHAR));
|
|
|
|
MACADDR_BYTE_TO_WSTR (pEthHdr->bSrcAddr, wszSrcAddr);
|
|
MACADDR_BYTE_TO_WSTR (pEthHdr->bDstAddr, wszDstAddr);
|
|
|
|
// Verify if the packet contains a 802.1P tag. If so, skip the 4 bytes
|
|
// after the src+dest mac addresses
|
|
|
|
if ((WireToHostFormat16(pBuffer + sizeof(ETH_HEADER)) == EAPOL_8021P_TAG_TYPE))
|
|
{
|
|
pEapolPkt = (EAPOL_PACKET *)(pBuffer + sizeof(ETH_HEADER) + 4);
|
|
}
|
|
else
|
|
{
|
|
pEapolPkt = (EAPOL_PACKET *)(pBuffer + sizeof(ETH_HEADER));
|
|
}
|
|
|
|
// EAPOL packet type should be valid
|
|
if ((pEapolPkt->PacketType != EAP_Packet) &&
|
|
(pEapolPkt->PacketType != EAPOL_Start) &&
|
|
(pEapolPkt->PacketType != EAPOL_Logoff) &&
|
|
(pEapolPkt->PacketType != EAPOL_Key))
|
|
{
|
|
break;
|
|
}
|
|
|
|
// Determine the value of local EAPOL state variables
|
|
if (pEapolPkt->PacketType == EAP_Packet)
|
|
{
|
|
// Validate length of packet for EAP
|
|
// Should be atleast (ETH_HEADER+EAPOL_PACKET)
|
|
if (dwLength < (sizeof (ETH_HEADER) + sizeof (EAPOL_PACKET)))
|
|
{
|
|
TRACE1 (EAPOL, "ProcessReceivedPacket: Invalid length of EAP packet %d. Ignoring packet",
|
|
dwLength);
|
|
dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
|
|
break;
|
|
}
|
|
|
|
pEapPkt = (PPP_EAP_PACKET *)pEapolPkt->PacketBody;
|
|
|
|
if ((pEapPkt->Code == EAPCODE_Request) ||
|
|
(pEapPkt->Code == EAPCODE_Response))
|
|
{
|
|
// Validate length of packet for EAP-Request packet
|
|
// Should be atleast (ETH_HEADER+EAPOL_PACKET-1+PPP_EAP_PACKET)
|
|
if (dwLength < (sizeof (ETH_HEADER) + sizeof(EAPOL_PACKET)-1
|
|
+ sizeof (PPP_EAP_PACKET)))
|
|
{
|
|
dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
|
|
break;
|
|
}
|
|
if (pEapPkt->Data[0] == EAPTYPE_Identity)
|
|
{
|
|
ReqId = TRUE;
|
|
}
|
|
}
|
|
else if ((pEapPkt->Code == EAPCODE_Success) ||
|
|
(pEapPkt->Code == EAPCODE_Failure))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
// Invalid type
|
|
dwRetCode = ERROR_INVALID_PACKET;
|
|
break;
|
|
}
|
|
|
|
DbLogPCBEvent (
|
|
DBLOG_CATEG_PACKET,
|
|
NULL,
|
|
EAPOL_PROCESS_PACKET_EAPOL_EAP,
|
|
fReceived?L"Received":L"Sent",
|
|
wszDstAddr,
|
|
wszSrcAddr,
|
|
EAPOLPacketTypes[pEapolPkt->PacketType],
|
|
WireToHostFormat16(pEapolPkt->PacketBodyLength),
|
|
EAPOLEAPPacketTypes[(DWORD)pEapPkt->Code],
|
|
pEapPkt->Id,
|
|
WireToHostFormat16(pEapPkt->Length),
|
|
ReqId?L"[Identity]":L""
|
|
);
|
|
}
|
|
else
|
|
{
|
|
DbLogPCBEvent (
|
|
DBLOG_CATEG_PACKET,
|
|
NULL,
|
|
EAPOL_PROCESS_PACKET_EAPOL,
|
|
fReceived?L"Received":L"Sent",
|
|
wszDstAddr,
|
|
wszSrcAddr,
|
|
EAPOLPacketTypes[pEapolPkt->PacketType]
|
|
);
|
|
}
|
|
}
|
|
while (FALSE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//
|
|
// ElFormatPCBContext
|
|
//
|
|
// Description:
|
|
//
|
|
// Function called to format PCB context details
|
|
//
|
|
// Arguments:
|
|
// pPCB - Pointer to PCB
|
|
// pwszContext - Context buffer
|
|
//
|
|
// Return Values:
|
|
//
|
|
|
|
DWORD
|
|
ElFormatPCBContext (
|
|
IN EAPOL_PCB *pPCB,
|
|
IN OUT WCHAR *pwszContext
|
|
)
|
|
{
|
|
DWORD i, j;
|
|
DWORD dwRetCode = NO_ERROR;
|
|
|
|
do
|
|
{
|
|
if ((dwRetCode = DbFormatEAPOLEventVA (
|
|
pwszContext,
|
|
EAPOL_STATE_DETAILS,
|
|
pPCB->pszIdentity?pPCB->pszIdentity:NULL,
|
|
EAPOLStates[((pPCB->State < EAPOLSTATE_LOGOFF) || (pPCB->State > EAPOLSTATE_AUTHENTICATED))?EAPOLSTATE_UNDEFINED:pPCB->State],
|
|
EAPOLAuthTypes[pPCB->PreviousAuthenticationType],
|
|
pPCB->dwEAPOLAuthMode,
|
|
pPCB->dwEapTypeToBeUsed,
|
|
pPCB->dwAuthFailCount)) != NO_ERROR)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
while (FALSE);
|
|
|
|
return dwRetCode;
|
|
}
|
|
|
|
|
|
//
|
|
// fFileTimeToStr
|
|
//
|
|
// Description:
|
|
//
|
|
// Converts FileTime to a printable form in *ppwszTime. If the function returns
|
|
// TRUE, the caller must ultimately call LocalFree(*ppwszTime).
|
|
//
|
|
// Arguments:
|
|
// pPCB - Pointer to PCB
|
|
//
|
|
// Return Values:
|
|
// TRUE: Success
|
|
// FALSE: Failure
|
|
|
|
BOOL
|
|
fFileTimeToStr (
|
|
IN FILETIME FileTime,
|
|
OUT WCHAR** ppwszTime
|
|
)
|
|
{
|
|
SYSTEMTIME SystemTime;
|
|
FILETIME LocalTime;
|
|
int nBytesDate;
|
|
int nBytesTime;
|
|
WCHAR* pwszTemp = NULL;
|
|
BOOL fRet = FALSE;
|
|
|
|
RTASSERT(NULL != ppwszTime);
|
|
|
|
if (!FileTimeToLocalFileTime(&FileTime, &LocalTime))
|
|
{
|
|
EapolTrace ("FileTimeToLocalFileTime(%d %d) failed and returned %d",
|
|
FileTime.dwLowDateTime, FileTime.dwHighDateTime,
|
|
GetLastError());
|
|
|
|
goto LDone;
|
|
}
|
|
|
|
if (!FileTimeToSystemTime(&LocalTime, &SystemTime))
|
|
{
|
|
EapolTrace ("FileTimeToSystemTime(%d %d) failed and returned %d",
|
|
LocalTime.dwLowDateTime, LocalTime.dwHighDateTime,
|
|
GetLastError());
|
|
|
|
goto LDone;
|
|
}
|
|
|
|
nBytesDate = GetDateFormat(LOCALE_USER_DEFAULT, 0, &SystemTime, NULL,
|
|
NULL, 0);
|
|
|
|
if (0 == nBytesDate)
|
|
{
|
|
EapolTrace ("GetDateFormat(%d %d %d %d %d %d %d %d) failed and "
|
|
"returned %d",
|
|
SystemTime.wYear, SystemTime.wMonth, SystemTime.wDayOfWeek,
|
|
SystemTime.wDay, SystemTime.wHour, SystemTime.wMinute,
|
|
SystemTime.wSecond, SystemTime.wMilliseconds,
|
|
GetLastError());
|
|
|
|
goto LDone;
|
|
}
|
|
|
|
nBytesTime = GetTimeFormat(LOCALE_USER_DEFAULT, 0, &SystemTime, NULL,
|
|
NULL, 0);
|
|
|
|
if (0 == nBytesTime)
|
|
{
|
|
EapolTrace ("GetTimeFormat(%d %d %d %d %d %d %d %d) failed and "
|
|
"returned %d",
|
|
SystemTime.wYear, SystemTime.wMonth, SystemTime.wDayOfWeek,
|
|
SystemTime.wDay, SystemTime.wHour, SystemTime.wMinute,
|
|
SystemTime.wSecond, SystemTime.wMilliseconds,
|
|
GetLastError());
|
|
|
|
goto LDone;
|
|
}
|
|
|
|
pwszTemp = LocalAlloc(LPTR, (nBytesDate + nBytesTime)*sizeof(WCHAR));
|
|
|
|
if (NULL == pwszTemp)
|
|
{
|
|
EapolTrace ("LocalAlloc failed and returned %d", GetLastError());
|
|
goto LDone;
|
|
}
|
|
|
|
if (0 == GetDateFormat(LOCALE_USER_DEFAULT, 0, &SystemTime, NULL,
|
|
pwszTemp, nBytesDate))
|
|
{
|
|
EapolTrace ("GetDateFormat(%d %d %d %d %d %d %d %d) failed and "
|
|
"returned %d",
|
|
SystemTime.wYear, SystemTime.wMonth, SystemTime.wDayOfWeek,
|
|
SystemTime.wDay, SystemTime.wHour, SystemTime.wMinute,
|
|
SystemTime.wSecond, SystemTime.wMilliseconds,
|
|
GetLastError());
|
|
|
|
goto LDone;
|
|
}
|
|
|
|
pwszTemp[nBytesDate - 1] = L' ';
|
|
|
|
if (0 == GetTimeFormat(LOCALE_USER_DEFAULT, 0, &SystemTime, NULL,
|
|
pwszTemp + nBytesDate, nBytesTime))
|
|
{
|
|
EapolTrace ("GetTimeFormat(%d %d %d %d %d %d %d %d) failed and "
|
|
"returned %d",
|
|
SystemTime.wYear, SystemTime.wMonth, SystemTime.wDayOfWeek,
|
|
SystemTime.wDay, SystemTime.wHour, SystemTime.wMinute,
|
|
SystemTime.wSecond, SystemTime.wMilliseconds,
|
|
GetLastError());
|
|
|
|
goto LDone;
|
|
}
|
|
|
|
*ppwszTime = pwszTemp;
|
|
pwszTemp = NULL;
|
|
fRet = TRUE;
|
|
|
|
LDone:
|
|
|
|
LocalFree(pwszTemp);
|
|
return(fRet);
|
|
}
|
|
|
|
|
|
//
|
|
// fByteToStr
|
|
//
|
|
// Description:
|
|
//
|
|
// Converts Byte stream to a printable form in *ppwszTime.
|
|
// If the function returns TRUE, the caller must ultimately call
|
|
// LocalFree(*ppwszStr).
|
|
//
|
|
// Arguments:
|
|
// pPCB - Pointer to PCB
|
|
//
|
|
// Return Values:
|
|
// TRUE: Success
|
|
// FALSE: Failure
|
|
|
|
BOOL
|
|
fByteToStr (
|
|
IN DWORD dwSizeOfData,
|
|
IN PBYTE pbData,
|
|
OUT WCHAR** ppwszStr
|
|
)
|
|
{
|
|
PWCHAR pwszTemp = NULL;
|
|
DWORD i = 0, j = 0;
|
|
BOOLEAN fResult = FALSE;
|
|
|
|
do
|
|
{
|
|
if ((pwszTemp = LocalAlloc (LPTR, (dwSizeOfData*2 + 1)*sizeof(WCHAR)))
|
|
== NULL)
|
|
break;
|
|
for (i=0; i<dwSizeOfData; i++)
|
|
{
|
|
BYTE nHex;
|
|
nHex = (pbData[i] & 0xf0) >> 4;
|
|
pwszTemp[j++] = HEX2WCHAR(nHex);
|
|
nHex = (pbData[i] & 0x0f);
|
|
pwszTemp[j++] = HEX2WCHAR(nHex);
|
|
}
|
|
pwszTemp[j] = L'\0';
|
|
*ppwszStr = pwszTemp;
|
|
pwszTemp = NULL;
|
|
fResult = TRUE;
|
|
}
|
|
while (FALSE);
|
|
|
|
if (pwszTemp != NULL)
|
|
{
|
|
LocalFree (pwszTemp);
|
|
}
|
|
return fResult;
|
|
}
|
|
|
|
|
|
//
|
|
// fSerialNumberByteToStr
|
|
//
|
|
// Description:
|
|
//
|
|
// Converts Byte stream to a printable form in *ppwszTime.
|
|
// If the function returns TRUE, the caller must ultimately call
|
|
// LocalFree(*ppwszStr).
|
|
//
|
|
// Arguments:
|
|
// pPCB - Pointer to PCB
|
|
//
|
|
// Return Values:
|
|
// TRUE: Success
|
|
// FALSE: Failure
|
|
|
|
BOOL
|
|
fSerialNumberByteToStr (
|
|
IN DWORD dwSizeOfData,
|
|
IN PBYTE pbData,
|
|
OUT WCHAR** ppwszStr
|
|
)
|
|
{
|
|
PWCHAR pwszTemp = NULL;
|
|
INT i = 0, j = 0;
|
|
BOOLEAN fResult = FALSE;
|
|
|
|
do
|
|
{
|
|
if ((pwszTemp = LocalAlloc (LPTR, (dwSizeOfData*2 + 1)*sizeof(WCHAR)))
|
|
== NULL)
|
|
break;
|
|
for (i=(dwSizeOfData-1); i>=0; i--)
|
|
{
|
|
BYTE nHex;
|
|
nHex = (pbData[i] & 0xf0) >> 4;
|
|
pwszTemp[j++] = HEX2WCHAR(nHex);
|
|
nHex = (pbData[i] & 0x0f);
|
|
pwszTemp[j++] = HEX2WCHAR(nHex);
|
|
}
|
|
pwszTemp[j] = L'\0';
|
|
*ppwszStr = pwszTemp;
|
|
pwszTemp = NULL;
|
|
fResult = TRUE;
|
|
}
|
|
while (FALSE);
|
|
|
|
if (pwszTemp != NULL)
|
|
{
|
|
LocalFree (pwszTemp);
|
|
}
|
|
return fResult;
|
|
}
|
|
|
|
|
|
//
|
|
// Gets the name in the cert pointed to by pCertContext, and converts
|
|
// it to a printable form in *ppwszName. If the function returns TRUE,
|
|
// the caller must ultimately call LocalFree(*ppwszName).
|
|
//
|
|
|
|
BOOL
|
|
FUserCertToStr(
|
|
IN PCCERT_CONTEXT pCertContext,
|
|
OUT WCHAR** ppwszName
|
|
)
|
|
{
|
|
DWORD dwExtensionIndex;
|
|
DWORD dwAltEntryIndex;
|
|
CERT_EXTENSION* pCertExtension;
|
|
CERT_ALT_NAME_INFO* pCertAltNameInfo;
|
|
CERT_ALT_NAME_ENTRY* pCertAltNameEntry;
|
|
CERT_NAME_VALUE* pCertNameValue;
|
|
DWORD dwCertAltNameInfoSize;
|
|
DWORD dwCertNameValueSize;
|
|
WCHAR* pwszName = NULL;
|
|
BOOL fExitOuterFor;
|
|
BOOL fExitInnerFor;
|
|
BOOL fRet = FALSE;
|
|
|
|
// See if cert has UPN in AltSubjectName->otherName
|
|
|
|
fExitOuterFor = FALSE;
|
|
|
|
for (dwExtensionIndex = 0;
|
|
dwExtensionIndex < pCertContext->pCertInfo->cExtension;
|
|
dwExtensionIndex++)
|
|
{
|
|
pCertAltNameInfo = NULL;
|
|
|
|
pCertExtension = pCertContext->pCertInfo->rgExtension+dwExtensionIndex;
|
|
|
|
if (strcmp(pCertExtension->pszObjId, szOID_SUBJECT_ALT_NAME2) != 0)
|
|
{
|
|
goto LOuterForEnd;
|
|
}
|
|
|
|
dwCertAltNameInfoSize = 0;
|
|
|
|
if (!CryptDecodeObjectEx(
|
|
pCertContext->dwCertEncodingType,
|
|
X509_ALTERNATE_NAME,
|
|
pCertExtension->Value.pbData,
|
|
pCertExtension->Value.cbData,
|
|
CRYPT_DECODE_ALLOC_FLAG,
|
|
NULL,
|
|
(VOID*)&pCertAltNameInfo,
|
|
&dwCertAltNameInfoSize))
|
|
{
|
|
goto LOuterForEnd;
|
|
}
|
|
|
|
fExitInnerFor = FALSE;
|
|
|
|
for (dwAltEntryIndex = 0;
|
|
dwAltEntryIndex < pCertAltNameInfo->cAltEntry;
|
|
dwAltEntryIndex++)
|
|
{
|
|
pCertNameValue = NULL;
|
|
|
|
pCertAltNameEntry = pCertAltNameInfo->rgAltEntry + dwAltEntryIndex;
|
|
|
|
if ( (CERT_ALT_NAME_OTHER_NAME !=
|
|
pCertAltNameEntry->dwAltNameChoice)
|
|
|| (NULL == pCertAltNameEntry->pOtherName)
|
|
|| (0 != strcmp(szOID_NT_PRINCIPAL_NAME,
|
|
pCertAltNameEntry->pOtherName->pszObjId)))
|
|
{
|
|
goto LInnerForEnd;
|
|
}
|
|
|
|
// We found a UPN!
|
|
|
|
dwCertNameValueSize = 0;
|
|
|
|
if (!CryptDecodeObjectEx(
|
|
pCertContext->dwCertEncodingType,
|
|
X509_UNICODE_ANY_STRING,
|
|
pCertAltNameEntry->pOtherName->Value.pbData,
|
|
pCertAltNameEntry->pOtherName->Value.cbData,
|
|
CRYPT_DECODE_ALLOC_FLAG,
|
|
NULL,
|
|
(VOID*)&pCertNameValue,
|
|
&dwCertNameValueSize))
|
|
{
|
|
goto LInnerForEnd;
|
|
}
|
|
|
|
// One extra char for the terminating NULL.
|
|
|
|
pwszName = LocalAlloc(LPTR, pCertNameValue->Value.cbData +
|
|
sizeof(WCHAR));
|
|
|
|
if (NULL == pwszName)
|
|
{
|
|
EapolTrace ("LocalAlloc failed and returned %d",
|
|
GetLastError());
|
|
|
|
fExitInnerFor = TRUE;
|
|
fExitOuterFor = TRUE;
|
|
|
|
goto LInnerForEnd;
|
|
}
|
|
|
|
CopyMemory(pwszName, pCertNameValue->Value.pbData,
|
|
pCertNameValue->Value.cbData);
|
|
|
|
*ppwszName = pwszName;
|
|
pwszName = NULL;
|
|
fRet = TRUE;
|
|
|
|
fExitInnerFor = TRUE;
|
|
fExitOuterFor = TRUE;
|
|
|
|
LInnerForEnd:
|
|
|
|
LocalFree(pCertNameValue);
|
|
|
|
if (fExitInnerFor)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
LOuterForEnd:
|
|
|
|
LocalFree(pCertAltNameInfo);
|
|
|
|
if (fExitOuterFor)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
LocalFree(pwszName);
|
|
return(fRet);
|
|
}
|
|
|
|
|
|
//
|
|
// Special function for getting the DNS machine name from the
|
|
// machine auth certificate
|
|
//
|
|
|
|
BOOL
|
|
FMachineAuthCertToStr
|
|
(
|
|
IN PCCERT_CONTEXT pCertContext,
|
|
OUT WCHAR ** ppwszName
|
|
)
|
|
{
|
|
|
|
DWORD dwExtensionIndex;
|
|
DWORD dwAltEntryIndex;
|
|
CERT_EXTENSION* pCertExtension;
|
|
CERT_ALT_NAME_INFO* pCertAltNameInfo;
|
|
CERT_ALT_NAME_ENTRY* pCertAltNameEntry;
|
|
DWORD dwCertAltNameInfoSize;
|
|
WCHAR* pwszName = NULL;
|
|
BOOL fExitOuterFor;
|
|
BOOL fExitInnerFor;
|
|
BOOL fRet = FALSE;
|
|
|
|
// See if cert has UPN in AltSubjectName->otherName
|
|
|
|
fExitOuterFor = FALSE;
|
|
|
|
for (dwExtensionIndex = 0;
|
|
dwExtensionIndex < pCertContext->pCertInfo->cExtension;
|
|
dwExtensionIndex++)
|
|
{
|
|
pCertAltNameInfo = NULL;
|
|
|
|
pCertExtension = pCertContext->pCertInfo->rgExtension+dwExtensionIndex;
|
|
|
|
if (strcmp(pCertExtension->pszObjId, szOID_SUBJECT_ALT_NAME2) != 0)
|
|
{
|
|
goto LOuterForEnd;
|
|
}
|
|
|
|
dwCertAltNameInfoSize = 0;
|
|
|
|
if (!CryptDecodeObjectEx(
|
|
pCertContext->dwCertEncodingType,
|
|
X509_ALTERNATE_NAME,
|
|
pCertExtension->Value.pbData,
|
|
pCertExtension->Value.cbData,
|
|
CRYPT_DECODE_ALLOC_FLAG,
|
|
NULL,
|
|
(VOID*)&pCertAltNameInfo,
|
|
&dwCertAltNameInfoSize))
|
|
{
|
|
goto LOuterForEnd;
|
|
}
|
|
|
|
fExitInnerFor = FALSE;
|
|
|
|
for (dwAltEntryIndex = 0;
|
|
dwAltEntryIndex < pCertAltNameInfo->cAltEntry;
|
|
dwAltEntryIndex++)
|
|
{
|
|
pCertAltNameEntry = pCertAltNameInfo->rgAltEntry + dwAltEntryIndex;
|
|
|
|
if ( (CERT_ALT_NAME_DNS_NAME !=
|
|
pCertAltNameEntry->dwAltNameChoice)
|
|
|| (NULL == pCertAltNameEntry->pwszDNSName)
|
|
)
|
|
{
|
|
goto LInnerForEnd;
|
|
}
|
|
|
|
// We found the DNS Name!
|
|
|
|
|
|
// One extra char for the terminating NULL.
|
|
|
|
pwszName = LocalAlloc(LPTR, wcslen( pCertAltNameEntry->pwszDNSName ) * sizeof(WCHAR) +
|
|
sizeof(WCHAR));
|
|
|
|
if (NULL == pwszName)
|
|
{
|
|
EapolTrace ("LocalAlloc failed and returned %d",
|
|
GetLastError());
|
|
|
|
fExitInnerFor = TRUE;
|
|
fExitOuterFor = TRUE;
|
|
|
|
goto LInnerForEnd;
|
|
}
|
|
|
|
wcscpy (pwszName, pCertAltNameEntry->pwszDNSName );
|
|
|
|
*ppwszName = pwszName;
|
|
pwszName = NULL;
|
|
fRet = TRUE;
|
|
|
|
fExitInnerFor = TRUE;
|
|
fExitOuterFor = TRUE;
|
|
|
|
LInnerForEnd:
|
|
|
|
if (fExitInnerFor)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
LOuterForEnd:
|
|
|
|
LocalFree(pCertAltNameInfo);
|
|
|
|
if (fExitOuterFor)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
LocalFree(pwszName);
|
|
return(fRet);
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Gets the name in the cert pointed to by pCertContext, and converts it
|
|
// to a printable form in *ppwszName. If the function returns TRUE, the
|
|
// caller must ultimately call LocalFree(*ppwszName).
|
|
//
|
|
|
|
BOOL
|
|
FOtherCertToStr(
|
|
IN PCCERT_CONTEXT pCertContext,
|
|
IN DWORD fFlags,
|
|
OUT WCHAR** ppwszName
|
|
)
|
|
{
|
|
WCHAR* pwszTemp = NULL;
|
|
DWORD dwSize;
|
|
BOOL fRet = FALSE;
|
|
|
|
RTASSERT(NULL != ppwszName);
|
|
|
|
// Fetch Machine UPN
|
|
if (fFlags == 0)
|
|
{
|
|
if (FMachineAuthCertToStr(pCertContext, &pwszTemp))
|
|
{
|
|
*ppwszName = pwszTemp;
|
|
pwszTemp = NULL;
|
|
fRet = TRUE;
|
|
goto LDone;
|
|
}
|
|
}
|
|
|
|
dwSize = CertGetNameString(pCertContext, CERT_NAME_SIMPLE_DISPLAY_TYPE,
|
|
fFlags, NULL, NULL, 0);
|
|
|
|
// dwSize is the number of characters, including the terminating NULL.
|
|
|
|
if (dwSize <= 1)
|
|
{
|
|
EapolTrace ("CertGetNameString failed.");
|
|
goto LDone;
|
|
}
|
|
|
|
pwszTemp = LocalAlloc(LPTR, dwSize*sizeof(WCHAR));
|
|
|
|
if (NULL == pwszTemp)
|
|
{
|
|
EapolTrace ("LocalAlloc failed and returned %d", GetLastError());
|
|
goto LDone;
|
|
}
|
|
|
|
dwSize = CertGetNameString(pCertContext, CERT_NAME_SIMPLE_DISPLAY_TYPE,
|
|
fFlags, NULL, pwszTemp, dwSize);
|
|
|
|
if (dwSize <= 1)
|
|
{
|
|
EapolTrace ("CertGetNameString failed.");
|
|
goto LDone;
|
|
}
|
|
|
|
*ppwszName = pwszTemp;
|
|
pwszTemp = NULL;
|
|
fRet = TRUE;
|
|
|
|
LDone:
|
|
|
|
LocalFree(pwszTemp);
|
|
return(fRet);
|
|
}
|
|
|
|
|
|
//
|
|
// Gets the name in the cert pointed to by pCertContext, and converts it
|
|
// to a printable form in *ppwszName. If the function returns TRUE, the
|
|
// caller must ultimately call LocalFree(*ppwszName).
|
|
//
|
|
|
|
BOOL
|
|
FCertToStr(
|
|
IN PCCERT_CONTEXT pCertContext,
|
|
IN DWORD fFlags,
|
|
IN BOOL fMachineCert,
|
|
OUT WCHAR** ppwszName
|
|
)
|
|
{
|
|
if (!fMachineCert)
|
|
{
|
|
if (FUserCertToStr(pCertContext, ppwszName))
|
|
{
|
|
return(TRUE);
|
|
}
|
|
}
|
|
|
|
return(FOtherCertToStr(pCertContext, fFlags, ppwszName));
|
|
}
|
|
|
|
|
|
//
|
|
// Stores the friendly name of the cert pointed to by pCertContext in
|
|
// *ppwszName. If the function returns TRUE, the caller must ultimately
|
|
// call LocalFree(*ppwszName).
|
|
//
|
|
|
|
BOOL
|
|
FGetFriendlyName(
|
|
IN PCCERT_CONTEXT pCertContext,
|
|
OUT WCHAR** ppwszName
|
|
)
|
|
{
|
|
WCHAR* pwszName = NULL;
|
|
DWORD dwBytes;
|
|
BOOL fRet = FALSE;
|
|
|
|
RTASSERT(NULL != ppwszName);
|
|
|
|
if (!CertGetCertificateContextProperty(pCertContext,
|
|
CERT_FRIENDLY_NAME_PROP_ID, NULL, &dwBytes))
|
|
{
|
|
// If there is no Friendly Name property, don't print an error stmt.
|
|
fRet = TRUE;
|
|
goto LDone;
|
|
}
|
|
|
|
pwszName = LocalAlloc(LPTR, dwBytes);
|
|
|
|
if (NULL == pwszName)
|
|
{
|
|
EapolTrace ("LocalAlloc failed and returned %d", GetLastError());
|
|
goto LDone;
|
|
}
|
|
|
|
if (!CertGetCertificateContextProperty(pCertContext,
|
|
CERT_FRIENDLY_NAME_PROP_ID, pwszName, &dwBytes))
|
|
{
|
|
EapolTrace ("CertGetCertificateContextProperty failed and "
|
|
"returned 0x%x", GetLastError());
|
|
goto LDone;
|
|
}
|
|
|
|
*ppwszName = pwszName;
|
|
pwszName = NULL;
|
|
fRet = TRUE;
|
|
|
|
LDone:
|
|
|
|
LocalFree(pwszName);
|
|
return(fRet);
|
|
}
|
|
|
|
|
|
//
|
|
// Get EKU Usage Blob out of the certificate Context
|
|
//
|
|
|
|
BOOL FGetEKUUsage (
|
|
IN PCCERT_CONTEXT pCertContext,
|
|
IN PEAPOL_CERT_NODE pNode
|
|
)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
DWORD dwBytes = 0;
|
|
PCERT_ENHKEY_USAGE pUsage = NULL;
|
|
DWORD dwOidLength = 0;
|
|
DWORD dwIndex = 0;
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
|
|
EapolTrace ("FGetEKUUsage");
|
|
|
|
if (!CertGetEnhancedKeyUsage(pCertContext, 0, NULL, &dwBytes))
|
|
{
|
|
dwErr = GetLastError();
|
|
|
|
if (CRYPT_E_NOT_FOUND == dwErr)
|
|
{
|
|
EapolTrace ("No usage in cert");
|
|
fRet = TRUE;
|
|
goto LDone;
|
|
}
|
|
|
|
EapolTrace ("FGetEKUUsage failed and returned 0x%x", dwErr);
|
|
goto LDone;
|
|
}
|
|
|
|
pUsage = LocalAlloc(LPTR, dwBytes);
|
|
|
|
if (NULL == pUsage)
|
|
{
|
|
dwErr = GetLastError();
|
|
EapolTrace ("LocalAlloc failed and returned %d", dwErr);
|
|
goto LDone;
|
|
}
|
|
|
|
if (!CertGetEnhancedKeyUsage(pCertContext, 0, pUsage, &dwBytes))
|
|
{
|
|
dwErr = GetLastError();
|
|
EapolTrace ("FGetEKUUsage failed and returned 0x%x", dwErr);
|
|
goto LDone;
|
|
}
|
|
|
|
for (dwIndex = 0; dwIndex < pUsage->cUsageIdentifier; dwIndex++)
|
|
{
|
|
PCCRYPT_OID_INFO pInfo;
|
|
if ((pInfo = CryptFindOIDInfo (
|
|
CRYPT_OID_INFO_OID_KEY,
|
|
(void *) pUsage->rgpszUsageIdentifier[dwIndex],
|
|
0)) != NULL)
|
|
{
|
|
dwOidLength += (wcslen(pInfo->pwszName)+3)*sizeof(WCHAR);
|
|
}
|
|
}
|
|
pNode->pwszEKUUsage = LocalAlloc (LPTR, (dwOidLength+sizeof(WCHAR)));
|
|
for (dwIndex = 0; dwIndex < pUsage->cUsageIdentifier; dwIndex++)
|
|
{
|
|
PCCRYPT_OID_INFO pInfo;
|
|
if ((pInfo = CryptFindOIDInfo (
|
|
CRYPT_OID_INFO_OID_KEY,
|
|
(void *) pUsage->rgpszUsageIdentifier[dwIndex],
|
|
0)) != NULL)
|
|
{
|
|
EapolTrace ("EKU: %ws", pInfo->pwszName);
|
|
if (dwIndex != 0)
|
|
wcscat (pNode->pwszEKUUsage, L", ");
|
|
wcscat (pNode->pwszEKUUsage, pInfo->pwszName);
|
|
}
|
|
}
|
|
EapolTrace ("EKUUsage: %ws", pNode->pwszEKUUsage);
|
|
|
|
fRet = TRUE;
|
|
LDone:
|
|
if (pUsage != NULL)
|
|
{
|
|
LocalFree (pUsage);
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
|
|
//
|
|
// ElLogCertificateDetails
|
|
//
|
|
// Description:
|
|
//
|
|
// Function called to display certificate contents
|
|
//
|
|
// Arguments:
|
|
// pPCB - Pointer to PCB
|
|
//
|
|
// Return Values:
|
|
//
|
|
|
|
DWORD
|
|
ElLogCertificateDetails (
|
|
IN EAPOL_PCB *pPCB
|
|
)
|
|
{
|
|
EAPTLS_USER_PROPERTIES *pUserProp = NULL;
|
|
HCERTSTORE hCertStore = NULL;
|
|
PCCERT_CONTEXT pCert = NULL;
|
|
CRYPT_HASH_BLOB HashBlob;
|
|
DWORD dwVersion = 0;
|
|
EAPOL_CERT_NODE *pNode = NULL;
|
|
BYTE rgbHash[MAX_HASH_LEN];
|
|
DWORD cbHash = MAX_HASH_LEN;
|
|
BOOLEAN fRevertToSelf = FALSE;
|
|
PCERT_ENHKEY_USAGE pUsageInternal = NULL;
|
|
DWORD dwRetCode = NO_ERROR;
|
|
|
|
do
|
|
{
|
|
if (pPCB->pCustomAuthUserData == NULL)
|
|
{
|
|
EapolTrace ("Cannot log Cert detail, since NULL user properties");
|
|
break;
|
|
}
|
|
|
|
pUserProp = (EAPTLS_USER_PROPERTIES *)pPCB->pCustomAuthUserData->pbCustomAuthData;
|
|
|
|
if (pPCB->hUserToken)
|
|
{
|
|
if (!ImpersonateLoggedOnUser (pPCB->hUserToken))
|
|
{
|
|
dwRetCode = GetLastError();
|
|
EapolTrace ("ElLogCertificateDetails: ImpersonateLoggedOnUser failed with error %ld",
|
|
dwRetCode);
|
|
break;
|
|
}
|
|
fRevertToSelf = TRUE;
|
|
}
|
|
|
|
hCertStore = CertOpenStore (
|
|
CERT_STORE_PROV_SYSTEM,
|
|
0,
|
|
0,
|
|
CERT_STORE_READONLY_FLAG |
|
|
((pPCB->PreviousAuthenticationType == EAPOL_MACHINE_AUTHENTICATION)? CERT_SYSTEM_STORE_LOCAL_MACHINE : CERT_SYSTEM_STORE_CURRENT_USER),
|
|
L"MY"
|
|
);
|
|
if (hCertStore == NULL)
|
|
{
|
|
dwRetCode = GetLastError();
|
|
EapolTrace ("CertOpenStore failed with error %ld", dwRetCode);
|
|
break;
|
|
}
|
|
|
|
HashBlob.cbData = pUserProp->Hash.cbHash;
|
|
HashBlob.pbData = pUserProp->Hash.pbHash;
|
|
pCert = CertFindCertificateInStore (
|
|
hCertStore,
|
|
X509_ASN_ENCODING,
|
|
0,
|
|
CERT_FIND_HASH,
|
|
&HashBlob,
|
|
NULL
|
|
);
|
|
if (pCert == NULL)
|
|
{
|
|
dwRetCode = GetLastError();
|
|
EapolTrace ("CertFindCertificateInStore failed with error %ld",
|
|
dwRetCode);
|
|
break;
|
|
}
|
|
|
|
if (fRevertToSelf)
|
|
{
|
|
fRevertToSelf = FALSE;
|
|
if (!RevertToSelf())
|
|
{
|
|
dwRetCode = GetLastError();
|
|
EapolTrace ("ElLogCertificateDetails: Error in RevertToSelf = %ld",
|
|
dwRetCode);
|
|
dwRetCode = ERROR_BAD_IMPERSONATION_LEVEL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pNode = LocalAlloc(LPTR, sizeof(EAPOL_CERT_NODE));
|
|
if (pNode == NULL)
|
|
{
|
|
dwRetCode = GetLastError ();
|
|
break;
|
|
}
|
|
|
|
if (!CertGetCertificateContextProperty (
|
|
pCert,
|
|
CERT_SHA1_HASH_PROP_ID,
|
|
rgbHash,
|
|
&cbHash
|
|
))
|
|
{
|
|
dwRetCode = GetLastError();
|
|
EapolTrace ("CertGetCertificateContextProperty failed with error %ld");
|
|
break;
|
|
}
|
|
if ((!fByteToStr (sizeof(DWORD), (PBYTE)&(pCert->pCertInfo->dwVersion),
|
|
&(pNode->pwszVersion))) ||
|
|
(!fSerialNumberByteToStr (pCert->pCertInfo->SerialNumber.cbData,
|
|
pCert->pCertInfo->SerialNumber.pbData,
|
|
&(pNode->pwszSerialNumber))) ||
|
|
(!fFileTimeToStr (pCert->pCertInfo->NotAfter,
|
|
&(pNode->pwszValidTo))) ||
|
|
(!fFileTimeToStr (pCert->pCertInfo->NotBefore,
|
|
&(pNode->pwszValidFrom))) ||
|
|
(!fByteToStr (cbHash, rgbHash, &(pNode->pwszThumbprint))) ||
|
|
(!FCertToStr (pCert, 0, ((pPCB->PreviousAuthenticationType == EAPOL_MACHINE_AUTHENTICATION)? TRUE: FALSE), &(pNode->pwszDisplayName))) ||
|
|
(!FCertToStr (pCert, CERT_NAME_ISSUER_FLAG, TRUE, &(pNode->pwszIssuer))) ||
|
|
(!FGetFriendlyName(pCert, &(pNode->pwszFriendlyName)))
|
|
|| (!FGetEKUUsage (pCert, pNode)))
|
|
{
|
|
EapolTrace ("ElLogCertificateDetails: An internal string convert function failed");
|
|
// break;
|
|
}
|
|
|
|
DbLogPCBEvent (
|
|
DBLOG_CATEG_INFO,
|
|
pPCB,
|
|
EAPOL_CERTIFICATE_DETAILS,
|
|
EAPOLAuthTypes[pPCB->PreviousAuthenticationType],
|
|
pNode->pwszVersion,
|
|
pNode->pwszSerialNumber,
|
|
pNode->pwszIssuer,
|
|
pNode->pwszFriendlyName,
|
|
pNode->pwszDisplayName,
|
|
pNode->pwszEKUUsage,
|
|
pNode->pwszValidFrom,
|
|
pNode->pwszValidTo,
|
|
pNode->pwszThumbprint
|
|
);
|
|
}
|
|
while (FALSE);
|
|
|
|
if (pCert)
|
|
CertFreeCertificateContext (pCert);
|
|
if (hCertStore)
|
|
CertCloseStore (hCertStore, 0);
|
|
if (fRevertToSelf)
|
|
{
|
|
if (!RevertToSelf())
|
|
{
|
|
dwRetCode = GetLastError();
|
|
EapolTrace ("ElLogCertificateDetails: Error in RevertToSelf = %ld",
|
|
dwRetCode);
|
|
dwRetCode = ERROR_BAD_IMPERSONATION_LEVEL;
|
|
fRevertToSelf = FALSE;
|
|
}
|
|
}
|
|
if (pNode)
|
|
{
|
|
LocalFree(pNode->pwszVersion);
|
|
LocalFree(pNode->pwszSerialNumber);
|
|
LocalFree(pNode->pwszIssuer);
|
|
LocalFree(pNode->pwszFriendlyName);
|
|
LocalFree(pNode->pwszDisplayName);
|
|
LocalFree(pNode->pwszEKUUsage);
|
|
LocalFree(pNode->pwszValidFrom);
|
|
LocalFree(pNode->pwszValidTo);
|
|
LocalFree(pNode->pwszThumbprint);
|
|
|
|
LocalFree(pNode);
|
|
}
|
|
|
|
return dwRetCode;
|
|
}
|
|
|
|
|
|
//
|
|
// General tracing function
|
|
//
|
|
|
|
VOID
|
|
EapolTrace(
|
|
IN CHAR* Format,
|
|
...
|
|
)
|
|
{
|
|
va_list arglist;
|
|
|
|
va_start(arglist, Format);
|
|
|
|
if (TRACEID != INVALID_TRACEID)
|
|
TraceVprintfExA(TRACEID,
|
|
((DWORD)0xFFFF0000 | TRACE_USE_MASK),
|
|
Format,
|
|
arglist);
|
|
va_end(arglist);
|
|
}
|
|
|