/** @file pmkcache.c
|
*
|
* @brief This file defines pmk cache functions
|
*
|
* 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
|
******************************************************/
|
#include "wl_macros.h"
|
#include "pass_phrase.h"
|
#include "pmkCache.h"
|
#include "hostsa_ext_def.h"
|
#include "authenticator.h"
|
#include "tlv.h"
|
#include "keyMgmtApStaCommon.h"
|
|
#define MAX_PMK_CACHE_ENTRIES 10
|
|
pmkElement_t pmkCache[MAX_PMK_CACHE_ENTRIES];
|
|
char PSKPassPhrase[PSK_PASS_PHRASE_LEN_MAX];
|
/*
|
** Replacement rank is used to determine which cache entry to replace
|
** once the cache is full. The rank order is determined by usage. The
|
** least recently used cache element is the first to be replaced.
|
**
|
** replacementRankMax is an indication of the number of cache entries used.
|
** It is used to determine the rank of the current cache entry used.
|
**
|
** Rank order goes from 1 to MAX_PMK_CACHE_ENTRIES. If the cache is full,
|
** the element with rank 1 is first to be replaced.
|
**
|
** Replacement rank of zero indicates that the entry is invalid.
|
*/
|
|
UINT8 *
|
pmkCacheFindPSK(void *priv, UINT8 *pSsid, UINT8 ssidLen)
|
{
|
UINT8 *pPMK = NULL;
|
pmkElement_t *pPMKElement;
|
|
if (!pPMK) {
|
/* extract the PSK from the cache entry */
|
pPMKElement =
|
pmkCacheFindPSKElement((void *)priv, pSsid, ssidLen);
|
if (pPMKElement) {
|
pPMK = pPMKElement->PMK;
|
} else if ('\0' != PSKPassPhrase[0]) {
|
/* Generate a new PSK entry with the
|
** provided passphrase.
|
*/
|
pmkCacheAddPSK((void *)priv, pSsid, ssidLen, NULL,
|
PSKPassPhrase);
|
pPMKElement =
|
pmkCacheFindPSKElement((void *)priv, pSsid,
|
ssidLen);
|
pmkCacheGeneratePSK((void *)priv, pSsid, ssidLen,
|
PSKPassPhrase, pPMKElement->PMK);
|
pPMK = pPMKElement->PMK;
|
}
|
}
|
|
return pPMK;
|
}
|
|
UINT8 *
|
pmkCacheFindPassphrase(void *priv, UINT8 *pSsid, UINT8 ssidLen)
|
{
|
UINT8 *pPassphrase = NULL;
|
pmkElement_t *pPMKElement;
|
|
if (!pPassphrase) {
|
/* extract the PSK from the cache entry */
|
pPMKElement =
|
pmkCacheFindPSKElement((void *)priv, pSsid, ssidLen);
|
if (pPMKElement) {
|
pPassphrase = pPMKElement->passphrase;
|
}
|
|
}
|
|
return pPassphrase;
|
}
|
|
void
|
pmkCacheSetPassphrase(void *priv, char *pPassphrase)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
|
if (pPassphrase != NULL) {
|
memcpy(util_fns, PSKPassPhrase,
|
pPassphrase, sizeof(PSKPassPhrase));
|
}
|
}
|
|
void
|
pmkCacheGetPassphrase(void *priv, char *pPassphrase)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
|
if (pPassphrase != NULL) {
|
memcpy(util_fns, pPassphrase,
|
PSKPassPhrase, sizeof(PSKPassPhrase));
|
}
|
}
|
|
void
|
pmkCacheInit(void *priv)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
|
memset(util_fns, pmkCache, 0x00, sizeof(pmkCache));
|
memset(util_fns, PSKPassPhrase, 0x00, sizeof(PSKPassPhrase));
|
replacementRankMax = 0;
|
}
|
|
void
|
pmkCacheFlush(void *priv)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
|
memset(util_fns, pmkCache, 0x00, sizeof(pmkCache));
|
replacementRankMax = 0;
|
}
|
|
//#pragma arm section code = ".init"
|
void
|
pmkCacheRomInit(void)
|
{
|
ramHook_MAX_PMK_CACHE_ENTRIES = MAX_PMK_CACHE_ENTRIES;
|
ramHook_pmkCache = &pmkCache[0];
|
ramHook_PSKPassPhrase = &PSKPassPhrase[0];
|
// ramHook_hal_SetCpuMaxSpeed = hal_SetCpuOpToSecuritySpeed;
|
// ramHook_hal_RestoreCpuSpeed = cm_SetPerformanceParams;
|
}
|
|
//#pragma arm section code
|
|
#ifdef DRV_EMBEDDED_SUPPLICANT
|
|
t_u16
|
SupplicantSetPassphrase(void *priv, void *pPassphraseBuf)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = NULL;
|
mlan_ds_passphrase *psk = (mlan_ds_passphrase *)pPassphraseBuf;
|
IEEEtypes_MacAddr_t *pBssid = NULL;
|
UINT8 *pPMK = NULL;
|
UINT8 Passphrase[PSK_PASS_PHRASE_LEN_MAX], *pPassphrase = NULL;
|
UINT8 *pSsid = NULL;
|
UINT8 ssidLen = 0;
|
UINT16 retVal = 0;
|
t_u8 zero_mac[] = { 0, 0, 0, 0, 0, 0 };
|
|
if (!psapriv)
|
return retVal;
|
util_fns = &psapriv->util_fns;
|
|
if (memcmp(util_fns, (t_u8 *)&psk->bssid, zero_mac, sizeof(zero_mac)))
|
pBssid = (IEEEtypes_MacAddr_t *)&psk->bssid;
|
|
ssidLen = psk->ssid.ssid_len;
|
if (ssidLen > 0)
|
pSsid = psk->ssid.ssid;
|
|
if (psk->psk_type == MLAN_PSK_PASSPHRASE) {
|
pPassphrase = psk->psk.passphrase.passphrase;
|
memset(util_fns, Passphrase, 0x00, sizeof(Passphrase));
|
memcpy(util_fns, Passphrase, pPassphrase,
|
MIN(MLAN_MAX_PASSPHRASE_LENGTH,
|
psk->psk.passphrase.passphrase_len));
|
}
|
|
if (psk->psk_type == MLAN_PSK_PMK)
|
pPMK = psk->psk.pmk.pmk;
|
|
/* Always enable the supplicant on a set */
|
// supplicantEnable(priv);
|
|
if (pBssid && pPMK) {
|
pmkCacheAddPMK(priv, pBssid, pPMK);
|
} else if (pSsid) {
|
if (pPMK) {
|
pmkCacheAddPSK(priv, pSsid, ssidLen, pPMK, NULL);
|
} else if (pPassphrase) {
|
pmkCacheAddPSK(priv, pSsid, ssidLen, NULL, Passphrase);
|
pPMK = pmkCacheFindPSK(priv, pSsid, ssidLen);
|
pmkCacheGeneratePSK(priv, pSsid, ssidLen,
|
(char *)Passphrase, pPMK);
|
} else {
|
/* Just an SSID so we can't set anything in the cache */
|
retVal = 1;
|
}
|
} else if (pPassphrase) {
|
memcpy(util_fns, PSKPassPhrase, Passphrase, sizeof(Passphrase));
|
} else {
|
/* Not enough data to set anything in the cache */
|
retVal = 1;
|
}
|
|
return retVal;
|
}
|
|
BOOLEAN
|
SupplicantClearPMK_internal(void *priv, void *pPassphraseBuf)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = &psapriv->util_fns;
|
mlan_ds_passphrase *psk = (mlan_ds_passphrase *)pPassphraseBuf;
|
IEEEtypes_MacAddr_t *pBssid = NULL;
|
UINT8 *pPassphrase = NULL;
|
UINT8 *pSsid = NULL;
|
UINT8 ssidLen = 0;
|
t_u8 zero_mac[] = { 0, 0, 0, 0, 0, 0 };
|
|
if (memcmp(util_fns, (t_u8 *)&psk->bssid, zero_mac, sizeof(zero_mac)))
|
pBssid = (IEEEtypes_MacAddr_t *)&psk->bssid;
|
|
ssidLen = psk->ssid.ssid_len;
|
if (ssidLen > 0)
|
pSsid = psk->ssid.ssid;
|
|
if (psk->psk_type == MLAN_PSK_PASSPHRASE)
|
pPassphrase = psk->psk.passphrase.passphrase;
|
|
if (pBssid) {
|
pmkCacheDeletePMK(priv, (UINT8 *)pBssid);
|
} else if (pSsid) {
|
pmkCacheDeletePSK(priv, pSsid, ssidLen);
|
} else if (pPassphrase) {
|
/* Clear the global passphrase by setting it to blank */
|
memset(util_fns, ramHook_PSKPassPhrase, 0x00,
|
PSK_PASS_PHRASE_LEN_MAX);
|
} else {
|
return FALSE;
|
}
|
|
return TRUE;
|
}
|
|
void
|
SupplicantClearPMK(void *priv, void *pPassphrase)
|
{
|
if (!priv)
|
return;
|
|
if (!SupplicantClearPMK_internal(priv, pPassphrase)) {
|
/* Always disable the supplicant on a flush */
|
supplicantDisable(priv);
|
pmkCacheFlush(priv);
|
}
|
}
|
|
void
|
SupplicantQueryPassphrase(void *priv, void *pPassphraseBuf)
|
{
|
phostsa_private psapriv = (phostsa_private)priv;
|
hostsa_util_fns *util_fns = NULL;
|
mlan_ds_passphrase *psk = (mlan_ds_passphrase *)pPassphraseBuf;
|
UINT8 *pPassphrase = NULL;
|
UINT8 *pSsid = NULL;
|
UINT8 ssidLen = 0;
|
|
if (!psapriv)
|
return;
|
|
util_fns = &psapriv->util_fns;
|
ssidLen = psk->ssid.ssid_len;
|
pSsid = psk->ssid.ssid;
|
|
if (ssidLen) {
|
pPassphrase = pmkCacheFindPassphrase(priv, pSsid, ssidLen);
|
if (pPassphrase) {
|
psk->psk_type = MLAN_PSK_PASSPHRASE;
|
memcpy(util_fns, psk->psk.passphrase.passphrase,
|
pPassphrase, PSK_PASS_PHRASE_LEN_MAX);
|
psk->psk.passphrase.passphrase_len =
|
wlan_strlen(pPassphrase);
|
}
|
}
|
|
}
|
#endif
|
