Orange Pi5 kernel

/** @file keyMgmtApStaCommon.c
 *
 *  @brief This file defines common api for authenticator and supplicant.
 *
 * 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 "keyMgmtAp_rom.h"
#include "crypt_new_rom.h"
#include "keyCommonDef.h"
#include "pmkCache_rom.h"
#include "crypt_new_rom.h"
#include "rc4_rom.h"
#include "aes_cmac_rom.h"
#include "sha1.h"
#include "md5.h"
#include "mrvl_sha256_crypto.h"

const UINT8 wpa_oui_none[4] = { 0x00, 0x50, 0xf2, 0x00 };
const UINT8 wpa_oui01[4] = { 0x00, 0x50, 0xf2, 0x01 };
const UINT8 wpa_oui02[4] = { 0x00, 0x50, 0xf2, 0x02 };
const UINT8 wpa_oui03[4] = { 0x00, 0x50, 0xf2, 0x03 };
const UINT8 wpa_oui04[4] = { 0x00, 0x50, 0xf2, 0x04 };
const UINT8 wpa_oui05[4] = { 0x00, 0x50, 0xf2, 0x05 };
const UINT8 wpa_oui06[4] = { 0x00, 0x50, 0xf2, 0x06 };

const UINT8 wpa2_oui01[4] = { 0x00, 0x0f, 0xac, 0x01 };
const UINT8 wpa2_oui02[4] = { 0x00, 0x0f, 0xac, 0x02 };
const UINT8 wpa2_oui03[4] = { 0x00, 0x0f, 0xac, 0x03 };
const UINT8 wpa2_oui04[4] = { 0x00, 0x0f, 0xac, 0x04 };
const UINT8 wpa2_oui05[4] = { 0x00, 0x0f, 0xac, 0x05 };
const UINT8 wpa2_oui06[4] = { 0x00, 0x0f, 0xac, 0x06 };

const UINT8 wpa_oui[3] = { 0x00, 0x50, 0xf2 };
const UINT8 kde_oui[3] = { 0x00, 0x0f, 0xac };

/**
 *  @brief strlen
 *
 *  @param str		        A pointer to string
 *
 *  @return                 Length of string
 */
t_u32
wlan_strlen(const char *str)
{
	t_u32 i;

	for (i = 0; str[i] != 0; i++) {
	}
	return i;
}

static t_u32
srand_new(void *priv)
{
	phostsa_private psapriv = (phostsa_private)priv;
	hostsa_util_fns *util_fns = &psapriv->util_fns;
	t_u32 sec, usec;

	ENTER();
	get_system_time(util_fns, &sec, &usec);
	sec = (sec & 0xFFFF) + (sec >> 16);
	usec = (usec & 0xFFFF) + (usec >> 16);

	LEAVE();
	return (usec << 16) | sec;
}

static unsigned int
rand_new(unsigned int seed, UINT32 randvaule)
{
	unsigned int next = seed;
	unsigned int result;

	next *= (3515245 * randvaule + randvaule * next);
	next += 12345 + randvaule * 7;
	result = (unsigned int)(next / 65536) % 2048;

	next *= (39018768 * randvaule + randvaule * next);
	next += 56789 + randvaule * 4;
	result <<= 10;
	result ^= (unsigned int)(next / 65536) % 1024;

	next *= (89042053 * randvaule + randvaule * next);
	next += 43728 + randvaule * 9;
	result <<= 10;
	result ^= (unsigned int)(next / 65536) % 1024;

	return result;
}

void
supplicantGenerateRand(hostsa_private *priv, UINT8 *dataOut, UINT32 length)
{
	UINT32 i;
	//UINT32 valueHi, valueLo;

	/* Read mac 0 timer.
	 ** Doesn't matter which one we read. We just need a good seed.
	 */
	//msi_wl_GetMCUCoreTimerTxTSF(&valueHi, &valueLo);
	//srand(valueLo);
	for (i = 0; i < length; i++) {
		//dataOut[i] = rand();
		dataOut[i] = rand_new(srand_new(priv), i + 1);
	}
}

