1 /** @file Authenticator_api.c
2 *
3 * @brief This file defines the main APIs for authenticator.
4 *
5 * Copyright (C) 2014-2017, Marvell International Ltd.
6 *
7 * This software file (the "File") is distributed by Marvell International
8 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
9 * (the "License"). You may use, redistribute and/or modify this File in
10 * accordance with the terms and conditions of the License, a copy of which
11 * is available by writing to the Free Software Foundation, Inc.,
12 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
13 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14 *
15 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
17 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
18 * this warranty disclaimer.
19 */
20
21 /******************************************************
22 Change log:
23 03/07/2014: Initial version
24 ******************************************************/
25 //Authenticator related function definitions
26 #include "wltypes.h"
27 #include "IEEE_types.h"
28
29 #include "hostsa_ext_def.h"
30 #include "authenticator.h"
31
32 #include "wl_macros.h"
33 #include "wlpd.h"
34 #include "pass_phrase.h"
35 #include "sha1.h"
36 #include "crypt_new.h"
37 #include "parser.h"
38 #include "keyCommonDef.h"
39 #include "keyMgmtStaTypes.h"
40 #include "AssocAp_srv_rom.h"
41 #include "pmkCache.h"
42 #include "keyMgmtApTypes.h"
43 #include "keyMgmtAp.h"
44 #include "rc4.h"
45 #include "keyMgmtAp.h"
46
47 /*********************
48 Local Variables
49 *********************/
50
51 /*********************
52 Global Variables
53 *********************/
54
55 /*********************
56 Local Functions
57 *********************/
58
59 /*********************
60 Global Functions
61 *********************/
62 #ifdef DRV_EMBEDDED_SUPPLICANT
63 extern void allocSupplicantData(void *phostsa_priv);
64 extern void freeSupplicantData(void *phostsa_priv);
65 extern mlan_status initSupplicantTimer(void *priv);
66 extern void keyMgmtSta_RomInit(void);
67 extern void freeSupplicantTimer(void *priv);
68 #endif
69
70 /*********************
71 Utility Handler
72 *********************/
73 #ifdef DRV_EMBEDDED_AUTHENTICATOR
74 static UINT32
util_CountBits(UINT32 val)75 util_CountBits(UINT32 val)
76 {
77 UINT32 count = 0;
78
79 for (count = 0; val; count++) {
80 val &= (val - 1);
81 }
82 return count;
83 }
84
85 static void
initMicErrorParams(UINT32 wpa,MIC_Error_t * pApMicError)86 initMicErrorParams(UINT32 wpa, MIC_Error_t *pApMicError)
87 {
88 if (wpa) {
89 pApMicError->MICCounterMeasureEnabled = 1;
90 pApMicError->disableStaAsso = 0;
91 pApMicError->status = NO_MIC_FAILURE;
92 }
93 }
94
95 /**
96 * @brief whether authenticator is enabled or not
97 *
98 * @param priv A void pointer to phostsa private struct
99 *
100 * @return
101 */
102 t_u8
IsAuthenticatorEnabled(void * priv)103 IsAuthenticatorEnabled(void *priv)
104 {
105 phostsa_private psapriv = (phostsa_private)priv;
106 apInfo_t *pApInfo = NULL;
107 apRsnConfig_t *pRsnConfig = NULL;
108 t_u8 ret = 0;
109
110 ENTER();
111
112 if (!psapriv) {
113 LEAVE();
114 return ret;
115 }
116
117 pApInfo = &psapriv->apinfo;
118 if (pApInfo == NULL) {
119 LEAVE();
120 return ret;
121 }
122
123 pRsnConfig = &pApInfo->bssConfig.RsnConfig;
124
125 // If Passphrase lengh is nonozero then
126 // authenticator in the driver is to be used,
127 // otherwise authenticator in the host is not to be used.
128 if (pRsnConfig->PSKPassPhraseLen != 0) {
129 ret = 1;
130 }
131
132 LEAVE();
133 return ret;
134 }
135
136 /**
137 * @brief BSS configure initialized
138 *
139 * @param priv A void pointer to phostsa private struct
140 *
141 * @return
142 */
143 void
AuthenitcatorInitBssConfig(void * priv)144 AuthenitcatorInitBssConfig(void *priv)
145 {
146 phostsa_private psapriv = (phostsa_private)priv;
147 hostsa_util_fns *util_fns = MNULL;
148 apInfo_t *pApInfo = MNULL;
149 BssConfig_t *pBssConfig = MNULL;
150 apRsnConfig_t *pRsnConfig = MNULL;
151
152 ENTER();
153
154 if (!psapriv) {
155 LEAVE();
156 return;
157 }
158 util_fns = &psapriv->util_fns;
159 pApInfo = &psapriv->apinfo;
160 pBssConfig = &pApInfo->bssConfig;
161 pRsnConfig = &pBssConfig->RsnConfig;
162
163 memset(util_fns, pBssConfig, 0x00, sizeof(BssConfig_t));
164 /**default ap ssid*/
165 pBssConfig->SsIdLen = wlan_strlen(AP_DEFAULT_SSID);
166 memset(util_fns, pBssConfig->SsId, 0x00, IEEEtypes_SSID_SIZE);
167 memcpy(util_fns, pBssConfig->SsId, AP_DEFAULT_SSID,
168 IEEEtypes_SSID_SIZE);
169 /**default retry times ans timeout*/
170 pRsnConfig->PwsHskTimeOut = PWS_HSK_TIMEOUT;
171 pRsnConfig->MaxPwsHskRetries = PWS_HSK_RETRIES;
172 pRsnConfig->GrpHskTimeOut = GRP_HSK_TIMEOUT;
173 pRsnConfig->MaxGrpHskRetries = GRP_HSK_RETRIES;
174 /**Group key rekey time*/
175 pRsnConfig->GrpReKeyTime = GRP_REKEY_TIME;
176
177 LEAVE();
178 }
179
180 /**
181 * @brief get bss config
182 *
183 * @param priv A void pointer to phostsa private struct
184 * @param pbss_config a pointer to mlan_uap_bss_param
185 * @param SetConfigToMlan 1 set releated config to mlan , 0 get related config from mlan
186 *
187 * @return
188 */
189 void
AuthenticatorGetBssConfig(hostsa_private * psapriv,t_u8 * pbss_config,t_u8 SetConfigToMlan)190 AuthenticatorGetBssConfig(hostsa_private *psapriv, t_u8 *pbss_config,
191 t_u8 SetConfigToMlan)
192 {
193 hostsa_util_fns *util_fns = &psapriv->util_fns;
194 apInfo_t *pApInfo = &psapriv->apinfo;
195 mlan_uap_bss_param *bss_config = (mlan_uap_bss_param *)pbss_config;
196 BssConfig_t *pBssConfig = MNULL;
197 apRsnConfig_t *pRsnConfig = MNULL;
198 t_u8 zero_mac[] = { 0, 0, 0, 0, 0, 0 };
199
200 ENTER();
201
202 pBssConfig = &pApInfo->bssConfig;
203 pRsnConfig = &pBssConfig->RsnConfig;
204
205 /**set bss config to mlan*/
206 if (SetConfigToMlan) {
207 if ((pRsnConfig->PwsHskTimeOut != 0) &&
208 (pRsnConfig->PwsHskTimeOut < (MAX_VALID_DWORD))) {
209 bss_config->pairwise_update_timeout =
210 pRsnConfig->PwsHskTimeOut;
211 }
212
213 if ((pRsnConfig->MaxPwsHskRetries != 0) &&
214 (pRsnConfig->MaxPwsHskRetries < (MAX_VALID_DWORD)))
215 bss_config->pwk_retries = pRsnConfig->MaxPwsHskRetries;
216
217 if ((pRsnConfig->GrpHskTimeOut != 0) &&
218 (pRsnConfig->GrpHskTimeOut < (MAX_VALID_DWORD)))
219 bss_config->groupwise_update_timeout =
220 pRsnConfig->GrpHskTimeOut;
221
222 if ((pRsnConfig->MaxGrpHskRetries != 0) &&
223 (pRsnConfig->MaxGrpHskRetries < (MAX_VALID_DWORD)))
224 bss_config->gwk_retries = pRsnConfig->MaxGrpHskRetries;
225
226 if (pRsnConfig->PSKPassPhraseLen != 0) {
227 bss_config->wpa_cfg.length =
228 pRsnConfig->PSKPassPhraseLen;
229 memcpy(util_fns, bss_config->wpa_cfg.passphrase,
230 pRsnConfig->PSKPassPhrase,
231 pRsnConfig->PSKPassPhraseLen);
232 }
233
234 if ((pRsnConfig->GrpReKeyTime != 0) &&
235 (pRsnConfig->GrpReKeyTime < MAX_GRP_TIMER))
236 bss_config->wpa_cfg.gk_rekey_time =
237 pRsnConfig->GrpReKeyTime;
238
239 LEAVE();
240 return;
241 }
242
243 if (((pBssConfig->SsIdLen != bss_config->ssid.ssid_len) ||
244 (memcmp(util_fns, pBssConfig->SsId,
245 bss_config->ssid.ssid, bss_config->ssid.ssid_len) != 0)) &&
246 bss_config->ssid.ssid_len) {
247 pApInfo->bssData.updatePassPhrase = 1;
248 memcpy(util_fns, pBssConfig->SsId, bss_config->ssid.ssid,
249 bss_config->ssid.ssid_len);
250 pBssConfig->SsIdLen = bss_config->ssid.ssid_len;
251 }
252
253 if (memcmp
254 (util_fns, zero_mac, &bss_config->mac_addr, MLAN_MAC_ADDR_LENGTH)) {
255 memset(util_fns, psapriv->curr_addr, 0x00,
256 MLAN_MAC_ADDR_LENGTH);
257 memcpy(util_fns, psapriv->curr_addr, &bss_config->mac_addr,
258 MLAN_MAC_ADDR_LENGTH);
259 }
260
261 if ((bss_config->max_sta_count != 0) &&
262 (bss_config->max_sta_count <= MAX_STA_COUNT))
263 pBssConfig->MaxStaSupported = bss_config->max_sta_count;
264
265 if ((bss_config->pairwise_update_timeout != 0) &&
266 (bss_config->pairwise_update_timeout < (MAX_VALID_DWORD))) {
267 pRsnConfig->PwsHskTimeOut = bss_config->pairwise_update_timeout;
268 }
269
270 if ((bss_config->pwk_retries != 0) &&
271 (bss_config->pwk_retries < (MAX_VALID_DWORD)))
272 pRsnConfig->MaxPwsHskRetries = bss_config->pwk_retries;
273
274 if ((bss_config->groupwise_update_timeout != 0) &&
275 (bss_config->groupwise_update_timeout < (MAX_VALID_DWORD)))
276 pRsnConfig->GrpHskTimeOut =
277 bss_config->groupwise_update_timeout;
278
279 if ((bss_config->gwk_retries != 0) &&
280 (bss_config->gwk_retries < (MAX_VALID_DWORD)))
281 pRsnConfig->MaxGrpHskRetries = bss_config->gwk_retries;
282
283 if ((bss_config->auth_mode <= MLAN_AUTH_MODE_SHARED) ||
284 (bss_config->auth_mode == MLAN_AUTH_MODE_AUTO))
285 pBssConfig->AuthType = bss_config->auth_mode;
286
287 memcpy(util_fns, &pBssConfig->SecType, &bss_config->protocol,
288 sizeof(pBssConfig->SecType));
289
290 if ((bss_config->protocol & PROTOCOL_WPA) ||
291 (bss_config->protocol & PROTOCOL_WPA2) ||
292 (bss_config->protocol & PROTOCOL_EAP)) {
293 pRsnConfig->AuthKey = bss_config->key_mgmt;
294 pRsnConfig->AuthKeyCount = util_CountBits(pRsnConfig->AuthKey);
295 memcpy(util_fns, (char *)&pRsnConfig->Akmp,
296 (char *)&bss_config->key_mgmt_operation,
297 sizeof(bss_config->key_mgmt_operation));
298
299 if ((bss_config->wpa_cfg.
300 pairwise_cipher_wpa & VALID_CIPHER_BITMAP) &&
301 (bss_config->wpa_cfg.pairwise_cipher_wpa != 0xff)) {
302 memset(util_fns, (t_u8 *)&pRsnConfig->wpaUcstCipher,
303 0x00, sizeof(Cipher_t));
304 memcpy(util_fns, (t_u8 *)&pRsnConfig->wpaUcstCipher,
305 (t_u8 *)&bss_config->wpa_cfg.pairwise_cipher_wpa,
306 sizeof(Cipher_t));
307 pRsnConfig->wpaUcstCipherCount =
308 util_CountBits(bss_config->wpa_cfg.
309 pairwise_cipher_wpa);
310 }
311
312 if ((bss_config->wpa_cfg.
313 pairwise_cipher_wpa2 & VALID_CIPHER_BITMAP) &&
314 (bss_config->wpa_cfg.pairwise_cipher_wpa2 != 0xff)) {
315 memset(util_fns, (t_u8 *)&pRsnConfig->wpa2UcstCipher,
316 0x00, sizeof(Cipher_t));
317 memcpy(util_fns, (t_u8 *)&pRsnConfig->wpa2UcstCipher,
318 (t_u8 *)&bss_config->wpa_cfg.
319 pairwise_cipher_wpa2, sizeof(Cipher_t));
320 pRsnConfig->wpa2UcstCipherCount =
321 util_CountBits(bss_config->wpa_cfg.
322 pairwise_cipher_wpa2);
323 }
324 DBG_HEXDUMP(MCMD_D, " wpa2UcstCipher",
325 (t_u8 *)&pRsnConfig->wpa2UcstCipher,
326 sizeof(Cipher_t));
327 DBG_HEXDUMP(MCMD_D, " wpaUcastCipher",
328 (t_u8 *)&pRsnConfig->wpaUcstCipher,
329 sizeof(Cipher_t));
330
331 if (bss_config->wpa_cfg.group_cipher & VALID_CIPHER_BITMAP) {
332 memset(util_fns, (t_u8 *)&pRsnConfig->mcstCipher, 0x00,
333 sizeof(Cipher_t));
334 memcpy(util_fns, (t_u8 *)&pRsnConfig->mcstCipher,
335 (t_u8 *)&bss_config->wpa_cfg.group_cipher,
336 sizeof(Cipher_t));
337 pRsnConfig->mcstCipherCount =
338 util_CountBits(bss_config->wpa_cfg.
339 group_cipher);
340 }
341
342 if (bss_config->wpa_cfg.rsn_protection <= MTRUE)
343 pRsnConfig->RSNReplayProtEn =
344 bss_config->wpa_cfg.
345 rsn_protection ? MTRUE : MFALSE;
346
347 }
348
349 if (((pRsnConfig->PSKPassPhraseLen != bss_config->wpa_cfg.length) ||
350 (memcmp(util_fns, pRsnConfig->PSKPassPhrase,
351 bss_config->wpa_cfg.passphrase,
352 bss_config->wpa_cfg.length) != 0)) &&
353 bss_config->wpa_cfg.length) {
354 pApInfo->bssData.updatePassPhrase = 1;
355 pRsnConfig->PSKPassPhraseLen = bss_config->wpa_cfg.length;
356 memset(util_fns, pRsnConfig->PSKPassPhrase,
357 0x00, PSK_PASS_PHRASE_LEN_MAX);
358 memcpy(util_fns, pRsnConfig->PSKPassPhrase,
359 bss_config->wpa_cfg.passphrase,
360 bss_config->wpa_cfg.length);
361 }
362
363 if ((bss_config->wpa_cfg.gk_rekey_time != 0) &&
364 (bss_config->wpa_cfg.gk_rekey_time < MAX_GRP_TIMER))
365 pRsnConfig->GrpReKeyTime = bss_config->wpa_cfg.gk_rekey_time;
366
367 LEAVE();
368 }
369
370 /**
371 * @brief get bss config for authenticator and append wpa/rsn ie to FW
372 *
373 * @param priv A void pointer to phostsa private struct
374 * @param pbss_config a pointer to mlan_uap_bss_param
375 * @param appendIE 1 append rsn/wpa ie to fw, 0 not append
376 * @param clearIE 1 clear rsn/wpa ie to fw, 0 not clear
377 * @param SetConfigToMlan 1 set releated config to mlan , 0 get related config from mlan
378 *
379 *
380 * @return
381 */
382 t_u8
AuthenticatorBssConfig(void * priv,t_u8 * pbss_config,t_u8 appendIE,t_u8 clearIE,t_u8 SetConfigToMlan)383 AuthenticatorBssConfig(void *priv, t_u8 *pbss_config, t_u8 appendIE,
384 t_u8 clearIE, t_u8 SetConfigToMlan)
385 {
386 phostsa_private psapriv = (phostsa_private)priv;
387 hostsa_util_fns *util_fns = MNULL;
388 hostsa_mlan_fns *pm_fns = MNULL;
389 apInfo_t *pApInfo = MNULL;
390 BssConfig_t *pBssConfig = MNULL;
391 apRsnConfig_t *pRsnConfig = MNULL;
392 t_u16 ielen = 0;
393 t_u8 ret = 0;
394
395 ENTER();
396
397 if (!psapriv) {
398 LEAVE();
399 return ret;
400 }
401 util_fns = &psapriv->util_fns;
402 pm_fns = &psapriv->mlan_fns;
403 pApInfo = &psapriv->apinfo;
404
405 pBssConfig = &pApInfo->bssConfig;
406 pRsnConfig = &pBssConfig->RsnConfig;
407
408 if (pbss_config)
409 AuthenticatorGetBssConfig(psapriv, pbss_config,
410 SetConfigToMlan);
411
412 if (appendIE && pRsnConfig->PSKPassPhraseLen &&
413 (pBssConfig->SecType.wpa || pBssConfig->SecType.wpa2 ||
414 pBssConfig->SecType.wpaNone)) {
415 PRINTM(MMSG, "authenticator set mgmt IE\n");
416 if (pBssConfig->wpa_ielen) {
417 pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
418 pBssConfig->wpa_ie,
419 pBssConfig->wpa_ielen, 1);
420 pBssConfig->wpa_ielen = 0;
421 memset(util_fns, pBssConfig->wpa_ie, 0x00, MAX_IE_SIZE);
422 }
423 /**construct wpa or RSN ie*/
424 if (pBssConfig->SecType.wpa) {
425 memset(util_fns, pBssConfig->wpa_ie, 0x00, MAX_IE_SIZE);
426 ielen = keyMgmtAp_FormatWPARSN_IE(psapriv,
427 (IEEEtypes_InfoElementHdr_t
428 *)pBssConfig->wpa_ie,
429 0,
430 &pBssConfig->
431 RsnConfig.
432 wpaUcstCipher,
433 pBssConfig->RsnConfig.
434 wpaUcstCipherCount,
435 &pBssConfig->
436 RsnConfig.mcstCipher,
437 pBssConfig->RsnConfig.
438 AuthKey,
439 pBssConfig->RsnConfig.
440 AuthKeyCount);
441 pBssConfig->wpa_ielen = ielen;
442 pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
443 pBssConfig->wpa_ie, ielen,
444 0);
445 }
446
447 if (pBssConfig->rsn_ielen) {
448 pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
449 pBssConfig->rsn_ie,
450 pBssConfig->rsn_ielen, 1);
451 pBssConfig->rsn_ielen = 0;
452 memset(util_fns, pBssConfig->rsn_ie, 0x00, MAX_IE_SIZE);
453 }
454
455 if (pBssConfig->SecType.wpa2) {
456 memset(util_fns, pBssConfig->rsn_ie, 0x00, MAX_IE_SIZE);
457 ielen = keyMgmtAp_FormatWPARSN_IE(psapriv,
458 (IEEEtypes_InfoElementHdr_t
459 *)pBssConfig->rsn_ie,
460 1,
461 &pBssConfig->
462 RsnConfig.
463 wpa2UcstCipher,
464 pBssConfig->RsnConfig.
465 wpa2UcstCipherCount,
466 &pBssConfig->
467 RsnConfig.mcstCipher,
468 pBssConfig->RsnConfig.
469 AuthKey,
470 pBssConfig->RsnConfig.
471 AuthKeyCount);
472 pBssConfig->rsn_ielen = ielen;
473 pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
474 pBssConfig->rsn_ie, ielen,
475 0);
476 }
477 }
478
479 if (clearIE) {
480 PRINTM(MMSG, "authenticator clear mgmt IE\n");
481 if (pBssConfig->wpa_ielen) {
482 pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
483 pBssConfig->wpa_ie,
484 pBssConfig->wpa_ielen, 1);
485 pBssConfig->wpa_ielen = 0;
486 memset(util_fns, pBssConfig->wpa_ie, 0x00, MAX_IE_SIZE);
487 }
488 if (pBssConfig->rsn_ielen) {
489 pm_fns->Hostsa_set_mgmt_ie(psapriv->pmlan_private,
490 pBssConfig->rsn_ie,
491 pBssConfig->rsn_ielen, 1);
492 pBssConfig->rsn_ielen = 0;
493 memset(util_fns, pBssConfig->rsn_ie, 0x00, MAX_IE_SIZE);
494 }
495 }
496 LEAVE();
497 return ret;
498 }
499
500 /**
501 * @brief initialize key
502 *
503 * @param priv A void pointer to phostsa private struct
504 *
505 * @return
506 */
507 void
AuthenticatorKeyMgmtInit(void * priv,t_u8 * addr)508 AuthenticatorKeyMgmtInit(void *priv, t_u8 *addr)
509 {
510 phostsa_private psapriv = (phostsa_private)priv;
511 hostsa_util_fns *util_fns = &psapriv->util_fns;
512 apInfo_t *pApInfo = &psapriv->apinfo;
513 BssConfig_t *pBssConfig = MNULL;
514
515 ENTER();
516
517 pBssConfig = &pApInfo->bssConfig;
518 /**mac address */
519 memcpy(util_fns, psapriv->curr_addr, addr, MLAN_MAC_ADDR_LENGTH);
520 /**Reset Group Key*/
521 memset(util_fns, &pBssConfig->pGtkKeyBuf, 0x00,
522 sizeof(pBssConfig->pGtkKeyBuf));
523 /**key init */
524 KeyMgmtInit(priv);
525 /**Group key update time,*/
526 if (pBssConfig->RsnConfig.GrpReKeyTime) {
527 pApInfo->bssData.grpRekeyCntConfigured = pApInfo->bssConfig.RsnConfig.GrpReKeyTime / 60;
528 /**every 60s grpRekeyCntRemaining -- */
529
530 pApInfo->bssData.grpRekeyCntRemaining
531 = pApInfo->bssData.grpRekeyCntConfigured;
532 }
533
534 keyApi_ApUpdateKeyMaterial(priv, MNULL, MTRUE);
535
536 /**start Group rekey timer*/
537 if (pBssConfig->RsnConfig.GrpReKeyTime && !psapriv->GrpRekeyTimerIsSet) {
538 util_fns->moal_start_timer(util_fns->pmoal_handle,
539 psapriv->GrpRekeytimer,
540 MFALSE, MRVDRV_TIMER_60S);
541 psapriv->GrpRekeyTimerIsSet = MTRUE;
542 }
543
544 LEAVE();
545 }
546
547 /**
548 * @brief clear key
549 *
550 * @param priv A void pointer to phostsa private struct
551 *
552 * @return
553 */
554 void
AuthenticatorkeyClear(void * priv)555 AuthenticatorkeyClear(void *priv)
556 {
557 phostsa_private psapriv = (phostsa_private)priv;
558 hostsa_util_fns *putil_fns = &psapriv->util_fns;
559 apInfo_t *pApInfo = &psapriv->apinfo;
560 BssConfig_t *pBssConfig = &pApInfo->bssConfig;
561
562 if (psapriv->GrpRekeyTimerIsSet) {
563 psapriv->GrpRekeyTimerIsSet = MFALSE;
564 putil_fns->moal_stop_timer(putil_fns->pmoal_handle,
565 psapriv->GrpRekeytimer);
566 /**Reset Group Key*/
567 memset(putil_fns, &pBssConfig->pGtkKeyBuf, 0x00,
568 sizeof(pBssConfig->pGtkKeyBuf));
569 }
570 }
571
572 /**
573 * @brief process received eapol packet
574 *
575 * @param psapriv A void pointer to phostsa private struct
576 * @param pbuf a pointer to packet buf
577 * @param len buffer len
578 * @
579 * @return
580 */
581 t_u8
AuthenticatorProcessEapolPacket(t_void * psapriv,t_u8 * pbuf,t_u32 len)582 AuthenticatorProcessEapolPacket(t_void *psapriv, t_u8 *pbuf, t_u32 len)
583 {
584 phostsa_private priv = (phostsa_private)psapriv;
585 hostsa_mlan_fns *pm_fns = &priv->mlan_fns;
586 EAPOL_KeyMsg_t *rx_eapol_ptr;
587 Status_e status = FAIL;
588 cm_Connection *connPtr = MNULL;
589 cm_Connection *pconnPtr = MNULL;
590 t_u8 *sta_addr = pbuf + MLAN_MAC_ADDR_LENGTH;
591 t_u8 ret = 0;
592 t_u32 eapol_pkt_len, least_len;
593
594 ENTER();
595
596 rx_eapol_ptr = (EAPOL_KeyMsg_t *)(pbuf + ETHII_HEADER_LEN);
597
598 if (rx_eapol_ptr->hdr_8021x.pckt_type !=
599 IEEE_8021X_PACKET_TYPE_EAPOL_KEY) {
600 ret = 1;
601 return ret;
602
603 }
604
605 eapol_pkt_len = len - ETHII_HEADER_LEN;
606 least_len = sizeof(EAPOL_KeyMsg_t) - sizeof(rx_eapol_ptr->key_data);
607 if (eapol_pkt_len < least_len) {
608 PRINTM(MERROR,
609 "Invalid EAPOL Key Packet, received len: %u, least len: %u\n",
610 eapol_pkt_len, least_len);
611 ret = 1;
612 return ret;
613 }
614
615 pm_fns->Hostsa_get_station_entry(priv->pmlan_private, sta_addr,
616 (t_void *)&pconnPtr);
617 connPtr = (cm_Connection *)pconnPtr;
618 if (connPtr) {
619 // rx_eapol_ptr = (EAPOL_KeyMsg_t *)(pbuf + ETHII_HEADER_LEN);
620
621 if (rx_eapol_ptr->key_info.Error) {
622 ApMicCounterMeasureInvoke((t_void *)connPtr);
623 return ret;
624 }
625
626 if (!isValidReplayCount(priv, &connPtr->staData.keyMgmtInfo,
627 (UINT8 *)&rx_eapol_ptr->replay_cnt[0]))
628 {
629 return ret;
630 }
631
632 if (connPtr->staData.keyMgmtInfo.rom.keyMgmtState ==
633 WAITING_4_MSG2) {
634 status = ProcessPWKMsg2(priv, connPtr, pbuf, len);
635 } else if (connPtr->staData.keyMgmtInfo.rom.keyMgmtState ==
636 WAITING_4_MSG4) {
637 status = ProcessPWKMsg4(priv, connPtr, pbuf, len);
638 } else if ((connPtr->staData.keyMgmtInfo.rom.keyMgmtState
639 == WAITING_4_GRPMSG2)
640 || (connPtr->staData.keyMgmtInfo.rom.keyMgmtState
641 == WAITING_4_GRP_REKEY_MSG2)) {
642 status = ProcessGrpMsg2(priv, connPtr, pbuf, len);
643 }
644 }
645 LEAVE();
646 return ret;
647 }
648
649 /**
650 * @brief send eapol packet
651 *
652 * @param psapriv A void pointer to phostsa private struct
653 * @param pconnPtr a pointer to connection
654 * @
655 * @return
656 */
657 t_void
AuthenticatorSendEapolPacket(t_void * priv,t_void * pconnPtr)658 AuthenticatorSendEapolPacket(t_void *priv, t_void *pconnPtr)
659 {
660 phostsa_private psapriv = (phostsa_private)priv;
661 cm_Connection *connPtr = (cm_Connection *)pconnPtr;
662 apInfo_t *pApInfo = &psapriv->apinfo;
663
664 ENTER();
665 /**check whether wpa/rsn is used*/
666 if (!connPtr->staData.RSNEnabled)
667 return;
668
669 /**init Mic error parameters*/
670 initMicErrorParams(pApInfo->bssConfig.SecType.wpa,
671 &connPtr->staData.apMicError);
672 connPtr->staData.keyMgmtInfo.rom.keyMgmtState = MSG1_PENDING;
673 //If it is in **_pending state
674 if (((connPtr->staData.keyMgmtInfo.rom.keyMgmtState) & 0x1) != 0) {
675 GenerateApEapolMsg(psapriv, connPtr,
676 connPtr->staData.keyMgmtInfo.rom.
677 keyMgmtState);
678
679 }
680
681 LEAVE();
682 }
683
684 /**
685 * @brief get station security infor from (re)assocaite request
686 *
687 * @param priv A void pointer to phostsa private struct
688 * @param pconnPtr a pointer to connection
689 * @param pIe a pointer to associate request
690 * @param ieLen len of ie
691 *
692 * @return
693 */
694 void
authenticator_get_sta_security_info(void * priv,t_void * pconnPtr,t_u8 * pIe,t_u8 ieLen)695 authenticator_get_sta_security_info(void *priv,
696 t_void *pconnPtr, t_u8 *pIe, t_u8 ieLen)
697 {
698 phostsa_private psapriv = (phostsa_private)priv;
699 hostsa_util_fns *util_fns = &psapriv->util_fns;
700 cm_Connection *connPtr = (cm_Connection *)pconnPtr;
701 IEPointers_t iePointers;
702 IEEEtypes_StatusCode_t retcode;
703
704 ENTER();
705
706 ieLen = GetIEPointers((t_void *)priv, pIe, ieLen, &iePointers);
707
708 assocSrvAp_CheckSecurity(connPtr, iePointers.pWps,
709 iePointers.pRsn, iePointers.pWpa,
710 iePointers.pWapi, &retcode);
711 /* clean key */
712 memset(util_fns, (t_u8 *)&connPtr->hskData, 0x00,
713 sizeof(eapolHskData_t));
714
715 LEAVE();
716 }
717
718 /**
719 * @brief initialize client
720 *
721 * @param priv A void pointer to phostsa private struct
722 * @param pconnPtr a pointer to pointer to connection
723 * @param mac a pointer to mac address
724 *
725 * @return
726 */
727 void
authenticator_init_client(void * priv,void ** ppconnPtr,t_u8 * mac)728 authenticator_init_client(void *priv, void **ppconnPtr, t_u8 *mac)
729 {
730 phostsa_private psapriv = (hostsa_private *)priv;
731 hostsa_util_fns *util_fns = &psapriv->util_fns;
732 cm_Connection *connPtr = MNULL;
733 mlan_status ret = MLAN_STATUS_SUCCESS;
734
735 ENTER();
736
737 ret = malloc(util_fns, sizeof(cm_Connection), (t_u8 **)&connPtr);
738 if ((ret != MLAN_STATUS_SUCCESS) || (!connPtr)) {
739 PRINTM(MERROR, "%s: could not allocate hostsa_private.\n",
740 __FUNCTION__);
741 ret = MLAN_STATUS_FAILURE;
742 goto done;
743 }
744
745 memset(util_fns, connPtr, 0x00, sizeof(cm_Connection));
746 connPtr->priv = priv;
747 memcpy(util_fns, connPtr->mac_addr, mac, MLAN_MAC_ADDR_LENGTH);
748
749 util_fns->moal_init_timer(util_fns->pmoal_handle, &connPtr->HskTimer,
750 KeyMgmtHskTimeout, connPtr);
751 util_fns->moal_init_timer(util_fns->pmoal_handle,
752 &connPtr->staData.apMicTimer,
753 ApMicErrTimerExpCb, connPtr);
754
755 done:
756 if (ret == MLAN_STATUS_SUCCESS)
757 *ppconnPtr = (void *)connPtr;
758 else
759 *ppconnPtr = MNULL;
760 LEAVE();
761
762 }
763
764 /**
765 * @brief free client
766 *
767 * @param priv A void pointer to phostsa private struct
768 * @param pconnPtr a pointer to connection
769 *
770 * @return
771 */
772 void
authenticator_free_client(void * priv,void * ppconnPtr)773 authenticator_free_client(void *priv, void *ppconnPtr)
774 {
775 phostsa_private psapriv = (phostsa_private)priv;
776 hostsa_util_fns *util_fns = &psapriv->util_fns;
777 cm_Connection *connPtr = (cm_Connection *)ppconnPtr;
778
779 ENTER();
780
781 if (connPtr) {
782 util_fns->moal_stop_timer(util_fns->pmoal_handle,
783 connPtr->HskTimer);
784 util_fns->moal_stop_timer(util_fns->pmoal_handle,
785 connPtr->staData.apMicTimer);
786
787 util_fns->moal_free_timer(util_fns->pmoal_handle,
788 connPtr->HskTimer);
789 util_fns->moal_free_timer(util_fns->pmoal_handle,
790 connPtr->staData.apMicTimer);
791 free(util_fns, (t_u8 *)connPtr);
792 }
793 LEAVE();
794 }
795 #endif
796
797 /**
798 * @brief Init hostsa data
799 *
800 * @param pphostsa_priv A pointer to pointer to a hostsa private data structure
801 * @param psa_util_fns A pointer to hostsa utility functions table
802 * @param psa_mlan_fns A pointer to MLAN APIs table
803 * @param addr a pointer to address
804 *
805 * @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
806 */
807 mlan_status
supplicant_authenticator_init(t_void ** pphostsa_priv,t_void * psa_util_fns,t_void * psa_mlan_fns,t_u8 * addr)808 supplicant_authenticator_init(t_void **pphostsa_priv, t_void *psa_util_fns,
809 t_void *psa_mlan_fns, t_u8 *addr)
810 {
811 hostsa_util_fns *putil_fns = (hostsa_util_fns *)psa_util_fns;
812 hostsa_mlan_fns *pmlan_fns = (hostsa_mlan_fns *)psa_mlan_fns;
813 mlan_status ret;
814 hostsa_private *priv = MNULL;
815
816 ENTER();
817
818 ret = malloc(putil_fns, sizeof(hostsa_private), (t_u8 **)&priv);
819 if ((ret != MLAN_STATUS_SUCCESS) || (!priv)) {
820 PRINTM(MERROR, "%s: could not allocate hostsa_private.\n",
821 __FUNCTION__);
822 ret = MLAN_STATUS_FAILURE;
823 goto done;
824 }
825
826 memset(putil_fns, priv, 0x00, sizeof(hostsa_private));
827 memset(putil_fns, &priv->apinfo, 0x00, sizeof(apInfo_t));
828
829 memcpy(putil_fns, &priv->util_fns, putil_fns, sizeof(hostsa_util_fns));
830 memcpy(putil_fns, &priv->mlan_fns, pmlan_fns, sizeof(hostsa_mlan_fns));
831
832 priv->pmlan_adapter = pmlan_fns->pmlan_adapter;
833 priv->pmlan_private = pmlan_fns->pmlan_private;
834
835 memcpy(putil_fns, priv->curr_addr, addr, MLAN_MAC_ADDR_LENGTH);
836 #ifdef DRV_EMBEDDED_AUTHENTICATOR
837 putil_fns->moal_init_timer(putil_fns->pmoal_handle,
838 &priv->GrpRekeytimer,
839 KeyMgmtGrpRekeyCountUpdate, priv);
840 /**Bss configure initialize*/
841 AuthenitcatorInitBssConfig(priv);
842 #endif
843 #ifdef DRV_EMBEDDED_SUPPLICANT
844 priv->suppData = MNULL;
845 allocSupplicantData(priv);
846 ret = initSupplicantTimer(priv);
847 if (ret != MLAN_STATUS_SUCCESS) {
848 goto done;
849 }
850 pmkCacheInit(priv);
851 pmkCacheRomInit();
852 keyMgmtSta_RomInit();
853 #endif
854
855 done:
856 if (ret == MLAN_STATUS_SUCCESS)
857 *pphostsa_priv = (t_void *)priv;
858 else
859 *pphostsa_priv = MNULL;
860 LEAVE();
861 return ret;
862 }
863
864 /**
865 * @brief Cleanup hostsa data
866 *
867 * @param phostsa_priv A pointer to a hostsa private data structure
868 *
869 * @return MLAN_STATUS_SUCCESS
870 */
871 mlan_status
supplicant_authenticator_free(t_void * phostsa_priv)872 supplicant_authenticator_free(t_void *phostsa_priv)
873 {
874 mlan_status ret = MLAN_STATUS_SUCCESS;
875 phostsa_private priv = (hostsa_private *)phostsa_priv;
876 hostsa_util_fns *putil_fns = &priv->util_fns;
877
878 ENTER();
879
880 if (!phostsa_priv)
881 goto done;
882 #ifdef DRV_EMBEDDED_SUPPLICANT
883 freeSupplicantData(priv);
884 freeSupplicantTimer(priv);
885 #endif
886 #ifdef DRV_EMBEDDED_AUTHENTICATOR
887 putil_fns->moal_stop_timer(putil_fns->pmoal_handle,
888 priv->GrpRekeytimer);
889 putil_fns->moal_free_timer(putil_fns->pmoal_handle,
890 priv->GrpRekeytimer);
891 #endif
892 free(putil_fns, (t_u8 *)priv);
893 done:
894 LEAVE();
895 return ret;
896 }
897