/*++
Copyright (c) 1999, Microsoft Corporation
Module Name:
elprotocol.c
Abstract:
This module implements functions related to EAPOL
protocol
Revision History:
sachins, Apr 30 2000, Created
--*/
#include "pcheapol.h"
#pragma hdrstop
#define EAPOL_SERVICE
#ifndef EAPOL_SERVICE
HRESULT
EAPOLMANAuthenticationStarted (
REFGUID InterfaceId
);
HRESULT
EAPOLMANAuthenticationSucceeded (
REFGUID InterfaceId
);
HRESULT
EAPOLMANAuthenticationFailed (
REFGUID InterfaceId,
DWORD dwType
);
HRESULT EAPOLMANNotification(
REFGUID InterfaceId,
LPWSTR szwNotificationMessage,
DWORD dwType
);
#endif
//
// ElProcessReceivedPacket
//
// Description:
//
// Function called to process data received from the NDISUIO driver.
// The EAPOL packet is extracted and further processing is done.
//
//
// Arguments:
// pvContext - Context buffer which is a pointer to EAPOL_BUFFER structure
//
// Return Values:
//
VOID
ElProcessReceivedPacket (
IN PVOID pvContext
)
{
EAPOL_PCB *pPCB = NULL;
EAPOL_BUFFER *pEapolBuffer = NULL;
DWORD dwLength = 0;
ETH_HEADER *pEthHdr = NULL;
EAPOL_PACKET *pEapolPkt = NULL;
EAPOL_PACKET_D8 *pEapolPktD8 = NULL;
BOOLEAN fRemoteEnd8021XD8 = FALSE;
PPP_EAP_PACKET *pEapPkt = NULL;
BYTE *pBuffer;
BOOLEAN ReqId = FALSE; // EAPOL state machine local variables
BOOLEAN ReqAuth = FALSE;
BOOLEAN EapSuccess = FALSE;
BOOLEAN EapFail = FALSE;
BOOLEAN RxKey = FALSE;
GUID DeviceGuid;
EAPOL_PACKET_D8_D7 DummyHeader;
DWORD dwRetCode = NO_ERROR;
if (pvContext == NULL)
{
TRACE0 (EAPOL, "ProcessReceivedPacket: Critical error, Context is NULL");
return;
}
pEapolBuffer = (EAPOL_BUFFER *)pvContext;
pPCB = (EAPOL_PCB *)pEapolBuffer->pvContext;
dwLength = pEapolBuffer->dwBytesTransferred;
pBuffer = (BYTE *)pEapolBuffer->pBuffer;
TRACE1 (EAPOL, "ProcessReceivedPacket entered, length = %ld", dwLength);
do
{
// The Port was verified to be active before the workitem
// was queued. But do a double-check
ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
if (!EAPOL_PORT_ACTIVE(pPCB))
{
TRACE1 (EAPOL, "ProcessReceivedPacket: Port %s not active",
pPCB->pszDeviceGUID);
RELEASE_WRITE_LOCK (&(pPCB->rwLock));
FREE (pEapolBuffer);
break;
}
RELEASE_WRITE_LOCK (&(pPCB->rwLock));
// Validate packet length
// Should be atleast ETH_HEADER and first 4 required bytes of
// EAPOL_PACKET
if (dwLength < (sizeof(ETH_HEADER) + 4))
{
TRACE2 (EAPOL, "ProcessReceivedPacket: Packet length %ld is less than minimum required %d. Ignoring packet",
dwLength, (sizeof(ETH_HEADER) + 4));
FREE (pEapolBuffer);
dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
break;
}
// Validate Destination MAC Address
// Compare with MAC address got during MEDIA_CONNECT
#if 0
pEthHdr = (ETH_HEADER *)pBuffer;
if ((memcmp ((BYTE *)pEthHdr->bSrcAddr,
(BYTE *)pPCB->bDestMacAddr,
SIZE_MAC_ADDR)) != 0)
{
TRACE2 (EAPOL, "ProcessReceivedPacket: Dest MAC address %s does not match PAE address %s. Ignoring packet",
pEthHdr->SrcAddr,
pPCB->bDestMacAddr);
FREE (pEapolBuffer);
dwRetCode = ERROR_INVALID_ADDRESS;
break;
}
#endif
// 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));
}
// Validate Ethernet type in the incoming packet
// It should be the same as the one defined for the
// current port
if (memcmp ((BYTE *)pEapolPkt->EthernetType, (BYTE *)pPCB->bEtherType,
SIZE_ETHERNET_TYPE) != 0)
{
TRACE2 (EAPOL, "ProcessReceivedPacket: Packet PAE type %s does not match expected type %s. Ignoring packet",
pEapolPkt->EthernetType,
pPCB->bEtherType);
FREE (pEapolBuffer);
dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
break;
}
// EAPOL packet type should be valid
if ((pEapolPkt->PacketType != EAP_Packet) &&
(pEapolPkt->PacketType != EAPOL_Start) &&
(pEapolPkt->PacketType != EAPOL_Logoff) &&
(pEapolPkt->PacketType != EAPOL_Key))
{
TRACE1 (EAPOL, "ProcessReceivedPacket: Invalid EAPOL packet type %d. Ignoring packet",
pEapolPkt->PacketType);
FREE (pEapolBuffer);
dwRetCode = ERROR_INVALID_PACKET;
break;
}
// Determine the value of local EAPOL state variables
if (pEapolPkt->PacketType == EAP_Packet)
{
TRACE0 (EAPOL, "ProcessReceivedPacket: 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);
FREE (pEapolBuffer);
dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
break;
}
// Determine if the packet is draft 8 or not
pEapolPktD8 = (EAPOL_PACKET_D8 *)pEapolPkt;
pEapPkt = (PPP_EAP_PACKET *)pEapolPktD8->PacketBody;
switch (WireToHostFormat16(pEapolPktD8->AuthResultCode))
{
case AUTH_Continuing:
if (pEapPkt->Code == EAPCODE_Request)
{
fRemoteEnd8021XD8 = TRUE;
}
break;
case AUTH_Authorized:
if (pEapPkt->Code == EAPCODE_Success)
{
fRemoteEnd8021XD8 = TRUE;
}
break;
case AUTH_Unauthorized:
if ((pEapPkt->Code == EAPCODE_Failure) ||
(pEapPkt->Code == EAPCODE_Success))
{
fRemoteEnd8021XD8 = TRUE;
}
break;
}
if (fRemoteEnd8021XD8 && (WireToHostFormat16(pEapolPktD8->PacketBodyLength) != 0))
{
TRACE0 (EAPOL, "ProcessReceivedPacket: Packet received DRAFT 8 format");
pPCB->fRemoteEnd8021XD8 = TRUE;
memcpy (DummyHeader.AuthResultCode, pEapolPktD8->AuthResultCode,
2);
memcpy (DummyHeader.EthernetType, pEapolPktD8->EthernetType,
2);
DummyHeader.ProtocolVersion = pEapolPktD8->ProtocolVersion;
DummyHeader.PacketType = pEapolPktD8->PacketType;
memcpy ((BYTE *)pEapolPktD8, (BYTE *)&DummyHeader, 6);
pEapolPkt = (EAPOL_PACKET *)((BYTE *)pEapolPktD8 + 2);
}
else
{
pPCB->fRemoteEnd8021XD8 = FALSE;
TRACE0 (EAPOL, "ProcessReceivedPacket: Packet received PRE-DRAFT 8 format");
}
pEapPkt = (PPP_EAP_PACKET *)pEapolPkt->PacketBody;
if (pEapPkt->Code == EAPCODE_Request)
{
// 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)))
{
TRACE1 (EAPOL, "ProcessReceivedPacket: Invalid length of EAP Request packet %d. Ignoring packet",
dwLength);
FREE (pEapolBuffer);
dwRetCode = ERROR_INVALID_PACKET_LENGTH_OR_ID;
break;
}
if (pEapPkt->Data[0] == EAPTYPE_Identity)
{
pPCB->fIsRemoteEndEAPOLAware = TRUE;
ReqId = TRUE;
}
else
{
ReqAuth = TRUE;
}
}
else if (pEapPkt->Code == EAPCODE_Success)
{
EapSuccess = TRUE;
}
else if (pEapPkt->Code == EAPCODE_Failure)
{
EapFail = TRUE;
}
else
{
// Invalid type
TRACE1 (EAPOL, "ProcessReceivedPacket: Invalid EAP packet type %d. Ignoring packet",
pEapPkt->Code);
FREE (pEapolBuffer);
dwRetCode = ERROR_INVALID_PACKET;
break;
}
}
else
{
TRACE0 (EAPOL, "ProcessReceivedPacket: != EAP_Packet");
if (pEapolPkt->PacketType == EAPOL_Key)
{
TRACE0 (EAPOL, "ProcessReceivedPacket: == EAPOL_Key");
RxKey = TRUE;
// Determine if the packet is draft 8 or not
pEapolPktD8 = (EAPOL_PACKET_D8 *)pEapolPkt;
// In pre-draft 8, PacketBodyLength cannot be '0'
// If it is zero, it is draft 8 packet format
if (WireToHostFormat16(pEapolPktD8->AuthResultCode)
== AUTH_Continuing)
{
pPCB->fRemoteEnd8021XD8 = TRUE;
memcpy (DummyHeader.AuthResultCode,
pEapolPktD8->AuthResultCode,
2);
memcpy (DummyHeader.EthernetType,
pEapolPktD8->EthernetType,
2);
DummyHeader.ProtocolVersion = pEapolPktD8->ProtocolVersion;
DummyHeader.PacketType = pEapolPktD8->PacketType;
memcpy ((BYTE *)pEapolPktD8, (BYTE *)&DummyHeader, 6);
pEapolPkt = (EAPOL_PACKET *)((BYTE *)pEapolPktD8 + 2);
}
else
{
pPCB->fRemoteEnd8021XD8 = FALSE;
TRACE0 (EAPOL, "ProcessReceivedPacket: EAPOL_Key Packet received PRE-DRAFT 8 format");
}
}
}
//
// NOTE:
// Should we check values of EAP type
//
// Checking value of PCB fields now
ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
switch (pPCB->State)
{
// ReqId, ReqAuth, EapSuccess, EapFail, RxKey are inherently
// mutually exclusive
// No checks will be made to verify this
// Also, assumption is being made that in any state, maximum
// one timer may be active on the port.
case EAPOLSTATE_LOGOFF:
// Only a User Logon event can get the port out of
// LOGOFF state
TRACE0 (EAPOL, "ProcessReceivedPacket: LOGOFF state, Ignoing packet");
break;
case EAPOLSTATE_DISCONNECTED:
// Only a Media Connect event can get the port out of
// DISCONNECTED state
TRACE0 (EAPOL, "ProcessReceivedPacket: DISCONNECTED state, Ignoing packet");
break;
case EAPOLSTATE_CONNECTING:
TRACE0 (EAPOL, "ProcessReceivedPacket: EAPOLSTATE_CONNECTING");
if (ReqId | EapSuccess | EapFail)
{
// Deactivate current timer
RESTART_TIMER (pPCB->hTimer,
INFINITE_SECONDS,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
break;
}
}
if (EapSuccess)
{
if ((dwRetCode = ElProcessEapSuccess (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
else
if (EapFail)
{
if ((dwRetCode = ElProcessEapFail (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
else
if (ReqId)
{
if ((dwRetCode = FSMAcquired (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
break;
case EAPOLSTATE_ACQUIRED:
TRACE0 (EAPOL, "ProcessReceivedPacket: EAPOLSTATE_ACQUIRED");
if (ReqId | ReqAuth | EapSuccess | EapFail)
{
// Deactivate current timer
RESTART_TIMER (pPCB->hTimer,
INFINITE_SECONDS,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
break;
}
}
if (EapSuccess)
{
if ((dwRetCode = ElProcessEapSuccess (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
else
if (EapFail)
{
if ((dwRetCode = ElProcessEapFail (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
else
if (ReqId)
{
if ((dwRetCode = FSMAcquired (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
else
if (ReqAuth)
{
if ((dwRetCode = FSMAuthenticating (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
break;
case EAPOLSTATE_AUTHENTICATING:
TRACE0 (EAPOL, "ProcessReceivedPacket: EAPOLSTATE_AUTHENTICATING");
// Common timer deletion
if (ReqAuth | ReqId | EapSuccess | EapFail)
{
// Deactivate current timer
RESTART_TIMER (pPCB->hTimer,
INFINITE_SECONDS,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
break;
}
if (ReqId)
{
if ((dwRetCode = FSMAcquired (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
else
{
if ((dwRetCode = FSMAuthenticating (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
}
// Continue further processing
if (EapSuccess | EapFail)
{
// Auth timer will have restarted in FSMAuthenticating
// Deactivate the timer
RESTART_TIMER (pPCB->hTimer,
INFINITE_SECONDS,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
break;
}
// If the packet received was a EAP-Success, go into
// AUTHENTICATED state
if (EapSuccess)
{
if ((dwRetCode = ElProcessEapSuccess (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
else
// If the packet received was a EAP-Failure, go into
// HELD state
if (EapFail)
{
if ((dwRetCode = ElProcessEapFail (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
}
break;
case EAPOLSTATE_HELD:
TRACE0 (EAPOL, "ProcessReceivedPacket: HELD state, Ignoring packet");
if (ReqId)
{
// Deactivate current timer
RESTART_TIMER (pPCB->hTimer,
INFINITE_SECONDS,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
break;
}
if ((dwRetCode = FSMAcquired (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
break;
case EAPOLSTATE_AUTHENTICATED:
TRACE0 (EAPOL, "ProcessReceivedPacket: STATE_AUTHENTICATED");
if (ReqId)
{
if ((dwRetCode = FSMAcquired (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
else
if (RxKey)
{
if ((dwRetCode = FSMRxKey (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
}
break;
default:
TRACE0 (EAPOL, "ProcessReceivedPacket: Critical Error. Invalid state, Ignoring packet");
break;
}
// Only packet passing through switch statement will be freed here
FREE (pEapolBuffer);
RELEASE_WRITE_LOCK (&(pPCB->rwLock));
} while (FALSE);
// Post a new read request, ignoring errors
ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
if (!EAPOL_PORT_ACTIVE(pPCB))
{
TRACE1 (EAPOL, "ProcessReceivedPacket: Port %s not active, not reposting read request",
pPCB->pszDeviceGUID);
// Port is not active, release Context buffer
RELEASE_WRITE_LOCK (&(pPCB->rwLock));
}
else
{
TRACE1 (EAPOL, "ProcessReceivedPacket: Reposting buffer on port %s",
pPCB->pszDeviceGUID);
RELEASE_WRITE_LOCK (&(pPCB->rwLock));
// ElReadFromPort creates a new context buffer, adds a ref count,
// and posts the read request
if ((dwRetCode = ElReadFromPort (
pPCB,
NULL,
0
)) != NO_ERROR)
{
TRACE1 (EAPOL, "ProcessReceivedPacket: Critical error: ElReadFromPort error %d",
dwRetCode);
// LOG
}
}
// Dereference ref count held for the read that was just processed
EAPOL_DEREFERENCE_PORT(pPCB);
TRACE2 (EAPOL, "ProcessReceivedPacket: pPCB= %p, RefCnt = %ld",
pPCB, pPCB->dwRefCount);
TRACE0 (EAPOL, "ProcessReceivedPacket exit");
return;
}
//
// FSMDisconnected
//
// Description:
// Function called when media disconnect occurs
//
// Arguments:
// pPCB - Pointer to PCB for the port on which media disconnect occurs
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
FSMDisconnected (
IN EAPOL_PCB *pPCB
)
{
DWORD dwRetCode = NO_ERROR;
TRACE1 (EAPOL, "FSMDisconnected entered for port %s", pPCB->pszFriendlyName);
do
{
} while (FALSE);
TRACE1 (EAPOL, "Setting state DISCONNECTED for port %s", pPCB->pszFriendlyName);
pPCB->State = EAPOLSTATE_DISCONNECTED;
// Free Identity buffer
if (pPCB->pszIdentity != NULL)
{
FREE (pPCB->pszIdentity);
pPCB->pszIdentity = NULL;
}
// Free Password buffer
if (pPCB->pszPassword != NULL)
{
FREE (pPCB->pszPassword);
pPCB->pszPassword = NULL;
}
// Free user-specific data in the PCB
if (pPCB->pCustomAuthUserData != NULL)
{
FREE (pPCB->pCustomAuthUserData);
pPCB->pCustomAuthUserData = NULL;
}
// Free connection data, though it is common to all users
if (pPCB->pCustomAuthConnData != NULL)
{
FREE (pPCB->pCustomAuthConnData);
pPCB->pCustomAuthConnData = NULL;
}
// Free SSID
if (pPCB->pszSSID != NULL)
{
FREE (pPCB->pszSSID);
pPCB->pszSSID = NULL;
}
pPCB->fGotUserIdentity = FALSE;
TRACE1 (EAPOL, "FSMDisconnected completed for port %s", pPCB->pszFriendlyName);
return dwRetCode;
}
//
// FSMLogoff
//
// Description:
// Function called to send out EAPOL_Logoff packet. Usually triggered by
// user logging off.
//
// Arguments:
// pPCB - Pointer to PCB for the port on which logoff packet is to be
// sent out
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
FSMLogoff (
IN EAPOL_PCB *pPCB
)
{
EAPOL_PACKET *pEapolPkt = NULL;
DWORD dwRetCode = NO_ERROR;
TRACE1 (EAPOL, "FSMLogoff entered for port %s", pPCB->pszFriendlyName);
do
{
// Allocate new buffer
pEapolPkt = (EAPOL_PACKET *) MALLOC (sizeof (EAPOL_PACKET));
if (pEapolPkt == NULL)
{
TRACE0 (EAPOL, "FSMLogoff: Error in allocating memory for EAPOL packet");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
// Fill in fields
memcpy ((BYTE *)pEapolPkt->EthernetType,
(BYTE *)pPCB->bEtherType,
SIZE_ETHERNET_TYPE);
pEapolPkt->ProtocolVersion = pPCB->bProtocolVersion;
pEapolPkt->PacketType = EAPOL_Logoff;
HostToWireFormat16 ((WORD)0, (BYTE *)pEapolPkt->PacketBodyLength);
// Send packet out on the port
dwRetCode = ElWriteToPort (pPCB,
(CHAR *)pEapolPkt,
sizeof (EAPOL_PACKET));
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "FSMLogoff: Error in writing Logoff pkt to port %ld",
dwRetCode);
break;
}
// Mark that EAPOL_Logoff was sent out on the port
pPCB->dwLogoffSent = 1;
} while (FALSE);
TRACE1 (EAPOL, "Setting state LOGOFF for port %s", pPCB->pszFriendlyName);
pPCB->State = EAPOLSTATE_LOGOFF;
// Free Identity buffer
if (pPCB->pszIdentity != NULL)
{
FREE (pPCB->pszIdentity);
pPCB->pszIdentity = NULL;
}
// Free Password buffer
if (pPCB->pszPassword != NULL)
{
FREE (pPCB->pszPassword);
pPCB->pszPassword = NULL;
}
// Free user-specific data in the PCB
if (pPCB->pCustomAuthUserData != NULL)
{
FREE (pPCB->pCustomAuthUserData);
pPCB->pCustomAuthUserData = NULL;
}
// Free connection data, though it is common to all users
if (pPCB->pCustomAuthConnData != NULL)
{
FREE (pPCB->pCustomAuthConnData);
pPCB->pCustomAuthConnData = NULL;
}
// Free SSID
if (pPCB->pszSSID != NULL)
{
FREE (pPCB->pszSSID);
pPCB->pszSSID = NULL;
}
pPCB->fGotUserIdentity = FALSE;
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
TRACE1 (EAPOL, "FSMLogoff completed for port %s", pPCB->pszFriendlyName);
return dwRetCode;
}
//
// FSMConnecting
//
// Description:
//
// Funtion called to send out EAPOL_Start packet. If MaxStart EAPOL_Start
// packets have been sent out, State Machine moves to Authenticated state
//
// Arguments:
// pPCB - Pointer to the PCB for the port on which Start packet is
// to be sent out
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
FSMConnecting (
IN EAPOL_PCB *pPCB
)
{
EAPOL_PACKET *pEapolPkt = NULL;
DWORD dwStartInterval = 0;
GUID DeviceGuid;
DWORD dwRetCode = NO_ERROR;
TRACE1 (EAPOL, "FSMConnecting entered for port %s", pPCB->pszFriendlyName);
#ifndef EAPOL_SERVICE
ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
(VOID)EAPOLMANAuthenticationStarted (&DeviceGuid);
#endif
do
{
if (pPCB->State == EAPOLSTATE_CONNECTING)
{
// If PCB->State was Connecting earlier, increment ulStartCount
// else set ulStartCount to zero
// Did not receive Req/Id
if ((++(pPCB->ulStartCount)) > pPCB->EapolConfig.dwmaxStart)
{
// Deactivate start timer
RESTART_TIMER (pPCB->hTimer,
INFINITE_SECONDS,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
break;
}
TRACE0 (EAPOL, "FSMConnecting: Sent out maxStart with no response, Setting AUTHENTICATED state");
// Sent out enough EAPOL_Starts
// Go into authenticated state
if ((dwRetCode = FSMAuthenticated (pPCB,
pEapolPkt)) != NO_ERROR)
{
TRACE1 (EAPOL, "FSMConnecting: Error in FSMAuthenticated %ld",
dwRetCode);
break;
}
#ifndef EAPOL_SERVICE
// Display change of status using sys tray balloon
// on interface icon
ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
(VOID)EAPOLMANAuthenticationSucceeded (&DeviceGuid);
#endif
// No need to send out more EAPOL_Start packets
// Reset start packet count
pPCB->ulStartCount = 0;
pPCB->fIsRemoteEndEAPOLAware = FALSE;
break;
}
}
else
{
pPCB->ulStartCount++;
}
// If user is not logged in, send out EAPOL_Start packets
// at intervals of 1 second each. This is used to detect if the
// interface is on a secure network or not.
// If user is logged in, use the configured value for the
// StartPeriod as the interval
//if (!pPCB->fUserLoggedIn)
if (!g_fUserLoggedOn)
{
dwStartInterval = EAPOL_INIT_START_PERIOD; // 1 second
}
else
{
dwStartInterval = pPCB->EapolConfig.dwstartPeriod;
}
// Restart timer with startPeriod
// Even if error occurs, timeout will happen
// Else, we won't be able to get out of connecting state
RESTART_TIMER (pPCB->hTimer,
dwStartInterval,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "FSMConnecting: Error in RESTART_TIMER %ld",
dwRetCode);
break;
}
// Send out EAPOL_Start
// Allocate new buffer
pEapolPkt = (EAPOL_PACKET *) MALLOC (sizeof(EAPOL_PACKET));
if (pEapolPkt == NULL)
{
TRACE0 (EAPOL, "FSMConnecting: Error in allocating memory for EAPOL packet");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
// ISSUE:
// Does Authenticator side also ignore data beyond PacketType
// as the supplicant side does?
memcpy ((BYTE *)pEapolPkt->EthernetType,
(BYTE *)pPCB->bEtherType,
SIZE_ETHERNET_TYPE);
pEapolPkt->ProtocolVersion = pPCB->bProtocolVersion;
pEapolPkt->PacketType = EAPOL_Start;
HostToWireFormat16 ((WORD)0, (BYTE *)pEapolPkt->PacketBodyLength);
// Send packet out on the port
dwRetCode = ElWriteToPort (pPCB,
(CHAR *)pEapolPkt,
sizeof (EAPOL_PACKET));
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "FSMConnecting: Error in writing Start Pkt to port %ld",
dwRetCode);
break;
}
TRACE1 (EAPOL, "Setting state CONNECTING for port %s", pPCB->pszFriendlyName);
pPCB->State = EAPOLSTATE_CONNECTING;
SET_EAPOL_START_TIMER(pPCB);
} while (FALSE);
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
}
TRACE1 (EAPOL, "FSMConnecting completed for port %s", pPCB->pszFriendlyName);
return dwRetCode;
}
//
// FSMAcquired
//
// Description:
// Function called when the port receives a EAP-Request/Identity packet.
// EAP processing of the packet occurs and a EAP-Response/Identity may
// be sent out by EAP if required.
//
//
// Arguments:
// pPCB - Pointer to the PCB for the port on which data is being
// processed
// pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
FSMAcquired (
IN EAPOL_PCB *pPCB,
IN EAPOL_PACKET *pEapolPkt
)
{
DWORD dwComputerNameLen = 0;
GUID DeviceGuid;
DWORD dwRetCode= NO_ERROR;
TRACE1 (EAPOL, "FSMAcquired entered for port %s", pPCB->pszFriendlyName);
#ifndef EAPOL_SERVICE
ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
(VOID)EAPOLMANAuthenticationStarted (&DeviceGuid);
#endif
do
{
// Indicate to EAP=Dll to cleanup any leftovers from earlier
// authentication. This is to take care of cases where errors
// occured in the earlier authentication and cleanup wasn't done
if ((dwRetCode = ElEapEnd (pPCB)) != NO_ERROR)
{
TRACE1 (EAPOL, "FSMAcquired: Error in ElEapEnd = %ld",
dwRetCode);
break;
}
// Restart timer with authPeriod
// Even if there is error in ElEapWork, the authtimer timeout
// should happen
RESTART_TIMER (pPCB->hTimer,
pPCB->EapolConfig.dwauthPeriod,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "FSMAcquired: Error in RESTART_TIMER %ld",
dwRetCode);
break;
}
// Since an EAP Req-ID was received, reset EAPOL_Start count
pPCB->ulStartCount = 0;
// If current received EAP Id is the same the previous EAP Id
// send the last EAPOL packet again
if (((PPP_EAP_PACKET *)pEapolPkt->PacketBody)->Id ==
pPCB->dwPreviousId)
{
TRACE0 (EAPOL, "FSMAcquired: Re-xmitting EAP_Packet to port");
dwRetCode = ElWriteToPort (pPCB,
(CHAR *)pPCB->pbPreviousEAPOLPkt,
pPCB->dwSizeOfPreviousEAPOLPkt);
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "FSMAcquired: Error in writing re-xmitted EAP_Packet to port %ld",
dwRetCode);
break;
}
}
else
{
// Process the EAP packet
// ElEapWork will send out response if required
if (( dwRetCode = ElEapWork (
pPCB,
(PPP_EAP_PACKET *)pEapolPkt->PacketBody
)) != NO_ERROR)
{
TRACE1 (EAPOL, "FSMAcquired: Error in ElEapWork %ld",
dwRetCode);
break;
}
}
TRACE1 (EAPOL, "Setting state ACQUIRED for port %s", pPCB->pszFriendlyName);
SET_EAPOL_AUTH_TIMER(pPCB);
pPCB->State = EAPOLSTATE_ACQUIRED;
} while (FALSE);
TRACE1 (EAPOL, "FSMAcquired completed for port %s", pPCB->pszFriendlyName);
return dwRetCode;
}
//
// FSMAuthenticating
//
// Description:
//
// Function called when an non EAP-Request/Identity packet is received on the
// port. EAP processing of the data occurs.
//
// Arguments:
// pPCB - Pointer to the PCB for the port on which data is being
// processed
// pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
FSMAuthenticating (
IN EAPOL_PCB *pPCB,
IN EAPOL_PACKET *pEapolPkt
)
{
GUID DeviceGuid;
DWORD dwRetCode = NO_ERROR;
TRACE1 (EAPOL, "FSMAuthenticating entered for port %s", pPCB->pszFriendlyName);
#ifndef EAPOL_SERVICE
ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
(VOID)EAPOLMANAuthenticationStarted (&DeviceGuid);
#endif
do
{
// Restart timer with authPeriod
// Even if there is error in ElEapWork, the authtimer timeout
// should happen
RESTART_TIMER (pPCB->hTimer,
pPCB->EapolConfig.dwauthPeriod,
"PCB",
&dwRetCode);
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "FSMAuthenticating: Error in RESTART_TIMER %ld",
dwRetCode);
break;
}
// If current received EAP Id is the same the previous EAP Id
// send the last EAPOL packet again
// For EAPCODE_Success and EAPCODE_Failure, the value of id field
// will not be increment, Refer to EAP RFC
if ((((PPP_EAP_PACKET *)pEapolPkt->PacketBody)->Id
== pPCB->dwPreviousId) &&
(((PPP_EAP_PACKET *)pEapolPkt->PacketBody)->Code
!= EAPCODE_Success) &&
(((PPP_EAP_PACKET *)pEapolPkt->PacketBody)->Code
!= EAPCODE_Failure))
{
TRACE0 (EAPOL, "FSMAcquired: Re-xmitting EAP_Packet to port");
dwRetCode = ElWriteToPort (pPCB,
(CHAR *)pPCB->pbPreviousEAPOLPkt,
pPCB->dwSizeOfPreviousEAPOLPkt);
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "FSMAcquired: Error in writing re-xmitted EAP_Packet to port = %ld",
dwRetCode);
break;
}
}
else
{
// Process the EAP packet
// ElEapWork will send out response if required
if (( dwRetCode = ElEapWork (
pPCB,
(PPP_EAP_PACKET *)pEapolPkt->PacketBody
)) != NO_ERROR)
{
TRACE1 (EAPOL, "FSMAuthenticating: Error in ElEapWork %ld",
dwRetCode);
break;
}
}
TRACE1 (EAPOL, "Setting state AUTHENTICATING for port %s", pPCB->pszFriendlyName);
SET_EAPOL_AUTH_TIMER(pPCB);
pPCB->State = EAPOLSTATE_AUTHENTICATING;
} while (FALSE);
TRACE1 (EAPOL, "FSMAuthenticating completed for port %s", pPCB->pszFriendlyName);
return dwRetCode;
}
//
// FSMHeld
//
// Description:
// Function called when a EAP-Failure packet is received in the
// Authenticating state. State machine is held for heldPeriod before
// re-authentication can occur.
//
// Arguments:
// pPCB - Pointer to the PCB for the port on which data is being
// processed
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
FSMHeld (
IN EAPOL_PCB *pPCB
)
{
DWORD dwRetCode = NO_ERROR;
TRACE1 (EAPOL, "FSMHeld entered for port %s", pPCB->pszFriendlyName);
do
{
#ifdef DRAFT7
if (g_dwMachineAuthEnabled)
{
#endif
pPCB->dwAuthFailCount++;
if (pPCB->dwAuthFailCount <= EAPOL_MAX_AUTH_FAIL_COUNT)
{
TRACE1 (EAPOL, "Restarting Held timer with time value = %ld",
pPCB->EapolConfig.dwheldPeriod);
// Restart timer with heldPeriod
RESTART_TIMER (pPCB->hTimer,
pPCB->EapolConfig.dwheldPeriod,
"PCB",
&dwRetCode);
}
else
{
TRACE1 (EAPOL, "Restarting Held timer with extended time value = %ld",
(pPCB->dwAuthFailCount * (pPCB->EapolConfig.dwheldPeriod)));
// Restart timer with heldPeriod times pPCB->dwAuthFailCount
RESTART_TIMER (pPCB->hTimer,
((pPCB->dwAuthFailCount) * (pPCB->EapolConfig.dwheldPeriod)),
"PCB",
&dwRetCode);
}
#ifdef DRAFT7
}
else
{
TRACE1 (EAPOL, "Restarting Held timer with time value = %ld",
pPCB->EapolConfig.dwheldPeriod);
// Restart timer with heldPeriod
RESTART_TIMER (pPCB->hTimer,
pPCB->EapolConfig.dwheldPeriod,
"PCB",
&dwRetCode);
} // g_dwMachineAuthEnabled
#endif
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "FSMHeld: Error in RESTART_TIMER %ld",
dwRetCode);
break;
}
// Free Identity buffer
if (pPCB->pszIdentity != NULL)
{
FREE (pPCB->pszIdentity);
pPCB->pszIdentity = NULL;
}
// Free Password buffer
if (pPCB->pszPassword != NULL)
{
FREE (pPCB->pszPassword);
pPCB->pszPassword = NULL;
}
// Free user-specific data in the PCB
if (pPCB->pCustomAuthUserData != NULL)
{
FREE (pPCB->pCustomAuthUserData);
pPCB->pCustomAuthUserData = NULL;
}
// Free connection data
if (pPCB->pCustomAuthConnData != NULL)
{
FREE (pPCB->pCustomAuthConnData);
pPCB->pCustomAuthConnData = NULL;
}
// Since there has been an error in credentials, start afresh
// the authentication. Credentials may have changed e.g. certs
// may be renewed, MD5 credentials corrected etc.
pPCB->fGotUserIdentity = FALSE;
TRACE1 (EAPOL, "Setting state HELD for port %s", pPCB->pszFriendlyName);
pPCB->State = EAPOLSTATE_HELD;
SET_EAPOL_HELD_TIMER(pPCB);
TRACE1 (EAPOL, "FSMHeld: Port %s set to HELD state",
pPCB->pszDeviceGUID);
} while (FALSE);
TRACE1 (EAPOL, "FSMHeld completed for port %s", pPCB->pszFriendlyName);
return dwRetCode;
}
//
// FSMAuthenticated
//
// Description:
//
// Function called when a EAP-Success packet is received or MaxStart
// EAPOL_Startpackets have been sent out, but no EAP-Request/Identity
// packets were received. If EAP-Success packet is request, DHCP client
// is restarted to get a new IP address.
//
// Arguments:
// pPCB - Pointer to the PCB for the port on which data is being
// processed
// pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
FSMAuthenticated (
IN EAPOL_PCB *pPCB,
IN EAPOL_PACKET *pEapolPkt
)
{
DHCP_PNP_CHANGE DhcpPnpChange;
DWORD dwRetCode = NO_ERROR;
TRACE1 (EAPOL, "FSMAuthenticated entered for port %s",
pPCB->pszFriendlyName);
do
{
// Shutdown earlier EAP session
ElEapEnd (pPCB);
// Call DHCP only if state machine went through authentication
// If FSM is getting AUTHENTICATED by default, don't call DHCP
// if (pPCB->ulStartCount < pPCB->EapolConfig.dwmaxStart)
{
// Call DHCP to do PnP
ZeroMemory(&DhcpPnpChange, sizeof(DHCP_PNP_CHANGE));
DhcpPnpChange.Version = DHCP_PNP_CHANGE_VERSION_0;
if ((dwRetCode = DhcpHandlePnPEvent(0,
DHCP_CALLER_TCPUI,
NULL,
//pPCB->pszDeviceGUID,
&DhcpPnpChange,
NULL)) != NO_ERROR)
{
TRACE1 (EAPOL, "FSMAuthenticated: DHCPHandlePnPEvent returned error %ld",
dwRetCode);
break;
}
TRACE0 (EAPOL, "FSMAuthenticated: DHCPHandlePnPEvent successful");
}
TRACE1 (EAPOL, "Setting state AUTHENTICATED for port %s", pPCB->pszFriendlyName);
pPCB->State = EAPOLSTATE_AUTHENTICATED;
} while (FALSE);
TRACE1 (EAPOL, "FSMAuthenticated completed for port %s", pPCB->pszFriendlyName);
return dwRetCode;
}
//
// FSMRxKey
//
// Description:
// Function called when an EAPOL-Key packet is received in the
// Authenticated state. The WEP key is decrypted and
// plumbed down to the NIC driver.
//
// Arguments:
// pPCB - Pointer to the PCB for the port on which data is being
// processed
// pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
FSMRxKey (
IN EAPOL_PCB *pPCB,
IN EAPOL_PACKET *pEapolPkt
)
{
EAPOL_KEY_DESC *pKeyDesc = NULL;
EAPOL_KEY_DESC_D8 *pKeyDesc_D8 = NULL;
EAPOL_PACKET_D8 EapolPktD8;
EAPOL_PACKET_D8 *pEapolPktD8 = NULL;
ULONGLONG ullReplayCheck = 0;
BYTE bReplayCheck[8];
BYTE *pbMD5EapolPkt = NULL;
DWORD dwMD5EapolPktLen = 0;
MD5_CTX MD5Context;
DWORD dwEapPktLen = 0;
DWORD dwIndex = 0;
BYTE bHMACMD5HashBuffer[MD5DIGESTLEN];
RC4_KEYSTRUCT rc4key;
BYTE bKeyBuffer[48];
BYTE *pbKeyToBePlumbed = NULL;
DWORD dwKeyLength = 0;
NDIS_802_11_WEP *pNdisWEPKey = NULL;
DWORD dwRetCode = NO_ERROR;
TRACE1 (EAPOL, "FSMRxKey entered for port %s", pPCB->pszFriendlyName);
do
{
if (!pPCB->fRemoteEnd8021XD8)
{
// DRAFT 7
pKeyDesc = (EAPOL_KEY_DESC *)pEapolPkt->PacketBody;
dwKeyLength = WireToHostFormat16 (pKeyDesc->KeyLength);
TRACE4 (EAPOL, "Signature Type = %ld, \n Encrypt Type = %ld, \n KeyLength = %ld, \n KeyIndex = %ld",
pKeyDesc->SignatureType,
pKeyDesc->EncryptType,
dwKeyLength,
pKeyDesc->KeyIndex
);
// For Draft 8, do not check for non-existing fields
if (pKeyDesc->SignatureType != 1)
{
TRACE1 (EAPOL, "FSMRxKey: Invalid signature type = %ld",
pKeyDesc->SignatureType);
// log
break;
}
if (pKeyDesc->EncryptType != 1)
{
TRACE1 (EAPOL, "FSMRxKey: Invalid encryption type = %ld",
pKeyDesc->EncryptType);
// log
break;
}
memcpy ((BYTE *)bReplayCheck,
(BYTE *)pKeyDesc->ReplayCounter,
8*sizeof(BYTE));
ullReplayCheck = ((*((PBYTE)(bReplayCheck)+0) << 56) +
(*((PBYTE)(bReplayCheck)+1) << 48) +
(*((PBYTE)(bReplayCheck)+2) << 40) +
(*((PBYTE)(bReplayCheck)+3) << 32) +
(*((PBYTE)(bReplayCheck)+4) << 24) +
(*((PBYTE)(bReplayCheck)+5) << 16) +
(*((PBYTE)(bReplayCheck)+6) << 8) +
(*((PBYTE)(bReplayCheck)+7)));
//
// Check validity of Key message using the ReplayCounter field
// Verify if it is in sync with the last ReplayCounter value
// received
//
TRACE0 (EAPOL, "Incoming Replay counter ======= ");
EAPOL_DUMPBA ((BYTE *)&ullReplayCheck, 8);
TRACE0 (EAPOL, "Last Replay counter ======= ");
EAPOL_DUMPBA ((BYTE *)&(pPCB->ullLastReplayCounter), 8);
if (ullReplayCheck <= pPCB->ullLastReplayCounter)
{
TRACE0 (EAPOL, "FSMRxKey: Replay counter is not in sync, something is wrong");
// log
break;
}
// If valid ReplayCounter, save it in the PCB for future check
pPCB->ullLastReplayCounter = ullReplayCheck;
TRACE0 (EAPOL, "Replay counter in desc ======");
EAPOL_DUMPBA (pKeyDesc->ReplayCounter, 8);
//
// Verify if the MD5 hash generated on the EAPOL packet,
// with Signature nulled out, is the same as the signature
// Use the MPPERecv key as the secret
//
dwEapPktLen = WireToHostFormat16 (pEapolPkt->PacketBodyLength);
dwMD5EapolPktLen = sizeof (EAPOL_PACKET) - sizeof(pEapolPkt->EthernetType) - 1 + dwEapPktLen;
if ((pbMD5EapolPkt = (BYTE *) MALLOC (dwMD5EapolPktLen)) == NULL)
{
TRACE0 (EAPOL, "FSMRxKey: Error in MALLOC for pbMD5EapolPkt");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
memcpy ((BYTE *)pbMD5EapolPkt, (BYTE *)pEapolPkt+sizeof(pEapolPkt->EthernetType), dwMD5EapolPktLen);
//
// Null out the signature in the key descriptor copy, to calculate
// the hash on the supplicant side
//
ZeroMemory ((BYTE *)(pbMD5EapolPkt
- sizeof(pEapolPkt->EthernetType) +
sizeof(EAPOL_PACKET) - 1 + // pEapolPkt->Body
sizeof(EAPOL_KEY_DESC)- // End of EAPOL_KEY_DESC
MD5DIGESTLEN-1), // Signature field
MD5DIGESTLEN);
(VOID) ElGetHMACMD5Digest (
pbMD5EapolPkt,
dwMD5EapolPktLen,
pPCB->pbMPPERecvKey,
pPCB->dwMPPERecvKeyLength,
bHMACMD5HashBuffer
);
TRACE0 (EAPOL, "FSMRxKey: MD5 Hash body ==");
EAPOL_DUMPBA (pbMD5EapolPkt, dwMD5EapolPktLen);
TRACE0 (EAPOL, "FSMRxKey: MD5 Hash secret ==");
EAPOL_DUMPBA (pPCB->pbMPPERecvKey, pPCB->dwMPPERecvKeyLength);
TRACE0 (EAPOL, "FSMRxKey: MD5 Hash generated by Supplicant");
EAPOL_DUMPBA (bHMACMD5HashBuffer, MD5DIGESTLEN);
TRACE0 (EAPOL, "FSMRxKey: Signature sent in EAPOL_KEY_DESC");
EAPOL_DUMPBA (pKeyDesc->KeySignature, MD5DIGESTLEN);
//
// Check if HMAC-MD5 hash in received packet is what is expected
//
if (memcmp (bHMACMD5HashBuffer, pKeyDesc->KeySignature, MD5DIGESTLEN) != 0)
{
TRACE0 (EAPOL, "FSMRxKey: Signature in Key Desc does not match, potential security attack");
// log
break;
}
//
// Decrypt the multicast WEP key if it has been provided
//
// Check if there is Key Material (5/16 bytes) at the end of
// the Key Descriptor
if (WireToHostFormat16 (pEapolPkt->PacketBodyLength) > sizeof (EAPOL_KEY_DESC))
{
memcpy ((BYTE *)bKeyBuffer, (BYTE *)pKeyDesc->Key_IV, 16);
memcpy ((BYTE *)&bKeyBuffer[16], (BYTE *)pPCB->pbMPPESendKey, 32);
rc4_key (&rc4key, 48, bKeyBuffer);
rc4 (&rc4key, dwKeyLength, pKeyDesc->Key);
TRACE0 (EAPOL, " ========= The multicast key is ============= ");
EAPOL_DUMPBA (pKeyDesc->Key, dwKeyLength);
// Use the unencrypted key in the Key Desc as the encryption key
pbKeyToBePlumbed = pKeyDesc->Key;
}
else
{
// Use the MPPESend key as the encryption key
pbKeyToBePlumbed = (BYTE *)pPCB->pbMPPESendKey;
}
if ((pNdisWEPKey = MALLOC ( sizeof(NDIS_802_11_WEP)-1+dwKeyLength ))
== NULL)
{
TRACE0 (EAPOL, "FSMRxKey: MALLOC failed for pNdisWEPKey");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
pNdisWEPKey->Length = sizeof(NDIS_802_11_WEP) - 1 + dwKeyLength;
memcpy ((BYTE *)pNdisWEPKey->KeyMaterial, (BYTE *)pbKeyToBePlumbed,
dwKeyLength);
pNdisWEPKey->KeyLength = dwKeyLength;
// Create the long index out of the byte index got from AP
// If MSB in byte is set, set MSB in ulong format
if (pKeyDesc->KeyIndex & 0x80)
{
pNdisWEPKey->KeyIndex = 0x80000000;
}
else
{
pNdisWEPKey->KeyIndex = 0x00000000;
}
pNdisWEPKey->KeyIndex |= (pKeyDesc->KeyIndex & 0x03);
TRACE1 (ANY, "FSMRxKey: Key Index is %x", pNdisWEPKey->KeyIndex);
// Use NDISUIO to plumb the key to the driver
if ((dwRetCode = ElNdisuioSetOIDValue (
pPCB->hPort,
OID_802_11_ADD_WEP,
(BYTE *)pNdisWEPKey,
pNdisWEPKey->Length)) != NO_ERROR)
{
TRACE1 (PORT, "FSMRxKey: ElNdisuioSetOIDValue failed with error %ld",
dwRetCode);
}
}
else
{
// DRAFT 8
// Point beyond Signature Type for structure alignment
pKeyDesc_D8 = (EAPOL_KEY_DESC_D8 *)(pEapolPkt->PacketBody);
dwKeyLength = WireToHostFormat16 (pKeyDesc_D8->KeyLength);
TRACE3 (EAPOL, "Descriptor type = %ld, \n KeyLength = %ld, \n KeyIndex = %ld",
pKeyDesc_D8->DescriptorType,
dwKeyLength,
pKeyDesc_D8->KeyIndex
);
memcpy ((BYTE *)bReplayCheck,
(BYTE *)pKeyDesc_D8->ReplayCounter,
8*sizeof(BYTE));
ullReplayCheck = ((*((PBYTE)(bReplayCheck)+0) << 56) +
(*((PBYTE)(bReplayCheck)+1) << 48) +
(*((PBYTE)(bReplayCheck)+2) << 40) +
(*((PBYTE)(bReplayCheck)+3) << 32) +
(*((PBYTE)(bReplayCheck)+4) << 24) +
(*((PBYTE)(bReplayCheck)+5) << 16) +
(*((PBYTE)(bReplayCheck)+6) << 8) +
(*((PBYTE)(bReplayCheck)+7)));
//
// Check validity of Key message using the ReplayCounter field
// Verify if it is in sync with the last ReplayCounter value
// received
//
TRACE0 (EAPOL, "Incoming Replay counter ======= ");
EAPOL_DUMPBA ((BYTE *)&ullReplayCheck, 8);
TRACE0 (EAPOL, "Last Replay counter ======= ");
EAPOL_DUMPBA ((BYTE *)&(pPCB->ullLastReplayCounter), 8);
if (ullReplayCheck < pPCB->ullLastReplayCounter)
{
TRACE0 (EAPOL, "FSMRxKey: Replay counter is not in sync, something is wrong");
// log
break;
}
// If valid ReplayCounter, save it in the PCB for future check
pPCB->ullLastReplayCounter = ullReplayCheck;
TRACE1 (EAPOL, "Replay counter ======= %lx", ullReplayCheck);
TRACE0 (EAPOL, "Replay counter in desc ======");
EAPOL_DUMPBA (pKeyDesc_D8->ReplayCounter, 8);
//
// Verify if the MD5 hash generated on the EAPOL packet,
// with Signature nulled out, is the same as the signature
// Use the MPPERecv key as the secret
//
{
ZeroMemory (&EapolPktD8, sizeof (EAPOL_PACKET_D8));
memcpy (EapolPktD8.EthernetType, pEapolPkt->EthernetType, 2);
EapolPktD8.ProtocolVersion = pEapolPkt->ProtocolVersion;
EapolPktD8.PacketType = pEapolPkt->PacketType;
memcpy (EapolPktD8.PacketBodyLength, pEapolPkt->PacketBodyLength,
2);
memcpy ((BYTE *)&(EapolPktD8.AuthResultCode), (BYTE *)pEapolPkt - 2, 2);
memcpy ((BYTE *)pEapolPkt - 2, (BYTE *)&EapolPktD8,
sizeof(EAPOL_PACKET_D8)-1);
pEapolPktD8 = (EAPOL_PACKET_D8 *)((BYTE *)pEapolPkt - 2);
}
dwEapPktLen = WireToHostFormat16 (pEapolPktD8->PacketBodyLength);
dwMD5EapolPktLen = sizeof (EAPOL_PACKET_D8) - sizeof(pEapolPktD8->EthernetType) - 1 + dwEapPktLen;
if ((pbMD5EapolPkt = (BYTE *) MALLOC (dwMD5EapolPktLen)) == NULL)
{
TRACE0 (EAPOL, "FSMRxKey: Error in MALLOC for pbMD5EapolPkt");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
memcpy ((BYTE *)pbMD5EapolPkt, (BYTE *)pEapolPktD8+sizeof(pEapolPktD8->EthernetType), dwMD5EapolPktLen);
//
// Null out the signature in the key descriptor copy, to calculate
// the hash on the supplicant side
//
// Draft 8 has different KEY_DESC size
ZeroMemory ((BYTE *)(pbMD5EapolPkt
- sizeof(pEapolPktD8->EthernetType) +
sizeof(EAPOL_PACKET_D8) - 1 + // pEapolPktD8->Body
sizeof(EAPOL_KEY_DESC_D8) - // End of EAPOL_KEY_DESC
MD5DIGESTLEN-1), // Signature field
MD5DIGESTLEN);
(VOID) ElGetHMACMD5Digest (
pbMD5EapolPkt,
dwMD5EapolPktLen,
pPCB->pbMPPERecvKey,
pPCB->dwMPPERecvKeyLength,
bHMACMD5HashBuffer
);
TRACE0 (EAPOL, "FSMRxKey: MD5 Hash body ==");
EAPOL_DUMPBA (pbMD5EapolPkt, dwMD5EapolPktLen);
TRACE0 (EAPOL, "FSMRxKey: MD5 Hash secret ==");
EAPOL_DUMPBA (pPCB->pbMPPERecvKey, pPCB->dwMPPERecvKeyLength);
TRACE0 (EAPOL, "FSMRxKey: MD5 Hash generated by Supplicant");
EAPOL_DUMPBA (bHMACMD5HashBuffer, MD5DIGESTLEN);
TRACE0 (EAPOL, "FSMRxKey: Signature sent in EAPOL_KEY_DESC");
EAPOL_DUMPBA (pKeyDesc_D8->KeySignature, MD5DIGESTLEN);
//
// Check if HMAC-MD5 hash in received packet is what is expected
//
if (memcmp (bHMACMD5HashBuffer, pKeyDesc_D8->KeySignature, MD5DIGESTLEN) != 0)
{
TRACE0 (EAPOL, "FSMRxKey: Signature in Key Desc does not match, potential security attack");
// log
break;
}
//
// Decrypt the multicast WEP key if it has been provided
//
// Check if there is Key Material (5/16 bytes) at the end of
// the Key Descriptor
if (WireToHostFormat16 (pEapolPktD8->PacketBodyLength) > sizeof (EAPOL_KEY_DESC))
{
memcpy ((BYTE *)bKeyBuffer, (BYTE *)pKeyDesc_D8->Key_IV, 16);
memcpy ((BYTE *)&bKeyBuffer[16], (BYTE *)pPCB->pbMPPESendKey, 32);
rc4_key (&rc4key, 48, bKeyBuffer);
rc4 (&rc4key, dwKeyLength, pKeyDesc_D8->Key);
TRACE0 (EAPOL, " ========= The multicast key is ============= ");
EAPOL_DUMPBA (pKeyDesc_D8->Key, dwKeyLength);
// Use the unencrypted key in the Key Desc as the encryption key
pbKeyToBePlumbed = pKeyDesc_D8->Key;
}
else
{
// Use the MPPESend key as the encryption key
pbKeyToBePlumbed = (BYTE *)pPCB->pbMPPESendKey;
}
if ((pNdisWEPKey = MALLOC ( sizeof(NDIS_802_11_WEP)-1+dwKeyLength ))
== NULL)
{
TRACE0 (EAPOL, "FSMRxKey: MALLOC failed for pNdisWEPKey");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
pNdisWEPKey->Length = sizeof(NDIS_802_11_WEP) - 1 + dwKeyLength;
memcpy ((BYTE *)pNdisWEPKey->KeyMaterial, (BYTE *)pbKeyToBePlumbed,
dwKeyLength);
pNdisWEPKey->KeyLength = dwKeyLength;
// Create the long index out of the byte index got from AP
// If MSB in byte is set, set MSB in ulong format
if (pKeyDesc_D8->KeyIndex & 0x80)
{
pNdisWEPKey->KeyIndex = 0x80000000;
}
else
{
pNdisWEPKey->KeyIndex = 0x00000000;
}
pNdisWEPKey->KeyIndex |= (pKeyDesc_D8->KeyIndex & 0x03);
TRACE1 (ANY, "FSMRxKey: Key Index is %x", pNdisWEPKey->KeyIndex);
// Use NDISUIO to plumb the key to the driver
if ((dwRetCode = ElNdisuioSetOIDValue (
pPCB->hPort,
OID_802_11_ADD_WEP,
(BYTE *)pNdisWEPKey,
pNdisWEPKey->Length)) != NO_ERROR)
{
TRACE1 (PORT, "FSMRxKey: ElNdisuioSetOIDValue failed with error %ld",
dwRetCode);
}
}
} while (FALSE);
if (pbMD5EapolPkt != NULL)
{
FREE (pbMD5EapolPkt);
pbMD5EapolPkt = NULL;
}
if (pNdisWEPKey != NULL)
{
FREE (pNdisWEPKey);
pNdisWEPKey = NULL;
}
TRACE1 (EAPOL, "FSMRxKey completed for port %s", pPCB->pszFriendlyName);
return dwRetCode;
}
//
// ElTimeoutCallbackRoutine
//
// Description:
//
// Function called when any timer work item queued on the global timer
// queue expires. Depending on the state in which the port is when the timer
// expires, the port moves to the next state.
//
// Arguments:
// pvContext - Pointer to context. In this case, it is pointer to a PCB
// fTimerOfWaitFired - Unused
//
// Return values:
//
VOID
ElTimeoutCallbackRoutine (
IN PVOID pvContext,
IN BOOLEAN fTimerOfWaitFired
)
{
EAPOL_PCB *pPCB;
TRACE0 (EAPOL, "ElTimeoutCallbackRoutine entered");
do
{
// Context should not be NULL
if (pvContext == NULL)
{
TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: pvContext is NULL. Invalid timeout callback");
break;
}
// PCB is guaranteed to exist until all timers are fired
// Verify if Port is still active
pPCB = (EAPOL_PCB *)pvContext;
ACQUIRE_WRITE_LOCK (&(pPCB->rwLock));
if (!EAPOL_PORT_ACTIVE(pPCB))
{
// Port is not active
RELEASE_WRITE_LOCK (&(pPCB->rwLock));
TRACE1 (PORT, "ElTimeoutCallbackRoutine: Port %s is inactive",
pPCB->pszDeviceGUID);
break;
}
// Check the timer has been changed
// If the current time is less than the programmed timeout on
// the PCB, either timer component has shot off timer earlier
// or the timer fired but someone changed it in the meanwhile
if (pPCB->ulTimeout > GetTickCount())
{
TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: Timeout value has been changed or Timer fired earlier than required");
break;
}
// Check the current state of the state machine
// We can do additional checks such as flagging which timer was fired
// and in the timeout checking if the PCB state has remained the same
// Else bail out
switch (pPCB->State)
{
case EAPOLSTATE_CONNECTING:
if (!EAPOL_START_TIMER_SET(pPCB))
{
TRACE1 (EAPOL, "ElTimeoutCallbackRoutine: Wrong timeout %ld in Connecting state", CHECK_EAPOL_TIMER(pPCB));
break;
}
FSMConnecting(pPCB);
break;
case EAPOLSTATE_ACQUIRED:
if (!EAPOL_AUTH_TIMER_SET(pPCB))
{
TRACE1 (EAPOL, "ElTimeoutCallbackRoutine: Wrong timeout %ld in Acquired state", CHECK_EAPOL_TIMER(pPCB));
break;
}
FSMConnecting(pPCB);
break;
case EAPOLSTATE_AUTHENTICATING:
if (!EAPOL_AUTH_TIMER_SET(pPCB))
{
TRACE1 (EAPOL, "ElTimeoutCallbackRoutine: Wrong timeout %ld in Authenticating state", CHECK_EAPOL_TIMER(pPCB));
break;
}
FSMConnecting(pPCB);
break;
case EAPOLSTATE_HELD:
if (!EAPOL_HELD_TIMER_SET(pPCB))
{
TRACE1 (EAPOL, "ElTimeoutCallbackRoutine: Wrong timeout %ld in Held state", CHECK_EAPOL_TIMER(pPCB));
break;
}
FSMConnecting(pPCB);
break;
case EAPOLSTATE_DISCONNECTED:
TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: No action in Disconnected state");
break;
case EAPOLSTATE_LOGOFF:
TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: No action in Logoff state");
break;
default:
TRACE0 (EAPOL, "ElTimeoutCallbackRoutine: Critical Error. Invalid state after timer expires ");
break;
}
RELEASE_WRITE_LOCK (&(pPCB->rwLock));
} while (FALSE);
TRACE0 (EAPOL, "ElTimeoutCallbackRoutine completed");
return;
}
//
// ElEapWork
//
// Description:
//
// Function called when an EAPOL packet of type EAP_Packet is received
// The EAP packet is passed to the EAP module for processing.
// Depending on the result of the processing, a EAP Response packet
// is sent or the incoming packet is ignored.
//
// Input arguments:
// pPCB - Pointer to PCB for the port on which data is being processed
// pRecvPkt - Pointer to EAP packet in the data received from the remote end
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
//
// ISSUE: Rewrite with do {} while(FALSE)
//
DWORD
ElEapWork (
IN EAPOL_PCB *pPCB,
IN PPP_EAP_PACKET *pRecvPkt
)
{
DWORD dwLength = 0;
ELEAP_RESULT EapResult;
PPP_EAP_PACKET *pSendPkt;
EAPOL_PACKET *pEapolPkt;
GUID DeviceGuid;
WCHAR awszNotificationMsg[MAX_NOTIFICATION_MSG_SIZE];
DWORD dwReceivedId = 0;
DWORD dwDraft8HdrIncr = 0;
DWORD dwRetCode = NO_ERROR;
//
// If the protocol has not been started yet, call ElEapBegin
//
if (!(pPCB->fEapInitialized))
{
if (ElEapBegin (pPCB) != NO_ERROR)
{
TRACE1 (EAPOL, "ElEapWork: Error in ElEapBegin = %ld", dwRetCode);
return dwRetCode;
}
}
ZeroMemory(&EapResult, sizeof(EapResult));
// Create buffer for EAPOL + EAP and pass pointer to EAP header
pEapolPkt = (EAPOL_PACKET *) MALLOC (MAX_EAPOL_BUFFER_SIZE);
TRACE1 (EAPOL, "ElEapWork: EapolPkt created at %p", pEapolPkt);
if (pEapolPkt == NULL)
{
TRACE0 (EAPOL, "ElEapWork: Error allocating EAP buffer");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
return dwRetCode;
}
// Point to EAP header
pSendPkt = (PPP_EAP_PACKET *)((PBYTE)pEapolPkt + sizeof (EAPOL_PACKET) - 1);
if (pRecvPkt != NULL)
{
dwReceivedId = pRecvPkt->Id;
}
if (pPCB->fRemoteEnd8021XD8)
{
// Account for 2 bytes of AuthResultCode
dwDraft8HdrIncr = 2;
}
dwRetCode = ElEapMakeMessage (pPCB,
pRecvPkt,
pSendPkt,
MAX_EAPOL_BUFFER_SIZE
- sizeof(EAPOL_PACKET) - 1 - dwDraft8HdrIncr,
&EapResult
);
// Notification message for the user
if (NULL != EapResult.pszReplyMessage)
{
// Free earlier notication with the PCB
if (pPCB->pszEapReplyMessage != NULL)
{
FREE (pPCB->pszEapReplyMessage);
pPCB->pszEapReplyMessage = NULL;
}
pPCB->pszEapReplyMessage = EapResult.pszReplyMessage;
// Notify user of message
#ifndef EAPOL_SERVICE
ZeroMemory (awszNotificationMsg, MAX_NOTIFICATION_MSG_SIZE);
if (0 == MultiByteToWideChar (
CP_ACP,
0,
pPCB->pszEapReplyMessage,
-1,
awszNotificationMsg,
MAX_NOTIFICATION_MSG_SIZE))
{
dwRetCode = GetLastError();
TRACE2 (EAPOL,"MultiByteToWideChar(%s) failed: %d",
pPCB->pszEapReplyMessage,
dwRetCode);
FREE (pEapolPkt);
pEapolPkt = NULL;
return dwRetCode;
}
// Display notification message using sys tray balloon
// on interface icon
ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
(VOID)EAPOLMANNotification (&DeviceGuid,
awszNotificationMsg,
0);
#endif
TRACE1 (EAPOL, "ElEapWork: Notified user of EAP data = %s",
pPCB->pszEapReplyMessage);
}
if (dwRetCode != NO_ERROR)
{
switch (dwRetCode)
{
case ERROR_PPP_INVALID_PACKET:
TRACE0 (EAPOL, "ElEapWork: Silently discarding invalid auth packet");
break;
default:
TRACE1 (EAPOL, "ElEapWork: ElEapMakeMessage returned error %ld",
dwRetCode);
// NotifyCallerOfFailure (pPCB, dwRetCode);
break;
}
// Free up memory reserved for packet
FREE (pEapolPkt);
pEapolPkt = NULL;
return dwRetCode;
}
//
// Check to see if we have to save any user data
//
if (EapResult.fSaveUserData)
{
if ((dwRetCode = ElSetEapUserInfo (
pPCB->hUserToken,
pPCB->pszDeviceGUID,
pPCB->dwEapTypeToBeUsed,
pPCB->pszSSID,
EapResult.pUserData,
EapResult.dwSizeOfUserData)) != NO_ERROR)
{
TRACE1 (EAPOL, "ElEapWork: ElSetEapUserInfo failed with error = %d",
dwRetCode);
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
return dwRetCode;
}
TRACE1 (EAPOL, "ElEapWork: Saved EAP data for user, dwRetCode = %d",
dwRetCode);
}
//
// Check to see if we have to save any connection data
//
if ((EapResult.fSaveConnectionData ) &&
( 0 != EapResult.SetCustomAuthData.dwSizeOfConnectionData ) )
{
if ((dwRetCode = ElSetCustomAuthData (
pPCB->pszDeviceGUID,
pPCB->dwEapTypeToBeUsed,
pPCB->pszSSID,
EapResult.SetCustomAuthData.pConnectionData,
EapResult.SetCustomAuthData.dwSizeOfConnectionData
)) != NO_ERROR)
{
TRACE1 ( EAPOL, "ElEapWork: ElSetCustomAuthData failed with error = %d",
dwRetCode);
FREE (pEapolPkt);
pEapolPkt = NULL;
return dwRetCode;
}
TRACE0 ( EAPOL, "ElEapWork: Saved EAP data for connection" );
}
switch( EapResult.Action )
{
case ELEAP_Send:
case ELEAP_SendAndDone:
// Send out EAPOL packet
memcpy ((BYTE *)pEapolPkt->EthernetType,
(BYTE *)pPCB->bEtherType,
SIZE_ETHERNET_TYPE);
pEapolPkt->ProtocolVersion = pPCB->bProtocolVersion;
pEapolPkt->PacketType = EAP_Packet;
// The EAP packet length is in the packet returned back by
// the Dll MakeMessage
// In case of Notification and Identity Response, it is in
// EapResult.wSizeOfEapPkt
if (EapResult.wSizeOfEapPkt == 0)
{
EapResult.wSizeOfEapPkt =
WireToHostFormat16 (pSendPkt->Length);
}
HostToWireFormat16 ((WORD) EapResult.wSizeOfEapPkt,
(BYTE *)pEapolPkt->PacketBodyLength);
// Make a copy of the EAPOL packet in the PCB
// Will be used during retransmission
if (pPCB->pbPreviousEAPOLPkt != NULL)
{
FREE (pPCB->pbPreviousEAPOLPkt);
}
pPCB->pbPreviousEAPOLPkt =
MALLOC (sizeof (EAPOL_PACKET)+EapResult.wSizeOfEapPkt-1);
if (pPCB->pbPreviousEAPOLPkt == NULL)
{
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
TRACE0 (EAPOL, "ElEapWork: MALLOC failed for pbPreviousEAPOLPkt");
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
return dwRetCode;
}
memcpy (pPCB->pbPreviousEAPOLPkt, pEapolPkt,
sizeof (EAPOL_PACKET)+EapResult.wSizeOfEapPkt-1);
pPCB->dwSizeOfPreviousEAPOLPkt =
sizeof (EAPOL_PACKET)+EapResult.wSizeOfEapPkt-1;
pPCB->dwPreviousId = dwReceivedId;
// Send packet out on the port
dwRetCode = ElWriteToPort (pPCB,
(CHAR *)pEapolPkt,
sizeof (EAPOL_PACKET)+EapResult.wSizeOfEapPkt-1);
if (dwRetCode != NO_ERROR)
{
TRACE1 (EAPOL, "ElEapWork: Error in writing EAP_Packet to port %ld",
dwRetCode);
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
return dwRetCode;
}
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
// More processing to be done?
// Supplicant side should not ever receive ELEAP_SendAndDone
// result code
if (EapResult.Action != ELEAP_SendAndDone)
{
break;
}
else
{
TRACE0 (EAPOL, "ElEapWork: ELEAP_SendAndDone wrong result received");
ASSERT(0);
}
case ELEAP_Done:
// Retrieve MPPE keys from the attributes information
// returned by EAP-TLS
switch (EapResult.dwError)
{
case NO_ERROR:
TRACE0 (EAPOL, "ElEapWork: Authentication was successful");
//
// If authentication was successful
//
dwRetCode = ElExtractMPPESendRecvKeys (
pPCB,
EapResult.pUserAttributes,
(BYTE*)&(EapResult.abChallenge),
(BYTE*)&(EapResult.abResponse));
if (dwRetCode != NO_ERROR)
{
FREE (pEapolPkt);
//NotifyCallerOfFailure (pPcb, dwRetCode);
return dwRetCode;
}
// ISSUE:
// Do we want to retain UserAttributes
// pPCB->pAuthProtocolAttributes = EapResult.pUserAttributes;
break;
default:
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
TRACE0 (EAPOL, "ElEapWork: Authentication FAILED");
break;
}
// Free memory allocated for the packet, since no response
// is going to be sent out
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
break;
case ELEAP_NoAction:
// Free memory allocated for the packet, since nothing
// is being done with it
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
break;
default:
break;
}
if (pEapolPkt != NULL)
{
FREE (pEapolPkt);
pEapolPkt = NULL;
}
//
// Check to see if we have to bring up the InteractiveUI for EAP
// i.e. Server cert confirmation etc.
//
if (EapResult.fInvokeEapUI)
{
ElInvokeInteractiveUI (pPCB, &(EapResult.InvokeEapUIData));
}
return dwRetCode;
}
//
//
// ElExtractMPPESendRecvKeys
//
// Description:
// Function called if authentication was successful. The MPPE Send &
// Recv keys are extracted from the RAS_AUTH_ATTRIBUTE passed from
// the EAP DLL and stored in the PCB. The keys are used to decrypt
// the multicast WEP key and also are used for media-based encrypting.
//
// Return values
//
// NO_ERROR - Success
// Non-zero - Failure
//
DWORD
ElExtractMPPESendRecvKeys (
IN EAPOL_PCB *pPCB,
IN RAS_AUTH_ATTRIBUTE * pUserAttributes,
IN BYTE * pChallenge,
IN BYTE * pResponse
)
{
RAS_AUTH_ATTRIBUTE * pAttribute;
RAS_AUTH_ATTRIBUTE * pAttributeSendKey;
RAS_AUTH_ATTRIBUTE * pAttributeRecvKey;
DWORD dwRetCode = NO_ERROR;
DWORD dwEncryptionPolicy = 0;
DWORD dwEncryptionTypes = 0;
//
// Every time we get encryption keys, plumb them to the driver
//
do
{
pAttribute = ElAuthAttributeGetVendorSpecific (
311, 12, pUserAttributes);
pAttributeSendKey = ElAuthAttributeGetVendorSpecific ( 311, 16,
pUserAttributes);
pAttributeRecvKey = ElAuthAttributeGetVendorSpecific ( 311, 17,
pUserAttributes);
if ((pAttributeSendKey != NULL)
&& (pAttributeRecvKey != NULL))
{
//
// Set the MS-MPPE-Send-Key and MS-MPPE-Recv-Key with
// the ethernet driver
//
ULONG ulSendKeyLength = 0;
ULONG ulRecvKeyLength = 0;
// Based on PPP code
ulSendKeyLength = *(((BYTE*)(pAttributeSendKey->Value))+8);
ulRecvKeyLength = *(((BYTE*)(pAttributeRecvKey->Value))+8);
TRACE0 (EAPOL, "Send key = ");
EAPOL_DUMPBA (((BYTE*)(pAttributeSendKey->Value))+9,
ulSendKeyLength);
TRACE0 (EAPOL, "Recv key = ");
EAPOL_DUMPBA (((BYTE*)(pAttributeRecvKey->Value))+9,
ulRecvKeyLength);
pPCB->dwMPPESendKeyLength = ulSendKeyLength;
pPCB->dwMPPERecvKeyLength = ulRecvKeyLength;
//
// Copy MPPE Send and Receive Keys into the PCB for later usage
// These keys will be used to decrypt the global multicast key
// (if any).
//
if (pPCB->dwMPPESendKeyLength != 0)
{
if (pPCB->pbMPPESendKey != NULL)
{
FREE (pPCB->pbMPPESendKey);
pPCB->pbMPPESendKey = NULL;
}
if ((pPCB->pbMPPESendKey = MALLOC (pPCB->dwMPPESendKeyLength))
== NULL)
{
TRACE0 (EAPOL, "ElExtractMPPESendRecvKeys: Error in Malloc for SendKey");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
memcpy (pPCB->pbMPPESendKey,
((BYTE*)(pAttributeSendKey->Value))+9,
pPCB->dwMPPESendKeyLength);
}
if (pPCB->dwMPPERecvKeyLength != 0)
{
if (pPCB->pbMPPERecvKey != NULL)
{
FREE (pPCB->pbMPPERecvKey);
pPCB->pbMPPERecvKey = NULL;
}
if ((pPCB->pbMPPERecvKey = MALLOC (pPCB->dwMPPERecvKeyLength))
== NULL)
{
TRACE0 (EAPOL, "ElExtractMPPESendRecvKeys: Error in Malloc for RecvKey");
dwRetCode = ERROR_NOT_ENOUGH_MEMORY;
break;
}
memcpy (pPCB->pbMPPERecvKey,
((BYTE*)(pAttributeRecvKey->Value))+9,
pPCB->dwMPPERecvKeyLength);
}
TRACE0 (EAPOL,"MPPE-Send/Recv-Keys set");
}
else
{
TRACE0 (EAPOL, "ElExtractMPPESendRecvKeys: pAttributeSendKey or pAttributeRecvKey == NULL");
}
} while (FALSE);
if (dwRetCode != NO_ERROR)
{
if (pPCB->pbMPPESendKey != NULL)
{
FREE (pPCB->pbMPPESendKey);
pPCB->pbMPPESendKey = NULL;
}
if (pPCB->pbMPPERecvKey != NULL)
{
FREE (pPCB->pbMPPERecvKey);
pPCB->pbMPPERecvKey = NULL;
}
}
return( dwRetCode );
}
//
// ElProcessEapSuccess
//
// Description:
//
// Function called when an EAP_Success is received in any state
//
// Input arguments:
// pPCB - Pointer to PCB for the port on which data is being processed
// pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
ElProcessEapSuccess (
IN EAPOL_PCB *pPCB,
IN EAPOL_PACKET *pEapolPkt
)
{
GUID DeviceGuid;
BOOLEAN fAuthenticateAndAuthorized = TRUE;
EAPOL_PACKET_D8_D7 *pDummyHeader;
DWORD dwRetCode = NO_ERROR;
TRACE0 (EAPOL, "ElProcessEapSuccess: Got EAPCODE_Success");
do
{
// Indicate to EAP=Dll to cleanup completed session
if ((dwRetCode = ElEapEnd (pPCB)) != NO_ERROR)
{
TRACE1 (EAPOL, "ProcessReceivedPacket: EapSuccess: Error in ElEapEnd = %ld",
dwRetCode);
break;
}
if (pPCB->fRemoteEnd8021XD8)
{
fAuthenticateAndAuthorized = FALSE;
pDummyHeader = (EAPOL_PACKET_D8_D7 *)((BYTE *)pEapolPkt - 2);
switch (WireToHostFormat16(pDummyHeader->AuthResultCode))
{
case AUTH_Authorized:
fAuthenticateAndAuthorized = TRUE;
break;
case AUTH_Unauthorized:
fAuthenticateAndAuthorized = FALSE;
break;
default:
fAuthenticateAndAuthorized = FALSE;
break;
}
}
if (fAuthenticateAndAuthorized)
{
TRACE0 (EAPOL, "ElProcessEapSuccess: Autho and Authen successful");
// Complete remaining processing i.e. DHCP
if ((dwRetCode = FSMAuthenticated (pPCB,
pEapolPkt)) != NO_ERROR)
{
break;
}
#ifndef EAPOL_SERVICE
// Display change of status using sys tray balloon
// on interface icon
ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
(VOID)EAPOLMANAuthenticationSucceeded (&DeviceGuid);
#endif
}
else
{
TRACE0 (EAPOL, "ElProcessEapSuccess: Autho and Authen failed");
if ((dwRetCode = FSMHeld (pPCB)) != NO_ERROR)
{
break;
}
#ifndef EAPOL_SERVICE
// Display change of status using sys tray balloon
// on interface icon
ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
(VOID)EAPOLMANAuthenticationFailed (&DeviceGuid, 0);
#endif
}
}
while (FALSE);
return dwRetCode;
}
//
// ElProcessEapFail
//
// Description:
//
// Function called when an EAP_Fail is received in any state
//
// Input arguments:
// pPCB - Pointer to PCB for the port on which data is being processed
// pEapolPkt - Pointer to EAPOL packet that was received
//
// Return values:
// NO_ERROR - success
// non-zero - error
//
DWORD
ElProcessEapFail (
IN EAPOL_PCB *pPCB,
IN EAPOL_PACKET *pEapolPkt
)
{
GUID DeviceGuid;
DWORD dwRetCode = NO_ERROR;
TRACE0 (EAPOL, "ElProcessEapFail: Got EAPCODE_Failure");
do
{
// Indicate to EAP=Dll to cleanup completed session
if ((dwRetCode = ElEapEnd (pPCB)) != NO_ERROR)
{
TRACE1 (EAPOL, "ElProcessEapFail: EapFail: Error in ElEapEnd = %ld",
dwRetCode);
break;
}
if ((dwRetCode = FSMHeld (pPCB)) != NO_ERROR)
{
break;
}
#ifndef EAPOL_SERVICE
// Display change of status using sys tray balloon
// on interface icon
ElStringToGuid (pPCB->pszDeviceGUID, &DeviceGuid);
(VOID)EAPOLMANAuthenticationFailed (&DeviceGuid, 0);
#endif
}
while (FALSE);
return dwRetCode;
}
#undef EAPOL_SERVICE