void
SetEAPOLKeyDescTypeVersion(EAPOL_KeyMsg_Tx_t *pTxEapol,
			   BOOLEAN isWPA2, BOOLEAN isKDF, BOOLEAN nonTKIP)
{
	if (isWPA2) {
		/* WPA2 */
		pTxEapol->keyMsg.desc_type = 2;
	} else {
		/* WPA */
		pTxEapol->keyMsg.desc_type = 254;
	}

	if (isKDF) {
		/* 802.11r and 802.11w use SHA256-KDF and a different KeyDescVer */
		pTxEapol->keyMsg.key_info.KeyDescriptorVersion = 3;
	} else if (nonTKIP) {
		/* CCMP */
		pTxEapol->keyMsg.key_info.KeyDescriptorVersion = 2;
	} else {
		/* TKIP OR WEP */
		pTxEapol->keyMsg.key_info.KeyDescriptorVersion = 1;
	}
}

void
ComputeEAPOL_MIC(phostsa_private priv, EAPOL_KeyMsg_t *pKeyMsg,
		 UINT16 data_length,
		 UINT8 *MIC_Key, UINT8 MIC_Key_length, UINT8 micKeyDescVersion)
{
	int len = data_length;
	UINT8 *pMicData;

	pMicData = (UINT8 *)pKeyMsg;

	/* Allow the caller to override the algorithm used to get by some Cisco
	 **    CCX bugs where the wrong MIC algorithm is used
	 */
	if (micKeyDescVersion == 0) {
		/* Algorithm not specified, use proper one from key_info */
		micKeyDescVersion = pKeyMsg->key_info.KeyDescriptorVersion;
	}

	switch (micKeyDescVersion) {
	case 3:
		/* AES-128-CMAC */
		mrvl_aes_cmac(priv, MIC_Key, pMicData, len,
			      (UINT8 *)pKeyMsg->key_MIC);
		break;

	case 2:
		/* CCMP */
		Mrvl_hmac_sha1((t_void *)priv, &pMicData,
			       &len,
			       1,
			       MIC_Key,
			       (int)MIC_Key_length,
			       (UINT8 *)pKeyMsg->key_MIC, EAPOL_MIC_SIZE);
		break;

	default:
	case 1:
		/* TKIP  or WEP */
		Mrvl_hmac_md5((t_void *)priv, pMicData,
			      data_length,
			      MIC_Key,
			      (int)MIC_Key_length, (UINT8 *)pKeyMsg->key_MIC);
		break;
	}
}

/* Returns TRUE if EAPOL MIC check passes, FALSE otherwise. */
BOOLEAN
IsEAPOL_MICValid(phostsa_private priv, EAPOL_KeyMsg_t *pKeyMsg, UINT8 *pMICKey)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	UINT8 msgMIC[EAPOL_MIC_SIZE];

	/* pull the MIC */
	memcpy(util_fns, (UINT8 *)msgMIC, (UINT8 *)pKeyMsg->key_MIC,
	       EAPOL_MIC_SIZE);

	/* zero the MIC key field before calculating the data */
	memset(util_fns, (UINT8 *)pKeyMsg->key_MIC, 0x00, EAPOL_MIC_SIZE);

	ComputeEAPOL_MIC(priv, pKeyMsg, (ntohs(pKeyMsg->hdr_8021x.pckt_body_len)
					 + sizeof(pKeyMsg->hdr_8021x)),
			 pMICKey, EAPOL_MIC_KEY_SIZE, 0);

	if (memcmp(util_fns, (UINT8 *)pKeyMsg->key_MIC, msgMIC, EAPOL_MIC_SIZE)) {
#ifdef KEYMSG_DEBUG
		hostEventPrintf(assocAgent_getConnPtr(),
				"EAPOL MIC Failure: cmac(%d), sha1(%d), md5(%d)",
				(pKeyMsg->key_info.KeyDescriptorVersion == 3),
				(pKeyMsg->key_info.KeyDescriptorVersion == 2),
				(pKeyMsg->key_info.KeyDescriptorVersion == 1));
#endif
		/* MIC Failure */
		return FALSE;
	}

	return TRUE;
}

void
supplicantConstructContext(phostsa_private priv, UINT8 *pAddr1,
			   UINT8 *pAddr2,
			   UINT8 *pNonce1, UINT8 *pNonce2, UINT8 *pContext)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	if (memcmp(util_fns, pAddr1, pAddr2, 6) < 0) {
		memcpy(util_fns, pContext, pAddr1, sizeof(IEEEtypes_MacAddr_t));
		memcpy(util_fns, (pContext + 6), pAddr2,
		       sizeof(IEEEtypes_MacAddr_t));
	} else {
		memcpy(util_fns, pContext, pAddr2, sizeof(IEEEtypes_MacAddr_t));
		memcpy(util_fns, (pContext + 6), pAddr1,
		       sizeof(IEEEtypes_MacAddr_t));
	}

	if (memcmp(util_fns, pNonce1, pNonce2, NONCE_SIZE) < 0) {
		memcpy(util_fns, pContext + 6 + 6, pNonce1, NONCE_SIZE);
		memcpy(util_fns, pContext + 6 + 6 + NONCE_SIZE, pNonce2,
		       NONCE_SIZE);
	} else {
		memcpy(util_fns, pContext + 6 + 6, pNonce2, NONCE_SIZE);
		memcpy(util_fns, pContext + 6 + 6 + NONCE_SIZE, pNonce1,
		       NONCE_SIZE);
	}
}

