/** @file Authenticator_api.c
|
*
|
* @brief This file defines the main APIs for authenticator.
|
*
|
* Copyright (C) 2014-2017, Marvell International Ltd.
|
*
|
* This software file (the "File") is distributed by Marvell International
|
* Ltd. under the terms of the GNU General Public License Version 2, June 1991
|
* (the "License"). You may use, redistribute and/or modify this File in
|
* accordance with the terms and conditions of the License, a copy of which
|
* is available by writing to the Free Software Foundation, Inc.,
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
|
* worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
|
*
|
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
|
* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
|
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
|
* this warranty disclaimer.
|
*/
|
|
/******************************************************
|
Change log:
|
03/07/2014: Initial version
|
******************************************************/
|
//Authenticator related function definitions
|
#include "wltypes.h"
|
#include "IEEE_types.h"
|
|
#include "hostsa_ext_def.h"
|
#include "authenticator.h"
|
|
#include "wl_macros.h"
|
#include "wlpd.h"
|
#include "pass_phrase.h"
|
#include "sha1.h"
|
#include "crypt_new.h"
|
#include "parser.h"
|
#include "keyCommonDef.h"
|
#include "keyMgmtStaTypes.h"
|
#include "AssocAp_srv_rom.h"
|
#include "pmkCache.h"
|
#include "keyMgmtApTypes.h"
|
#include "keyMgmtAp.h"
|
#include "rc4.h"
|
#include "keyMgmtAp.h"
|
|
/*********************
|
Local Variables
|
*********************/
|
|
/*********************
|
Global Variables
|
*********************/
|
|
/*********************
|
Local Functions
|
*********************/
|
|
/*********************
|
Global Functions
|
*********************/
|
#ifdef DRV_EMBEDDED_SUPPLICANT
|
extern void allocSupplicantData(void *phostsa_priv);
|
extern void freeSupplicantData(void *phostsa_priv);
|
extern mlan_status initSupplicantTimer(void *priv);
|
extern void keyMgmtSta_RomInit(void);
|
extern void freeSupplicantTimer(void *priv);
|
#endif
|
|
/*********************
|
Utility Handler
|
*********************/
|
#ifdef DRV_EMBEDDED_AUTHENTICATOR
|
static UINT32
|
util_CountBits(UINT32 val)
|
{
|
UINT32 count = 0;
|
|
for (count = 0; val; count++) {
|
val &= (val - 1);
|
}
|
return count;
|
}
|
|
static void
|
initMicErrorParams(UINT32 wpa, MIC_Error_t *pApMicError)
|
{
|
if (wpa) {
|
pApMicError->MICCounterMeasureEnabled = 1;
|
pApMicError->disableStaAsso = 0;
|
pApMicError->status = NO_MIC_FAILURE;
|
}
|
}
|
|
/**
|
* @brief whether authenticator is enabled or not
|
*
|
* @param priv A void pointer to phostsa private struct
|
*
|
* @return
|
*/
|
t_u8
|
IsAuthenticatorEnabled(void *priv)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
apInfo_t *pApInfo = NULL;
|
apRsnConfig_t *pRsnConfig = NULL;
|
t_u8 ret = 0;
|
|
ENTER();
|
|
if (!psapriv) {
|
LEAVE();
|
return ret;
|
}
|
|
pApInfo = &psapriv->apinfo;
|
if (pApInfo == NULL) {
|
LEAVE();
|
return ret;
|
}
|
|
pRsnConfig = &pApInfo->bssConfig.RsnConfig;
|
|
// If Passphrase lengh is nonozero then
|
// authenticator in the driver is to be used,
|
// otherwise authenticator in the host is not to be used.
|
if (pRsnConfig->PSKPassPhraseLen != 0) {
|
ret = 1;
|
}
|
|
LEAVE();
|
return ret;
|
}
|
|
/**
|
* @brief BSS configure initialized
|
*
|
* @param priv A void pointer to phostsa private struct
|
*
|
* @return
|
*/
|
void
|
AuthenitcatorInitBssConfig(void *priv)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = MNULL;
|
apInfo_t *pApInfo = MNULL;
|
BssConfig_t *pBssConfig = MNULL;
|
apRsnConfig_t *pRsnConfig = MNULL;
|
|
ENTER();
|
|
if (!psapriv) {
|
LEAVE();
|
return;
|
}
|
util_fns = &psapriv->util_fns;
|
pApInfo = &psapriv->apinfo;
|
pBssConfig = &pApInfo->bssConfig;
|
pRsnConfig = &pBssConfig->RsnConfig;
|
|
memset(util_fns, pBssConfig, 0x00, sizeof(BssConfig_t));
|
/**default ap ssid*/
|
pBssConfig->SsIdLen = wlan_strlen(AP_DEFAULT_SSID);
|
memset(util_fns, pBssConfig->SsId, 0x00, IEEEtypes_SSID_SIZE);
|
memcpy(util_fns, pBssConfig->SsId, AP_DEFAULT_SSID,
|
IEEEtypes_SSID_SIZE);
|
/**default retry times ans timeout*/
|
pRsnConfig->PwsHskTimeOut = PWS_HSK_TIMEOUT;
|
pRsnConfig->MaxPwsHskRetries = PWS_HSK_RETRIES;
|
pRsnConfig->GrpHskTimeOut = GRP_HSK_TIMEOUT;
|
pRsnConfig->MaxGrpHskRetries = GRP_HSK_RETRIES;
|
/**Group key rekey time*/
|
pRsnConfig->GrpReKeyTime = GRP_REKEY_TIME;
|
|
LEAVE();
|
}
|
|
/**
|
* @brief get bss config
|
*
|
* @param priv A void pointer to phostsa private struct
|
* @param pbss_config a pointer to mlan_uap_bss_param
|
* @param SetConfigToMlan 1 set releated config to mlan , 0 get related config from mlan
|
*
|
* @return
|
*/
|
void
|
AuthenticatorGetBssConfig(hostsa_private *psapriv, t_u8 *pbss_config,
|
t_u8 SetConfigToMlan)
|
{
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
apInfo_t *pApInfo = &psapriv->apinfo;
|
mlan_uap_bss_param *bss_config = (mlan_uap_bss_param *)pbss_config;
|
BssConfig_t *pBssConfig = MNULL;
|
apRsnConfig_t *pRsnConfig = MNULL;
|
t_u8 zero_mac[] = { 0, 0, 0, 0, 0, 0 };
|
|
ENTER();
|
|
pBssConfig = &pApInfo->bssConfig;
|
pRsnConfig = &pBssConfig->RsnConfig;
|
|
/**set bss config to mlan*/
|
if (SetConfigToMlan) {
|
if ((pRsnConfig->PwsHskTimeOut != 0) &&
|
(pRsnConfig->PwsHskTimeOut < (MAX_VALID_DWORD))) {
|
bss_config->pairwise_update_timeout =
|
pRsnConfig->PwsHskTimeOut;
|
}
|
|
if ((pRsnConfig->MaxPwsHskRetries != 0) &&
|
(pRsnConfig->MaxPwsHskRetries < (MAX_VALID_DWORD)))
|
bss_config->pwk_retries = pRsnConfig->MaxPwsHskRetries;
|
|
if ((pRsnConfig->GrpHskTimeOut != 0) &&
|
(pRsnConfig->GrpHskTimeOut < (MAX_VALID_DWORD)))
|
bss_config->groupwise_update_timeout =
|
pRsnConfig->GrpHskTimeOut;
|
|
if ((pRsnConfig->MaxGrpHskRetries != 0) &&
|
(pRsnConfig->MaxGrpHskRetries < (MAX_VALID_DWORD)))
|
bss_config->gwk_retries = pRsnConfig->MaxGrpHskRetries;
|
|
if (pRsnConfig->PSKPassPhraseLen != 0) {
|
bss_config->wpa_cfg.length =
|
pRsnConfig->PSKPassPhraseLen;
|
memcpy(util_fns, bss_config->wpa_cfg.passphrase,
|
pRsnConfig->PSKPassPhrase,
|
pRsnConfig->PSKPassPhraseLen);
|
}
|
|
if ((pRsnConfig->GrpReKeyTime != 0) &&
|
(pRsnConfig->GrpReKeyTime < MAX_GRP_TIMER))
|
bss_config->wpa_cfg.gk_rekey_time =
|
pRsnConfig->GrpReKeyTime;
|
|
LEAVE();
|
return;
|
}
|
|
if (((pBssConfig->SsIdLen != bss_config->ssid.ssid_len) ||
|
(memcmp(util_fns, pBssConfig->SsId,
|
bss_config->ssid.ssid, bss_config->ssid.ssid_len) != 0)) &&
|
bss_config->ssid.ssid_len) {
|
pApInfo->bssData.updatePassPhrase = 1;
|
memcpy(util_fns, pBssConfig->SsId, bss_config->ssid.ssid,
|
bss_config->ssid.ssid_len);
|
pBssConfig->SsIdLen = bss_config->ssid.ssid_len;
|
}
|
|
if (memcmp
|
(util_fns, zero_mac, &bss_config->mac_addr, MLAN_MAC_ADDR_LENGTH)) {
|
memset(util_fns, psapriv->curr_addr, 0x00,
|
MLAN_MAC_ADDR_LENGTH);
|
memcpy(util_fns, psapriv->curr_addr, &bss_config->mac_addr,
|
MLAN_MAC_ADDR_LENGTH);
|
}
|
|
if ((bss_config->max_sta_count != 0) &&
|
(bss_config->max_sta_count <= MAX_STA_COUNT))
|
pBssConfig->MaxStaSupported = bss_config->max_sta_count;
|
|
if ((bss_config->pairwise_update_timeout != 0) &&
|
(bss_config->pairwise_update_timeout < (MAX_VALID_DWORD))) {
|
pRsnConfig->PwsHskTimeOut = bss_config->pairwise_update_timeout;
|
}
|
|
if ((bss_config->pwk_retries != 0) &&
|
(bss_config->pwk_retries < (MAX_VALID_DWORD)))
|
pRsnConfig->MaxPwsHskRetries = bss_config->pwk_retries;
|
|
if ((bss_config->groupwise_update_timeout != 0) &&
|
(bss_config->groupwise_update_timeout < (MAX_VALID_DWORD)))
|
pRsnConfig->GrpHskTimeOut =
|
bss_config->groupwise_update_timeout;
|
|
if ((bss_config->gwk_retries != 0) &&
|
(bss_config->gwk_retries < (MAX_VALID_DWORD)))
|
pRsnConfig->MaxGrpHskRetries = bss_config->gwk_retries;
|
|
if ((bss_config->auth_mode <= MLAN_AUTH_MODE_SHARED) ||
|
(bss_config->auth_mode == MLAN_AUTH_MODE_AUTO))
|
pBssConfig->AuthType = bss_config->auth_mode;
|
|
memcpy(util_fns, &pBssConfig->SecType, &bss_config->protocol,
|
sizeof(pBssConfig->SecType));
|
|
if ((bss_config->protocol & PROTOCOL_WPA) ||
|
(bss_config->protocol & PROTOCOL_WPA2) ||
|
(bss_config->protocol & PROTOCOL_EAP)) {
|
pRsnConfig->AuthKey = bss_config->key_mgmt;
|
pRsnConfig->AuthKeyCount = util_CountBits(pRsnConfig->AuthKey);
|
memcpy(util_fns, (char *)&pRsnConfig->Akmp,
|
(char *)&bss_config->key_mgmt_operation,
|
sizeof(bss_config->key_mgmt_operation));
|
|
if ((bss_config->wpa_cfg.
|
pairwise_cipher_wpa & VALID_CIPHER_BITMAP) &&
|
(bss_config->wpa_cfg.pairwise_cipher_wpa != 0xff)) {
|
memset(util_fns, (t_u8 *)&pRsnConfig->wpaUcstCipher,
|
0x00, sizeof(Cipher_t));
|
memcpy(util_fns, (t_u8 *)&pRsnConfig->wpaUcstCipher,
|
(t_u8 *)&bss_config->wpa_cfg.pairwise_cipher_wpa,
|
sizeof(Cipher_t));
|
pRsnConfig->wpaUcstCipherCount =
|
util_CountBits(bss_config->wpa_cfg.
|
pairwise_cipher_wpa);
|
}
|
|
if ((bss_config->wpa_cfg.
|
pairwise_cipher_wpa2 & VALID_CIPHER_BITMAP) &&
|
(bss_config->wpa_cfg.pairwise_cipher_wpa2 != 0xff)) {
|
memset(util_fns, (t_u8 *)&pRsnConfig->wpa2UcstCipher,
|
0x00, sizeof(Cipher_t));
|
memcpy(util_fns, (t_u8 *)&pRsnConfig->wpa2UcstCipher,
|
(t_u8 *)&bss_config->wpa_cfg.
|
pairwise_cipher_wpa2, sizeof(Cipher_t));
|
pRsnConfig->wpa2UcstCipherCount =
|
util_CountBits(bss_config->wpa_cfg.
|
pairwise_cipher_wpa2);
|
}
|
DBG_HEXDUMP(MCMD_D, " wpa2UcstCipher",
|
(t_u8 *)&pRsnConfig->wpa2UcstCipher,
|
sizeof(Cipher_t));
|
DBG_HEXDUMP(MCMD_D, " wpaUcastCipher",
|
(t_u8 *)&pRsnConfig->wpaUcstCipher,
|
sizeof(Cipher_t));
|
|
if (bss_config->wpa_cfg.group_cipher & VALID_CIPHER_BITMAP) {
|
memset(util_fns, (t_u8 *)&pRsnConfig->mcstCipher, 0x00,
|
sizeof(Cipher_t));
|
memcpy(util_fns, (t_u8 *)&pRsnConfig->mcstCipher,
|
(t_u8 *)&bss_config->wpa_cfg.group_cipher,
|
sizeof(Cipher_t));
|
pRsnConfig->mcstCipherCount =
|
util_CountBits(bss_config->wpa_cfg.
|
group_cipher);
|
}
|
|
if (bss_config->wpa_cfg.rsn_protection <= MTRUE)
|
pRsnConfig->RSNReplayProtEn =
|
bss_config->wpa_cfg.
|
rsn_protection ? MTRUE : MFALSE;
|
|
}
|
|
if (((pRsnConfig->PSKPassPhraseLen != bss_config->wpa_cfg.length) ||
|
(memcmp(util_fns, pRsnConfig->PSKPassPhrase,
|
bss_config->wpa_cfg.passphrase,
|
bss_config->wpa_cfg.length) != 0)) &&
|
bss_config->wpa_cfg.length) {
|
pApInfo->bssData.updatePassPhrase = 1;
|
pRsnConfig->PSKPassPhraseLen = bss_config->wpa_cfg.length;
|
memset(util_fns, pRsnConfig->PSKPassPhrase,
|
0x00, PSK_PASS_PHRASE_LEN_MAX);
|
memcpy(util_fns, pRsnConfig->PSKPassPhrase,
|
bss_config->wpa_cfg.passphrase,
|
bss_config->wpa_cfg.length);
|
}
|
|
if ((bss_config->wpa_cfg.gk_rekey_time != 0) &&
|
(bss_config->wpa_cfg.gk_rekey_time < MAX_GRP_TIMER))
|
pRsnConfig->GrpReKeyTime = bss_config->wpa_cfg.gk_rekey_time;
|
|
LEAVE();
|
}
|
|
/**
|
* @brief get bss config for authenticator and append wpa/rsn ie to FW
|
*
|
* @param priv A void pointer to phostsa private struct
|
* @param pbss_config a pointer to mlan_uap_bss_param
|
* @param appendIE 1 append rsn/wpa ie to fw, 0 not append
|
* @param clearIE 1 clear rsn/wpa ie to fw, 0 not clear
|
* @param SetConfigToMlan 1 set releated config to mlan , 0 get related config from mlan
|
*
|
*
|
* @return
|
*/
|
t_u8
|
AuthenticatorBssConfig(void *priv, t_u8 *pbss_config, t_u8 appendIE,
|
t_u8 clearIE, t_u8 SetConfigToMlan)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = MNULL;
|
hostsa_mlan_fns *pm_fns = MNULL;
|
apInfo_t *pApInfo = MNULL;
|
BssConfig_t *pBssConfig = MNULL;
|
apRsnConfig_t *pRsnConfig = MNULL;
|
t_u16 ielen = 0;
|
t_u8 ret = 0;
|
|
ENTER();
|
|
if (!psapriv) {
|
LEAVE();
|
return ret;
|
}
|
util_fns = &psapriv->util_fns;
|
pm_fns = &psapriv->mlan_fns;
|
pApInfo = &psapriv->apinfo;
|
|
pBssConfig = &pApInfo->bssConfig;
|
pRsnConfig = &pBssConfig->RsnConfig;
|
|
if (pbss_config)
|
AuthenticatorGetBssConfig(psapriv, pbss_config,
|
SetConfigToMlan);
|
|
if (appendIE && pRsnConfig->PSKPassPhraseLen &&
|
(pBssConfig->SecType.wpa || pBssConfig->SecType.wpa2 ||
|
pBssConfig->SecType.wpaNone)) {
|
PRINTM(MMSG, "authenticator set mgmt IE\n");
|
if (pBssConfig->wpa_ielen) {
|
pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
|
pBssConfig->wpa_ie,
|
pBssConfig->wpa_ielen, 1);
|
pBssConfig->wpa_ielen = 0;
|
memset(util_fns, pBssConfig->wpa_ie, 0x00, MAX_IE_SIZE);
|
}
|
/**construct wpa or RSN ie*/
|
if (pBssConfig->SecType.wpa) {
|
memset(util_fns, pBssConfig->wpa_ie, 0x00, MAX_IE_SIZE);
|
ielen = keyMgmtAp_FormatWPARSN_IE(psapriv,
|
(IEEEtypes_InfoElementHdr_t
|
*)pBssConfig->wpa_ie,
|
0,
|
&pBssConfig->
|
RsnConfig.
|
wpaUcstCipher,
|
pBssConfig->RsnConfig.
|
wpaUcstCipherCount,
|
&pBssConfig->
|
RsnConfig.mcstCipher,
|
pBssConfig->RsnConfig.
|
AuthKey,
|
pBssConfig->RsnConfig.
|
AuthKeyCount);
|
pBssConfig->wpa_ielen = ielen;
|
pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
|
pBssConfig->wpa_ie, ielen,
|
0);
|
}
|
|
if (pBssConfig->rsn_ielen) {
|
pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
|
pBssConfig->rsn_ie,
|
pBssConfig->rsn_ielen, 1);
|
pBssConfig->rsn_ielen = 0;
|
memset(util_fns, pBssConfig->rsn_ie, 0x00, MAX_IE_SIZE);
|
}
|
|
if (pBssConfig->SecType.wpa2) {
|
memset(util_fns, pBssConfig->rsn_ie, 0x00, MAX_IE_SIZE);
|
ielen = keyMgmtAp_FormatWPARSN_IE(psapriv,
|
(IEEEtypes_InfoElementHdr_t
|
*)pBssConfig->rsn_ie,
|
1,
|
&pBssConfig->
|
RsnConfig.
|
wpa2UcstCipher,
|
pBssConfig->RsnConfig.
|
wpa2UcstCipherCount,
|
&pBssConfig->
|
RsnConfig.mcstCipher,
|
pBssConfig->RsnConfig.
|
AuthKey,
|
pBssConfig->RsnConfig.
|
AuthKeyCount);
|
pBssConfig->rsn_ielen = ielen;
|
pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
|
pBssConfig->rsn_ie, ielen,
|
0);
|
}
|
}
|
|
if (clearIE) {
|
PRINTM(MMSG, "authenticator clear mgmt IE\n");
|
if (pBssConfig->wpa_ielen) {
|
pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
|
pBssConfig->wpa_ie,
|
pBssConfig->wpa_ielen, 1);
|
pBssConfig->wpa_ielen = 0;
|
memset(util_fns, pBssConfig->wpa_ie, 0x00, MAX_IE_SIZE);
|
}
|
if (pBssConfig->rsn_ielen) {
|
pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
|
pBssConfig->rsn_ie,
|
pBssConfig->rsn_ielen, 1);
|
pBssConfig->rsn_ielen = 0;
|
memset(util_fns, pBssConfig->rsn_ie, 0x00, MAX_IE_SIZE);
|
}
|
}
|
LEAVE();
|
return ret;
|
}
|
|
/**
|
* @brief initialize key
|
*
|
* @param priv A void pointer to phostsa private struct
|
*
|
* @return
|
*/
|
void
|
AuthenticatorKeyMgmtInit(void *priv, t_u8 *addr)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
apInfo_t *pApInfo = &psapriv->apinfo;
|
BssConfig_t *pBssConfig = MNULL;
|
|
ENTER();
|
|
pBssConfig = &pApInfo->bssConfig;
|
/**mac address */
|
memcpy(util_fns, psapriv->curr_addr, addr, MLAN_MAC_ADDR_LENGTH);
|
/**Reset Group Key*/
|
memset(util_fns, &pBssConfig->pGtkKeyBuf, 0x00,
|
sizeof(pBssConfig->pGtkKeyBuf));
|
/**key init */
|
KeyMgmtInit(priv);
|
/**Group key update time,*/
|
if (pBssConfig->RsnConfig.GrpReKeyTime) {
|
pApInfo->bssData.grpRekeyCntConfigured = pApInfo->bssConfig.RsnConfig.GrpReKeyTime / 60;
|
/**every 60s grpRekeyCntRemaining -- */
|
|
pApInfo->bssData.grpRekeyCntRemaining
|
= pApInfo->bssData.grpRekeyCntConfigured;
|
}
|
|
keyApi_ApUpdateKeyMaterial(priv, MNULL, MTRUE);
|
|
/**start Group rekey timer*/
|
if (pBssConfig->RsnConfig.GrpReKeyTime && !psapriv->GrpRekeyTimerIsSet) {
|
util_fns->moal_start_timer(util_fns->pmoal_handle,
|
psapriv->GrpRekeytimer,
|
MFALSE, MRVDRV_TIMER_60S);
|
psapriv->GrpRekeyTimerIsSet = MTRUE;
|
}
|
|
LEAVE();
|
}
|
|
/**
|
* @brief clear key
|
*
|
* @param priv A void pointer to phostsa private struct
|
*
|
* @return
|
*/
|
void
|
AuthenticatorkeyClear(void *priv)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *putil_fns = &psapriv->util_fns;
|
apInfo_t *pApInfo = &psapriv->apinfo;
|
BssConfig_t *pBssConfig = &pApInfo->bssConfig;
|
|
if (psapriv->GrpRekeyTimerIsSet) {
|
psapriv->GrpRekeyTimerIsSet = MFALSE;
|
putil_fns->moal_stop_timer(putil_fns->pmoal_handle,
|
psapriv->GrpRekeytimer);
|
/**Reset Group Key*/
|
memset(putil_fns, &pBssConfig->pGtkKeyBuf, 0x00,
|
sizeof(pBssConfig->pGtkKeyBuf));
|
}
|
}
|
|
/**
|
* @brief process received eapol packet
|
*
|
* @param psapriv A void pointer to phostsa private struct
|
* @param pbuf a pointer to packet buf
|
* @param len buffer len
|
* @
|
* @return
|
*/
|
t_u8
|
AuthenticatorProcessEapolPacket(t_void *psapriv, t_u8 *pbuf, t_u32 len)
|
{
|
phostsa_private priv = (phostsa_private)psapriv;
|
hostsa_mlan_fns *pm_fns = &priv->mlan_fns;
|
EAPOL_KeyMsg_t *rx_eapol_ptr;
|
Status_e status = FAIL;
|
cm_Connection *connPtr = MNULL;
|
cm_Connection *pconnPtr = MNULL;
|
t_u8 *sta_addr = pbuf + MLAN_MAC_ADDR_LENGTH;
|
t_u8 ret = 0;
|
t_u32 eapol_pkt_len, least_len;
|
|
ENTER();
|
|
rx_eapol_ptr = (EAPOL_KeyMsg_t *)(pbuf + ETHII_HEADER_LEN);
|
|
if (rx_eapol_ptr->hdr_8021x.pckt_type !=
|
IEEE_8021X_PACKET_TYPE_EAPOL_KEY) {
|
ret = 1;
|
return ret;
|
|
}
|
|
eapol_pkt_len = len - ETHII_HEADER_LEN;
|
least_len = sizeof(EAPOL_KeyMsg_t) - sizeof(rx_eapol_ptr->key_data);
|
if (eapol_pkt_len < least_len) {
|
PRINTM(MERROR,
|
"Invalid EAPOL Key Packet, received len: %u, least len: %u\n",
|
eapol_pkt_len, least_len);
|
ret = 1;
|
return ret;
|
}
|
|
pm_fns->Hostsa_get_station_entry(priv->pmlan_private, sta_addr,
|
(t_void *)&pconnPtr);
|
connPtr = (cm_Connection *)pconnPtr;
|
if (connPtr) {
|
// rx_eapol_ptr = (EAPOL_KeyMsg_t *)(pbuf + ETHII_HEADER_LEN);
|
|
if (rx_eapol_ptr->key_info.Error) {
|
ApMicCounterMeasureInvoke((t_void *)connPtr);
|
return ret;
|
}
|
|
if (!isValidReplayCount(priv, &connPtr->staData.keyMgmtInfo,
|
(UINT8 *)&rx_eapol_ptr->replay_cnt[0]))
|
{
|
return ret;
|
}
|
|
if (connPtr->staData.keyMgmtInfo.rom.keyMgmtState ==
|
WAITING_4_MSG2) {
|
status = ProcessPWKMsg2(priv, connPtr, pbuf, len);
|
} else if (connPtr->staData.keyMgmtInfo.rom.keyMgmtState ==
|
WAITING_4_MSG4) {
|
status = ProcessPWKMsg4(priv, connPtr, pbuf, len);
|
} else if ((connPtr->staData.keyMgmtInfo.rom.keyMgmtState
|
== WAITING_4_GRPMSG2)
|
|| (connPtr->staData.keyMgmtInfo.rom.keyMgmtState
|
== WAITING_4_GRP_REKEY_MSG2)) {
|
status = ProcessGrpMsg2(priv, connPtr, pbuf, len);
|
}
|
}
|
LEAVE();
|
return ret;
|
}
|
|
/**
|
* @brief send eapol packet
|
*
|
* @param psapriv A void pointer to phostsa private struct
|
* @param pconnPtr a pointer to connection
|
* @
|
* @return
|
*/
|
t_void
|
AuthenticatorSendEapolPacket(t_void *priv, t_void *pconnPtr)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
cm_Connection *connPtr = (cm_Connection *)pconnPtr;
|
apInfo_t *pApInfo = &psapriv->apinfo;
|
|
ENTER();
|
/**check whether wpa/rsn is used*/
|
if (!connPtr->staData.RSNEnabled)
|
return;
|
|
/**init Mic error parameters*/
|
initMicErrorParams(pApInfo->bssConfig.SecType.wpa,
|
&connPtr->staData.apMicError);
|
connPtr->staData.keyMgmtInfo.rom.keyMgmtState = MSG1_PENDING;
|
//If it is in **_pending state
|
if (((connPtr->staData.keyMgmtInfo.rom.keyMgmtState) & 0x1) != 0) {
|
GenerateApEapolMsg(psapriv, connPtr,
|
connPtr->staData.keyMgmtInfo.rom.
|
keyMgmtState);
|
|
}
|
|
LEAVE();
|
}
|
|
/**
|
* @brief get station security infor from (re)assocaite request
|
*
|
* @param priv A void pointer to phostsa private struct
|
* @param pconnPtr a pointer to connection
|
* @param pIe a pointer to associate request
|
* @param ieLen len of ie
|
*
|
* @return
|
*/
|
void
|
authenticator_get_sta_security_info(void *priv,
|
t_void *pconnPtr, t_u8 *pIe, t_u8 ieLen)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
cm_Connection *connPtr = (cm_Connection *)pconnPtr;
|
IEPointers_t iePointers;
|
IEEEtypes_StatusCode_t retcode;
|
|
ENTER();
|
|
ieLen = GetIEPointers((t_void *)priv, pIe, ieLen, &iePointers);
|
|
assocSrvAp_CheckSecurity(connPtr, iePointers.pWps,
|
iePointers.pRsn, iePointers.pWpa,
|
iePointers.pWapi, &retcode);
|
/* clean key */
|
memset(util_fns, (t_u8 *)&connPtr->hskData, 0x00,
|
sizeof(eapolHskData_t));
|
|
LEAVE();
|
}
|
|
/**
|
* @brief initialize client
|
*
|
* @param priv A void pointer to phostsa private struct
|
* @param pconnPtr a pointer to pointer to connection
|
* @param mac a pointer to mac address
|
*
|
* @return
|
*/
|
void
|
authenticator_init_client(void *priv, void **ppconnPtr, t_u8 *mac)
|
{
|
phostsa_private psapriv = (hostsa_private *)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
cm_Connection *connPtr = MNULL;
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
ret = malloc(util_fns, sizeof(cm_Connection), (t_u8 **)&connPtr);
|
if ((ret != MLAN_STATUS_SUCCESS) || (!connPtr)) {
|
PRINTM(MERROR, "%s: could not allocate hostsa_private.\n",
|
__FUNCTION__);
|
ret = MLAN_STATUS_FAILURE;
|
goto done;
|
}
|
|
memset(util_fns, connPtr, 0x00, sizeof(cm_Connection));
|
connPtr->priv = priv;
|
memcpy(util_fns, connPtr->mac_addr, mac, MLAN_MAC_ADDR_LENGTH);
|
|
util_fns->moal_init_timer(util_fns->pmoal_handle, &connPtr->HskTimer,
|
KeyMgmtHskTimeout, connPtr);
|
util_fns->moal_init_timer(util_fns->pmoal_handle,
|
&connPtr->staData.apMicTimer,
|
ApMicErrTimerExpCb, connPtr);
|
|
done:
|
if (ret == MLAN_STATUS_SUCCESS)
|
*ppconnPtr = (void *)connPtr;
|
else
|
*ppconnPtr = MNULL;
|
LEAVE();
|
|
}
|
|
/**
|
* @brief free client
|
*
|
* @param priv A void pointer to phostsa private struct
|
* @param pconnPtr a pointer to connection
|
*
|
* @return
|
*/
|
void
|
authenticator_free_client(void *priv, void *ppconnPtr)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
cm_Connection *connPtr = (cm_Connection *)ppconnPtr;
|
|
ENTER();
|
|
if (connPtr) {
|
util_fns->moal_stop_timer(util_fns->pmoal_handle,
|
connPtr->HskTimer);
|
util_fns->moal_stop_timer(util_fns->pmoal_handle,
|
connPtr->staData.apMicTimer);
|
|
util_fns->moal_free_timer(util_fns->pmoal_handle,
|
connPtr->HskTimer);
|
util_fns->moal_free_timer(util_fns->pmoal_handle,
|
connPtr->staData.apMicTimer);
|
free(util_fns, (t_u8 *)connPtr);
|
}
|
LEAVE();
|
}
|
#endif
|
|
/**
|
* @brief Init hostsa data
|
*
|
* @param pphostsa_priv A pointer to pointer to a hostsa private data structure
|
* @param psa_util_fns A pointer to hostsa utility functions table
|
* @param psa_mlan_fns A pointer to MLAN APIs table
|
* @param addr a pointer to address
|
*
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
*/
|
mlan_status
|
supplicant_authenticator_init(t_void **pphostsa_priv, t_void *psa_util_fns,
|
t_void *psa_mlan_fns, t_u8 *addr)
|
{
|
hostsa_util_fns *putil_fns = (hostsa_util_fns *)psa_util_fns;
|
hostsa_mlan_fns *pmlan_fns = (hostsa_mlan_fns *)psa_mlan_fns;
|
mlan_status ret;
|
hostsa_private *priv = MNULL;
|
|
ENTER();
|
|
ret = malloc(putil_fns, sizeof(hostsa_private), (t_u8 **)&priv);
|
if ((ret != MLAN_STATUS_SUCCESS) || (!priv)) {
|
PRINTM(MERROR, "%s: could not allocate hostsa_private.\n",
|
__FUNCTION__);
|
ret = MLAN_STATUS_FAILURE;
|
goto done;
|
}
|
|
memset(putil_fns, priv, 0x00, sizeof(hostsa_private));
|
memset(putil_fns, &priv->apinfo, 0x00, sizeof(apInfo_t));
|
|
memcpy(putil_fns, &priv->util_fns, putil_fns, sizeof(hostsa_util_fns));
|
memcpy(putil_fns, &priv->mlan_fns, pmlan_fns, sizeof(hostsa_mlan_fns));
|
|
priv->pmlan_adapter = pmlan_fns->pmlan_adapter;
|
priv->pmlan_private = pmlan_fns->pmlan_private;
|
|
memcpy(putil_fns, priv->curr_addr, addr, MLAN_MAC_ADDR_LENGTH);
|
#ifdef DRV_EMBEDDED_AUTHENTICATOR
|
putil_fns->moal_init_timer(putil_fns->pmoal_handle,
|
&priv->GrpRekeytimer,
|
KeyMgmtGrpRekeyCountUpdate, priv);
|
/**Bss configure initialize*/
|
AuthenitcatorInitBssConfig(priv);
|
#endif
|
#ifdef DRV_EMBEDDED_SUPPLICANT
|
priv->suppData = MNULL;
|
allocSupplicantData(priv);
|
ret = initSupplicantTimer(priv);
|
if (ret != MLAN_STATUS_SUCCESS) {
|
goto done;
|
}
|
pmkCacheInit(priv);
|
pmkCacheRomInit();
|
keyMgmtSta_RomInit();
|
#endif
|
|
done:
|
if (ret == MLAN_STATUS_SUCCESS)
|
*pphostsa_priv = (t_void *)priv;
|
else
|
*pphostsa_priv = MNULL;
|
LEAVE();
|
return ret;
|
}
|
|
/**
|
* @brief Cleanup hostsa data
|
*
|
* @param phostsa_priv A pointer to a hostsa private data structure
|
*
|
* @return MLAN_STATUS_SUCCESS
|
*/
|
mlan_status
|
supplicant_authenticator_free(t_void *phostsa_priv)
|
{
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
phostsa_private priv = (hostsa_private *)phostsa_priv;
|
hostsa_util_fns *putil_fns = &priv->util_fns;
|
|
ENTER();
|
|
if (!phostsa_priv)
|
goto done;
|
#ifdef DRV_EMBEDDED_SUPPLICANT
|
freeSupplicantData(priv);
|
freeSupplicantTimer(priv);
|
#endif
|
#ifdef DRV_EMBEDDED_AUTHENTICATOR
|
putil_fns->moal_stop_timer(putil_fns->pmoal_handle,
|
priv->GrpRekeytimer);
|
putil_fns->moal_free_timer(putil_fns->pmoal_handle,
|
priv->GrpRekeytimer);
|
#endif
|
free(putil_fns, (t_u8 *)priv);
|
done:
|
LEAVE();
|
return ret;
|
}
|