UINT16
KeyMgmtSta_PopulateEAPOLLengthMic(phostsa_private priv,
				  EAPOL_KeyMsg_Tx_t *pTxEapol,
				  UINT8 *pEAPOLMICKey,
				  UINT8 eapolProtocolVersion,
				  UINT8 forceKeyDescVersion)
{
	UINT16 frameLen;

#if 0				//!defined(REMOVE_PATCH_HOOKS)
	if (KeyMgmtSta_PopulateEAPOLLengthMic_hook(pTxEapol,
						   pEAPOLMICKey,
						   eapolProtocolVersion,
						   forceKeyDescVersion,
						   &frameLen)) {
		return frameLen;
	}
#endif

	if (!pTxEapol) {
		return 0;
	}

	frameLen = sizeof(pTxEapol->keyMsg);
	frameLen -= sizeof(pTxEapol->keyMsg.hdr_8021x);
	frameLen -= sizeof(pTxEapol->keyMsg.key_data);
	frameLen += pTxEapol->keyMsg.key_material_len;

	pTxEapol->keyMsg.hdr_8021x.protocol_ver = eapolProtocolVersion;
	pTxEapol->keyMsg.hdr_8021x.pckt_type = IEEE_8021X_PACKET_TYPE_EAPOL_KEY;
	pTxEapol->keyMsg.hdr_8021x.pckt_body_len = htons(frameLen);

	pTxEapol->keyMsg.key_material_len
		= htons(pTxEapol->keyMsg.key_material_len);

	ComputeEAPOL_MIC(priv, &pTxEapol->keyMsg,
			 frameLen + sizeof(pTxEapol->keyMsg.hdr_8021x),
			 pEAPOLMICKey, EAPOL_MIC_KEY_SIZE, forceKeyDescVersion);

	return frameLen;
}

/*
**  This function generates the Pairwise transient key
*/
void
KeyMgmt_DerivePTK(phostsa_private priv, UINT8 *pAddr1,
		  UINT8 *pAddr2,
		  UINT8 *pNonce1,
		  UINT8 *pNonce2, UINT8 *pPTK, UINT8 *pPMK, BOOLEAN use_kdf)
{
	UINT8 *pContext;
	char *prefix;

	/* pPTK is expected to be an encryption pool buffer (at least 500 bytes).
	 **
	 ** Use the first portion for the ptk output.  Use memory in the end of
	 **   the buffer for the context construction (76 bytes).
	 **
	 ** The sha256 routine assumes available memory after the context for its
	 **   own sha256 output.  Space after the context (76 bytes) is required
	 **   for 2 digests (2 * 32).  pContext must have at least 76 + 64 bytes
	 **   available.
	 */
	pContext = pPTK + 200;

	supplicantConstructContext(priv, pAddr1, pAddr2, pNonce1, pNonce2,
				   pContext);

	prefix = "Pairwise key expansion";

	if (use_kdf) {
		mrvl_sha256_crypto_kdf((t_void *)priv, pPMK, PMK_LEN_MAX, prefix, 22,	/* strlen(prefix) */
				       pContext, 76,	/* sizeof constructed context */
				       pPTK, 384);
	} else {
		Mrvl_PRF((void *)priv, pPMK, PMK_LEN_MAX, (UINT8 *)prefix, 22,	/* strlen(prefix) */
			 pContext, 76,	/* sizeof constructed context */
			 pPTK, 64);
	}
}

void
KeyMgmtSta_DeriveKeys(hostsa_private *priv, UINT8 *pPMK,
		      UINT8 *da,
		      UINT8 *sa,
		      UINT8 *ANonce,
		      UINT8 *SNonce,
		      UINT8 *EAPOL_MIC_Key,
		      UINT8 *EAPOL_Encr_Key,
		      KeyData_t *newPWKey, BOOLEAN use_kdf)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
//    phostsa_private psapriv = (phostsa_private) priv;
	//   hostsa_util_fns  *util_fns = &psapriv->util_fns;
	//BufferDesc_t* pBufDesc = NULL;
	UINT8 buf[500] = { 0 };
	TkipPtk_t *pPtk;

#if 0
#if !defined(REMOVE_PATCH_HOOKS)
	if (KeyMgmtSta_DeriveKeys_hook(pPMK,
				       da,
				       sa,
				       ANonce,
				       SNonce,
				       EAPOL_MIC_Key,
				       EAPOL_Encr_Key, newPWKey, use_kdf)) {
		return;
	}
#endif
#endif
	if (!pPMK || !EAPOL_MIC_Key || !newPWKey) {
		return;
	}
#if 0
	/* Wait forever ensures a buffer */
	pBufDesc = (BufferDesc_t *) bml_AllocBuffer(ramHook_encrPoolConfig,
						    500, BML_WAIT_FOREVER);
	pPtk = (TkipPtk_t *)BML_DATA_PTR(pBufDesc);
#endif
	pPtk = (TkipPtk_t *)buf;

	KeyMgmt_DerivePTK(priv, sa, da, ANonce, SNonce, (UINT8 *)pPtk, pPMK,
			  use_kdf);

	memcpy(util_fns, EAPOL_MIC_Key, pPtk->kck, sizeof(pPtk->kck));
	memcpy(util_fns, EAPOL_Encr_Key, pPtk->kek, sizeof(pPtk->kek));
	memcpy(util_fns, newPWKey->Key, pPtk->tk, sizeof(pPtk->tk));

	memcpy(util_fns, newPWKey->RxMICKey,
	       pPtk->rxMicKey, sizeof(pPtk->rxMicKey));

	memcpy(util_fns, newPWKey->TxMICKey,
	       pPtk->txMicKey, sizeof(pPtk->txMicKey));

//    bml_FreeBuffer((UINT32)pBufDesc);
}

void
UpdateEAPOLWcbLenAndTransmit(hostsa_private *priv, pmlan_buffer pmbuf,
			     UINT16 frameLen)
{
	hostsa_mlan_fns *pm_fns = &priv->mlan_fns;

	pm_fns->hostsa_tx_packet(priv->pmlan_private, pmbuf, frameLen);
}

void
formEAPOLEthHdr(phostsa_private priv, EAPOL_KeyMsg_Tx_t *pTxEapol,
		t_u8 *da, t_u8 *sa)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	memcpy(util_fns, (void *)pTxEapol->ethHdr.da, da,
	       IEEEtypes_ADDRESS_SIZE);
	memcpy(util_fns, (void *)pTxEapol->ethHdr.sa, sa,
	       IEEEtypes_ADDRESS_SIZE);
	pTxEapol->ethHdr.type = 0x8E88;
}

void
supplicantParseWpaIe(phostsa_private priv, IEEEtypes_WPAElement_t *pIe,
		     SecurityMode_t *pWpaType,
		     Cipher_t *pMcstCipher,
		     Cipher_t *pUcstCipher,
		     AkmSuite_t *pAkmList, UINT8 akmOutMax)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	IEEEtypes_WPAElement_t *pTemp = pIe;
	int count;
	int akmCount = akmOutMax;
	AkmSuite_t *pAkm = pAkmList;

	memset(util_fns, pMcstCipher, 0x00, sizeof(Cipher_t));
	memset(util_fns, pUcstCipher, 0x00, sizeof(Cipher_t));
	memset(util_fns, pAkmList, 0x00, akmOutMax * sizeof(AkmSuite_t));
	memset(util_fns, pWpaType, 0x00, sizeof(SecurityMode_t));

	pWpaType->wpa = 1;

	/* record the AP's multicast cipher */
	if (!memcmp
	    (util_fns, (char *)pTemp->GrpKeyCipher, wpa_oui02,
	     sizeof(wpa_oui02))) {
		/* WPA TKIP */
		pMcstCipher->tkip = 1;
	} else if (!memcmp
		   (util_fns, (char *)pTemp->GrpKeyCipher, wpa_oui04,
		    sizeof(wpa_oui04))) {
		/* WPA AES */
		pMcstCipher->ccmp = 1;
	} else if (!memcmp
		   (util_fns, (char *)pTemp->GrpKeyCipher, wpa_oui01,
		    sizeof(wpa_oui01))) {
		/* WPA WEP 40 */
		pMcstCipher->wep40 = 1;
	} else if (!memcmp
		   (util_fns, (char *)pTemp->GrpKeyCipher, wpa_oui05,
		    sizeof(wpa_oui05))) {
		/* WPA WEP 104 */
		pMcstCipher->wep104 = 1;
	}

	count = wlan_le16_to_cpu(pTemp->PwsKeyCnt);

	while (count) {
		/* record the AP's unicast cipher */
		if (!memcmp(util_fns, (char *)pTemp->PwsKeyCipherList,
			    wpa_oui02, sizeof(wpa_oui02))) {
			/* WPA TKIP */
			pUcstCipher->tkip = 1;
		} else if (!memcmp(util_fns, (char *)pTemp->PwsKeyCipherList,
				   wpa_oui04, sizeof(wpa_oui04))) {
			/* WPA AES */
			pUcstCipher->ccmp = 1;
		}
		count--;

		if (count) {
			pTemp = (IEEEtypes_WPAElement_t *)((UINT8 *)pTemp +
							   sizeof(pTemp->
								  PwsKeyCipherList));
		}
	}

	count = wlan_le16_to_cpu(pTemp->AuthKeyCnt);

	while (count) {
		if (akmCount) {
			/* Store the AKM */
			memcpy(util_fns, pAkm,
			       (char *)pTemp->AuthKeyList,
			       sizeof(pTemp->AuthKeyList));
			pAkm++;
			akmCount--;
		}

		count--;

		if (count) {
			pTemp = (IEEEtypes_WPAElement_t *)((UINT8 *)pTemp
							   +
							   sizeof(pTemp->
								  AuthKeyList));
		}
	}

	if (!memcmp(util_fns, pAkmList, wpa_oui_none, sizeof(wpa_oui_none))) {
		pWpaType->wpaNone = 1;
	}
}

void
supplicantParseMcstCipher(phostsa_private priv, Cipher_t *pMcstCipherOut,
			  UINT8 *pGrpKeyCipher)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	memset(util_fns, pMcstCipherOut, 0x00, sizeof(Cipher_t));

	/* record the AP's multicast cipher */
	if (!memcmp(util_fns, pGrpKeyCipher, wpa2_oui02, sizeof(wpa2_oui02))) {
		/* WPA2 TKIP */
		pMcstCipherOut->tkip = 1;
	} else if (!memcmp
		   (util_fns, pGrpKeyCipher, wpa2_oui04, sizeof(wpa2_oui04))) {
		/* WPA2 AES */
		pMcstCipherOut->ccmp = 1;
	} else if (!memcmp
		   (util_fns, pGrpKeyCipher, wpa2_oui01, sizeof(wpa2_oui01))) {
		/* WPA2 WEP 40 */
		pMcstCipherOut->wep40 = 1;
	} else if (!memcmp
		   (util_fns, pGrpKeyCipher, wpa2_oui05, sizeof(wpa2_oui05))) {
		/* WPA2 WEP 104 */
		pMcstCipherOut->wep104 = 1;
	}
}

void
supplicantParseUcstCipher(phostsa_private priv, Cipher_t *pUcstCipherOut,
			  UINT8 pwsKeyCnt, UINT8 *pPwsKeyCipherList)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	UINT8 count;

	memset(util_fns, pUcstCipherOut, 0x00, sizeof(Cipher_t));

	/* Cycle through the PwsKeyCipherList and record each unicast cipher */
	for (count = 0; count < pwsKeyCnt; count++) {
		/* record the AP's unicast cipher */
		if (!memcmp(util_fns, pPwsKeyCipherList + (count * 4),
			    wpa2_oui02, sizeof(wpa2_oui02))) {
			/* WPA2 TKIP */
			pUcstCipherOut->tkip = 1;
		} else if (!memcmp(util_fns, pPwsKeyCipherList + (count * 4),
				   wpa2_oui04, sizeof(wpa2_oui04))) {
			/* WPA2 AES */
			pUcstCipherOut->ccmp = 1;
		}
	}
}

void
supplicantParseRsnIe(phostsa_private priv, IEEEtypes_RSNElement_t *pRsnIe,
		     SecurityMode_t *pWpaTypeOut,
		     Cipher_t *pMcstCipherOut,
		     Cipher_t *pUcstCipherOut,
		     AkmSuite_t *pAkmListOut,
		     UINT8 akmOutMax,
		     IEEEtypes_RSNCapability_t *pRsnCapOut,
		     Cipher_t *pGrpMgmtCipherOut)
{
	hostsa_util_fns *util_fns = &priv->util_fns;
	UINT8 *pIeData;
	UINT8 *pIeEnd;
	UINT8 *pGrpKeyCipher;
	UINT16 pwsKeyCnt;
	UINT8 *pPwsKeyCipherList;
	UINT16 authKeyCnt;
	UINT8 *pAuthKeyList;

	IEEEtypes_RSNCapability_t *pRsnCap;

	UINT16 *pPMKIDCnt;
	UINT16 PMKIDCnt;

	UINT8 *pGrpMgmtCipher;
#if 0
#if !defined(REMOVE_PATCH_HOOKS)
	if (supplicantParseRsnIe_hook(pRsnIe,
				      pWpaTypeOut,
				      pMcstCipherOut,
				      pUcstCipherOut,
				      pAkmListOut,
				      akmOutMax,
				      pRsnCapOut, pGrpMgmtCipherOut)) {
		return;
	}
#endif
#endif
	memset(util_fns, pWpaTypeOut, 0x00, sizeof(SecurityMode_t));

	pWpaTypeOut->wpa2 = 1;

	/* Set the start and end of the IE data */
	pIeData = (UINT8 *)&pRsnIe->Ver;
	pIeEnd = pIeData + pRsnIe->Len;

	/* Skip past the version field */
	pIeData += sizeof(pRsnIe->Ver);

	/* Parse the group key cipher list */
	pGrpKeyCipher = pIeData;
	pIeData += sizeof(pRsnIe->GrpKeyCipher);
	supplicantParseMcstCipher(priv, pMcstCipherOut, pGrpKeyCipher);

	/* Parse the pairwise key cipher list */
	pwsKeyCnt = wlan_le16_to_cpu(*(UINT16 *)pIeData);
	pIeData += sizeof(pRsnIe->PwsKeyCnt);

	pPwsKeyCipherList = pIeData;
	pIeData += pwsKeyCnt * sizeof(pRsnIe->PwsKeyCipherList);
	supplicantParseUcstCipher(priv, pUcstCipherOut, pwsKeyCnt,
				  pPwsKeyCipherList);

	/* Parse and return the AKM list */
	authKeyCnt = wlan_le16_to_cpu(*(UINT16 *)pIeData);
	pIeData += sizeof(pRsnIe->AuthKeyCnt);

	pAuthKeyList = pIeData;
	pIeData += authKeyCnt * sizeof(pRsnIe->AuthKeyList);
	memset(util_fns, pAkmListOut, 0x00, akmOutMax * sizeof(AkmSuite_t));
	memcpy(util_fns, pAkmListOut,
	       pAuthKeyList,
	       MIN(authKeyCnt, akmOutMax) * sizeof(pRsnIe->AuthKeyList));

	DBG_HEXDUMP(MCMD_D, " pAuthKeyList",
		    (t_u8 *)pAuthKeyList, MIN(authKeyCnt,
					      akmOutMax) *
		    sizeof(pRsnIe->AuthKeyList));
	DBG_HEXDUMP(MCMD_D, " pAuthKeyList", (t_u8 *)pAkmListOut,
		    MIN(authKeyCnt, akmOutMax) * sizeof(pRsnIe->AuthKeyList));
	/* Check if the RSN Capability is included */
	if (pIeData < pIeEnd) {
		pRsnCap = (IEEEtypes_RSNCapability_t *)pIeData;
		pIeData += sizeof(pRsnIe->RsnCap);

		if (pRsnCapOut) {
			memcpy(util_fns, pRsnCapOut, pRsnCap,
			       sizeof(IEEEtypes_RSNCapability_t));
		}
	}

	/* Check if the PMKID count is included */
	if (pIeData < pIeEnd) {
		pPMKIDCnt = (UINT16 *)pIeData;
		PMKIDCnt = wlan_le16_to_cpu(*pPMKIDCnt);
		pIeData += sizeof(pRsnIe->PMKIDCnt);

		/* Check if the PMKID List is included */
		if (pIeData < pIeEnd) {
			/* pPMKIDList = pIeData; <-- Currently not used in parsing */
			pIeData += PMKIDCnt * sizeof(pRsnIe->PMKIDList);
		}
	}

	/* Check if the Group Mgmt Cipher is included */
	if (pIeData < pIeEnd) {
		pGrpMgmtCipher = pIeData;

		if (pGrpMgmtCipherOut) {
			memcpy(util_fns, pGrpMgmtCipherOut,
			       pGrpMgmtCipher, sizeof(pRsnIe->GrpMgmtCipher));
		}
	}
}