1 /* 2 * rsn.c 3 * 4 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name Texas Instruments nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 35 /** \file rsn.c 36 * \brief 802.11 rsniation SM source 37 * 38 * \see rsnSM.h 39 */ 40 41 42 /***************************************************************************/ 43 /* */ 44 /* MODULE: rsnSM.c */ 45 /* PURPOSE: 802.11 rsniation SM source */ 46 /* */ 47 /***************************************************************************/ 48 49 #define __FILE_ID__ FILE_ID_40 50 #include "osApi.h" 51 #include "paramOut.h" 52 #include "timer.h" 53 #include "report.h" 54 #include "DataCtrl_Api.h" 55 #include "siteMgrApi.h" 56 #include "smeApi.h" 57 #include "mainSecSm.h" 58 #include "admCtrl.h" 59 #include "rsnApi.h" 60 #include "rsn.h" 61 #include "keyParser.h" 62 #include "EvHandler.h" 63 #include "TI_IPC_Api.h" 64 #include "sme.h" 65 #include "apConn.h" 66 #include "802_11Defs.h" 67 #include "externalSec.h" 68 #include "connApi.h" 69 #ifdef XCC_MODULE_INCLUDED 70 #include "admCtrlWpa.h" 71 #include "XCCMngr.h" 72 #include "admCtrlXCC.h" 73 #endif 74 #include "TWDriver.h" 75 #include "DrvMainModules.h" 76 #include "PowerMgr_API.h" 77 78 /* Constants */ 79 80 /* Enumerations */ 81 82 /* Typedefs */ 83 84 /* Structures */ 85 86 /* External data definitions */ 87 88 /* External functions definitions */ 89 90 /* Global variables */ 91 92 /* Local function prototypes */ 93 TI_STATUS rsn_sendKeysNotSet(rsn_t *pRsn); 94 void rsn_pairwiseReKeyTimeout(TI_HANDLE hRsn, TI_BOOL bTwdInitOccured); 95 void rsn_groupReKeyTimeout(TI_HANDLE hRsn, TI_BOOL bTwdInitOccured); 96 void rsn_micFailureReportTimeout (TI_HANDLE hRsn, TI_BOOL bTwdInitOccured); 97 static rsn_siteBanEntry_t * findEntryForInsert(TI_HANDLE hRsn); 98 static rsn_siteBanEntry_t * findBannedSiteAndCleanup(TI_HANDLE hRsn, TMacAddr siteBssid); 99 100 /* functions */ 101 102 /** 103 * 104 * rsn_Create - allocate memory for rsniation SM 105 * 106 * \b Description: 107 * 108 * Allocate memory for rsniation SM. \n 109 * Allocates memory for Rsniation context. \n 110 * Allocates memory for rsniation timer. \n 111 * Allocates memory for rsniation SM matrix. \n 112 * 113 * \b ARGS: 114 * 115 * I - hOs - OS context \n 116 * 117 * \b RETURNS: 118 * 119 * TI_OK if successful, TI_NOK otherwise. 120 * 121 * \sa rsn_mainSecKeysOnlyStop() 122 */ 123 TI_HANDLE rsn_create(TI_HANDLE hOs) 124 { 125 rsn_t *pRsn; 126 127 /* allocate rsniation context memory */ 128 pRsn = (rsn_t*)os_memoryAlloc (hOs, sizeof(rsn_t)); 129 if (pRsn == NULL) 130 { 131 return NULL; 132 } 133 134 os_memoryZero (hOs, pRsn, sizeof(rsn_t)); 135 136 /* create admission control */ 137 pRsn->pAdmCtrl = admCtrl_create (hOs); 138 if (pRsn->pAdmCtrl == NULL) 139 { 140 os_memoryFree (hOs, pRsn, sizeof(rsn_t)); 141 return NULL; 142 } 143 144 /* create main security SM */ 145 pRsn->pMainSecSm = mainSec_create (hOs); 146 if (pRsn->pMainSecSm == NULL) 147 { 148 admCtrl_unload (pRsn->pAdmCtrl); 149 os_memoryFree (hOs, pRsn, sizeof(rsn_t)); 150 return NULL; 151 } 152 153 pRsn->pKeyParser = pRsn->pMainSecSm->pKeyParser; 154 155 pRsn->hOs = hOs; 156 157 return pRsn; 158 } 159 160 161 /** 162 * 163 * rsn_Unload - unload rsniation SM from memory 164 * 165 * \b Description: 166 * 167 * Unload rsniation SM from memory 168 * 169 * \b ARGS: 170 * 171 * I - hRsn - rsniation SM context \n 172 * 173 * \b RETURNS: 174 * 175 * TI_OK if successful, TI_NOK otherwise. 176 * 177 * \sa rsn_mainSecKeysOnlyStop() 178 */ 179 TI_STATUS rsn_unload (TI_HANDLE hRsn) 180 { 181 rsn_t *pRsn; 182 TI_STATUS status; 183 184 if (hRsn == NULL) 185 { 186 return TI_NOK; 187 } 188 189 pRsn = (rsn_t*)hRsn; 190 191 if (pRsn->hMicFailureReportWaitTimer) 192 { 193 tmr_DestroyTimer (pRsn->hMicFailureReportWaitTimer); 194 } 195 if (pRsn->hMicFailureGroupReKeyTimer) 196 { 197 tmr_DestroyTimer (pRsn->hMicFailureGroupReKeyTimer); 198 } 199 if (pRsn->hMicFailurePairwiseReKeyTimer) 200 { 201 tmr_DestroyTimer (pRsn->hMicFailurePairwiseReKeyTimer); 202 } 203 204 status = admCtrl_unload (pRsn->pAdmCtrl); 205 status = mainSec_unload (pRsn->pMainSecSm); 206 207 os_memoryFree (pRsn->hOs, hRsn, sizeof(rsn_t)); 208 209 return status; 210 } 211 212 213 /** 214 * 215 * rsn_init - Init module 216 * 217 * \b Description: 218 * 219 * Init module handles and variables. 220 * 221 * \b RETURNS: 222 * 223 * void 224 * 225 * \sa rsn_Create, rsn_Unload 226 */ 227 void rsn_init (TStadHandlesList *pStadHandles) 228 { 229 rsn_t *pRsn = (rsn_t*)(pStadHandles->hRsn); 230 231 pRsn->eGroupKeyUpdate = GROUP_KEY_UPDATE_FALSE; 232 pRsn->ePairwiseKeyUpdate = PAIRWISE_KEY_UPDATE_FALSE; 233 pRsn->PrivacyOptionImplemented = TI_TRUE; 234 235 pRsn->hTxCtrl = pStadHandles->hTxCtrl; 236 pRsn->hRx = pStadHandles->hRxData; 237 pRsn->hConn = pStadHandles->hConn; 238 pRsn->hTWD = pStadHandles->hTWD; 239 pRsn->hCtrlData = pStadHandles->hCtrlData; 240 pRsn->hSiteMgr = pStadHandles->hSiteMgr; 241 pRsn->hReport = pStadHandles->hReport; 242 pRsn->hOs = pStadHandles->hOs; 243 pRsn->hXCCMngr = pStadHandles->hXCCMngr; 244 pRsn->hEvHandler= pStadHandles->hEvHandler; 245 pRsn->hSmeSm = pStadHandles->hSme; 246 pRsn->hAPConn = pStadHandles->hAPConnection; 247 pRsn->hMlme = pStadHandles->hMlmeSm; 248 pRsn->hPowerMgr = pStadHandles->hPowerMgr; 249 pRsn->hTimer = pStadHandles->hTimer; 250 pRsn->hCurrBss = pStadHandles->hCurrBss; 251 252 pRsn->setPaeConfig = rsn_setPaeConfig; 253 pRsn->getNetworkMode = rsn_getNetworkMode; 254 pRsn->setKey = rsn_setKey; 255 pRsn->removeKey = rsn_removeKey; 256 pRsn->reportStatus = rsn_reportStatus; 257 pRsn->setDefaultKeyId = rsn_setDefaultKeyId; 258 pRsn->defaultKeysOn = TI_TRUE; 259 pRsn->eapType = OS_EAP_TYPE_NONE; 260 pRsn->numOfBannedSites = 0; 261 } 262 263 264 TI_STATUS rsn_SetDefaults (TI_HANDLE hRsn, TRsnInitParams *pInitParam) 265 { 266 rsn_t *pRsn = (rsn_t*)hRsn; 267 TI_UINT8 keyIndex; 268 TI_STATUS status; 269 270 /* Create the module's timers */ 271 pRsn->hMicFailureReportWaitTimer = tmr_CreateTimer (pRsn->hTimer); 272 if (pRsn->hMicFailureReportWaitTimer == NULL) 273 { 274 TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "rsn_SetDefaults(): Failed to create hMicFailureReportWaitTimer!\n"); 275 return TI_NOK; 276 } 277 pRsn->hMicFailureGroupReKeyTimer = tmr_CreateTimer (pRsn->hTimer); 278 if (pRsn->hMicFailureGroupReKeyTimer == NULL) 279 { 280 TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "rsn_SetDefaults(): Failed to create hMicFailureGroupReKeyTimer!\n"); 281 return TI_NOK; 282 } 283 284 /* Configure the RSN external mode */ 285 pRsn->bRsnExternalMode = pInitParam->bRsnExternalMode; 286 287 pRsn->hMicFailurePairwiseReKeyTimer = tmr_CreateTimer (pRsn->hTimer); 288 if (pRsn->hMicFailurePairwiseReKeyTimer == NULL) 289 { 290 TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "rsn_SetDefaults(): Failed to create hMicFailurePairwiseReKeyTimer!\n"); 291 return TI_NOK; 292 } 293 294 pRsn->bPairwiseMicFailureFilter = pInitParam->bPairwiseMicFailureFilter; 295 /* config the admission control with the authentication suite selected. 296 Admission control will configure the main security SM. */ 297 status = admCtrl_config (pRsn->pAdmCtrl, 298 pRsn->hMlme, 299 pRsn->hRx, 300 pRsn->hReport, 301 pRsn->hOs, 302 pRsn, 303 pRsn->hXCCMngr, 304 pRsn->hPowerMgr, 305 pRsn->hEvHandler, 306 pRsn->hTimer, 307 pRsn->hCurrBss, 308 pInitParam); 309 310 if (status != TI_OK) 311 { 312 return status; 313 } 314 315 /* Configure keys from registry */ 316 if (pInitParam->privacyOn) 317 { 318 pRsn->wepStaticKey = TI_TRUE; 319 } 320 321 pRsn->defaultKeyId = pInitParam->defaultKeyId; 322 for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) 323 { 324 os_memoryCopy (pRsn->hOs, &pRsn->keys[keyIndex], &pInitParam->keys[keyIndex], sizeof(TSecurityKeys)); 325 if (pRsn->keys[keyIndex].keyType != KEY_NULL) 326 { 327 pRsn->wepDefaultKeys[keyIndex] = TI_TRUE; 328 } 329 pRsn->keys_en [keyIndex] = TI_FALSE; 330 } 331 332 return status; 333 } 334 335 336 /** 337 * 338 * rsn_reconfig - re-configure a rsniation 339 * 340 * \b Description: 341 * 342 * Re-configure rsniation 343 * 344 * \b ARGS: 345 * 346 * I - hRsn - Rsniation SM context \n 347 * 348 * \b RETURNS: 349 * 350 * TI_OK if successful, TI_NOK otherwise. 351 * 352 * \sa rsn_Create, rsn_Unload 353 */ 354 TI_STATUS rsn_reconfig (TI_HANDLE hRsn) 355 { 356 rsn_t *pRsn = (rsn_t *)hRsn; 357 TI_UINT8 keyIndex; 358 359 /* Mark all keys as removed */ 360 for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) 361 pRsn->keys_en [keyIndex] = TI_FALSE; 362 363 return TI_OK; 364 } 365 366 367 /** 368 * 369 * rsn_setDefaultKeys - 370 * 371 * \b Description: 372 * 373 * 374 * 375 * \b ARGS: 376 * 377 * I - hRsn - Rsn SM context \n 378 * 379 * \b RETURNS: 380 * 381 * TI_OK if successful, TI_NOK otherwise. 382 * 383 * \sa rsn_Stop, rsn_Recv 384 */ 385 TI_STATUS rsn_setDefaultKeys(rsn_t *pRsn) 386 { 387 TI_STATUS status = TI_OK; 388 TTwdParamInfo tTwdParam; 389 TI_UINT8 keyIndex; 390 391 for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) 392 { 393 /* Set the WEP key to the HAL */ 394 if (pRsn->wepDefaultKeys[keyIndex] /*pRsn->keys[keyIndex].encLen>0*/) 395 { 396 /* Change key type to WEP-key before setting*/ 397 pRsn->keys[keyIndex].keyType = KEY_WEP; 398 399 status = pRsn->pMainSecSm->setKey (pRsn->pMainSecSm, &pRsn->keys[keyIndex]); 400 401 if (status != TI_OK) 402 { 403 TRACE1(pRsn->hReport, REPORT_SEVERITY_ERROR, "RSN: Setting key #%d failed \n", keyIndex); 404 return status; 405 } 406 } 407 } 408 409 /* Now we configure default key ID to the HAL */ 410 if (pRsn->defaultKeyId < MAX_KEYS_NUM) 411 { 412 tTwdParam.paramType = TWD_RSN_DEFAULT_KEY_ID_PARAM_ID; 413 tTwdParam.content.configureCmdCBParams.pCb = &pRsn->defaultKeyId; 414 tTwdParam.content.configureCmdCBParams.fCb = NULL; 415 tTwdParam.content.configureCmdCBParams.hCb = NULL; 416 status = TWD_SetParam (pRsn->hTWD, &tTwdParam); 417 418 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: default key ID =%d \n", pRsn->defaultKeyId); 419 } 420 421 return status; 422 } 423 424 425 /** 426 * 427 * rsn_Start - Start event for the rsniation SM 428 * 429 * \b Description: 430 * 431 * Start event for the rsniation SM 432 * 433 * \b ARGS: 434 * 435 * I - hRsn - Rsniation SM context \n 436 * 437 * \b RETURNS: 438 * 439 * TI_OK if successful, TI_NOK otherwise. 440 * 441 * \sa rsn_Stop, rsn_Recv 442 */ 443 TI_STATUS rsn_start(TI_HANDLE hRsn) 444 { 445 TI_STATUS status; 446 rsn_t *pRsn; 447 ECipherSuite suite; 448 EExternalAuthMode extAuthMode; 449 TTwdParamInfo tTwdParam; 450 451 pRsn = (rsn_t*)hRsn; 452 453 if (pRsn == NULL) 454 { 455 return TI_NOK; 456 } 457 458 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_start ...\n"); 459 pRsn->rsnStartedTs = os_timeStampMs (pRsn->hOs); 460 461 status = pRsn->pMainSecSm->start (pRsn->pMainSecSm); 462 /* Set keys that need to be set */ 463 pRsn->defaultKeysOn = TI_FALSE; 464 pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &suite); 465 pRsn->pAdmCtrl->getExtAuthMode (pRsn->pAdmCtrl, &extAuthMode); 466 467 if (pRsn->wepStaticKey && ( (suite == TWD_CIPHER_WEP) || (suite == TWD_CIPHER_CKIP) ) ) 468 { /* set default WEP keys */ 469 status = rsn_sendKeysNotSet (pRsn); 470 pRsn->eapType = OS_EAP_TYPE_NONE; 471 } 472 else if (suite == TWD_CIPHER_NONE && extAuthMode != RSN_EXT_AUTH_MODE_OPEN) 473 { /* remove previously WEP key for SHARED */ 474 pRsn->wepStaticKey = TI_FALSE; 475 status = rsn_removedDefKeys (pRsn); 476 477 /* Set None to HAL */ 478 tTwdParam.paramType = TWD_RSN_SECURITY_MODE_PARAM_ID; 479 tTwdParam.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_NONE; 480 status = TWD_SetParam (pRsn->hTWD, &tTwdParam); 481 482 } 483 else if (suite==TWD_CIPHER_NONE) 484 { 485 pRsn->eapType = OS_EAP_TYPE_NONE; 486 } 487 488 return status; 489 } 490 491 492 TI_STATUS rsn_sendKeysNotSet(rsn_t *pRsn) 493 { 494 TI_UINT8 keyIndex; 495 OS_802_11_KEY rsnOsKey; 496 TI_STATUS status = TI_OK; 497 498 for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) 499 { 500 if (pRsn->wepDefaultKeys[keyIndex]) 501 { 502 rsnOsKey.KeyIndex = pRsn->keys[keyIndex].keyIndex; 503 rsnOsKey.KeyLength = pRsn->keys[keyIndex].encLen; 504 rsnOsKey.Length = sizeof(rsnOsKey); 505 506 /* Change key type to WEP-key before setting*/ 507 pRsn->keys[keyIndex].keyType = KEY_WEP; 508 509 MAC_COPY (rsnOsKey.BSSID, pRsn->keys[keyIndex].macAddress); 510 os_memoryCopy (pRsn->hOs, &rsnOsKey.KeyRSC, 511 (void *)pRsn->keys[keyIndex].keyRsc, 512 KEY_RSC_LEN); 513 os_memoryCopy (pRsn->hOs, rsnOsKey.KeyMaterial, 514 (void *)pRsn->keys[keyIndex].encKey, 515 MAX_KEY_LEN /*pRsn->keys[keyIndex].encLen*/); 516 517 /* Set WEP transmit key mask on the default key */ 518 if (keyIndex == pRsn->defaultKeyId) 519 { 520 rsnOsKey.KeyIndex |= 0x80000000; 521 } 522 523 status = pRsn->pKeyParser->recv (pRsn->pKeyParser, (TI_UINT8*)&rsnOsKey, sizeof(rsnOsKey)); 524 } 525 } 526 527 return status; 528 } 529 530 531 TI_STATUS rsn_removedDefKeys (TI_HANDLE hRsn) 532 { 533 TI_UINT8 keyIndex; 534 rsn_t *pRsn = (rsn_t*)hRsn; 535 536 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_removedDefKeys Enter \n"); 537 538 for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) 539 { 540 TSecurityKeys key; 541 542 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_removedDefKeys, Remove keyId=%d\n", keyIndex); 543 544 pRsn->wepDefaultKeys[keyIndex] = TI_FALSE; 545 os_memoryCopy (pRsn->hOs, &key, &pRsn->keys[keyIndex], sizeof(TSecurityKeys)); 546 pRsn->removeKey (pRsn, &key); 547 548 /* Set WEP transmit key mask on the default key */ 549 if (keyIndex == pRsn->defaultKeyId) 550 { 551 pRsn->defaultKeyId = 0; 552 } 553 } 554 555 return TI_OK; 556 } 557 558 559 /** 560 * 561 * rsn_Stop - Stop event for the rsniation SM 562 * 563 * \b Description: 564 * 565 * Stop event for the rsniation SM 566 * 567 * \b ARGS: 568 * 569 * I - hRsn - Rsniation SM context \n 570 * 571 * \b RETURNS: 572 * 573 * TI_OK if successful, TI_NOK otherwise. 574 * 575 * \sa rsn_Start, rsn_Recv 576 */ 577 TI_STATUS rsn_stop (TI_HANDLE hRsn, TI_BOOL removeKeys) 578 { 579 TI_STATUS status; 580 rsn_t *pRsn; 581 TI_UINT8 keyIndex; 582 TSecurityKeys key; 583 584 pRsn = (rsn_t*)hRsn; 585 586 if (pRsn == NULL) 587 { 588 return TI_NOK; 589 } 590 591 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: calling STOP... removeKeys=%d\n", removeKeys); 592 593 for (keyIndex = 0; keyIndex < MAX_KEYS_NUM; keyIndex++) 594 { 595 os_memoryCopy (pRsn->hOs, &key, &pRsn->keys[keyIndex], sizeof(TSecurityKeys)); 596 597 if (!pRsn->wepDefaultKeys[keyIndex]) 598 { /* Remove only dynamic keys. Default keys are removed by calling: rsn_removedDefKeys() */ 599 TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_stop, Remove keyIndex=%d, key.keyIndex=%d\n",keyIndex, key.keyIndex); 600 601 TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)key.macAddress, 6); 602 603 pRsn->removeKey (pRsn, &key); 604 } 605 606 } 607 608 tmr_StopTimer (pRsn->hMicFailureReportWaitTimer); 609 610 /* Stop the pre-authentication timer in case we are disconnecting */ 611 tmr_StopTimer (pRsn->pAdmCtrl->hPreAuthTimerWpa2); 612 613 status = pRsn->pMainSecSm->stop (pRsn->pMainSecSm); 614 615 pRsn->eGroupKeyUpdate = GROUP_KEY_UPDATE_FALSE; 616 pRsn->ePairwiseKeyUpdate = PAIRWISE_KEY_UPDATE_FALSE; 617 pRsn->defaultKeysOn = TI_TRUE; 618 619 if (removeKeys) 620 { /* reset PMKID list if exist */ 621 pRsn->pAdmCtrl->resetPmkidList (pRsn->pAdmCtrl); 622 } 623 624 return status; 625 } 626 627 TI_STATUS rsn_getParamEncryptionStatus(TI_HANDLE hRsn, ECipherSuite *rsnStatus) 628 { /* RSN_ENCRYPTION_STATUS_PARAM */ 629 rsn_t *pRsn = (rsn_t *)hRsn; 630 TI_STATUS status = TI_NOK; 631 632 if ( (NULL == pRsn) || (NULL == rsnStatus) ) 633 { 634 return status; 635 } 636 status = pRsn->pAdmCtrl->getCipherSuite(pRsn->pAdmCtrl, rsnStatus); 637 return status; 638 } 639 640 /** 641 * 642 * rsn_GetParam - Get a specific parameter from the rsniation SM 643 * 644 * \b Description: 645 * 646 * Get a specific parameter from the rsniation SM. 647 * 648 * \b ARGS: 649 * 650 * I - hRsn - Rsniation SM context \n 651 * I/O - pParam - Parameter \n 652 * 653 * \b RETURNS: 654 * 655 * TI_OK if successful, TI_NOK otherwise. 656 * 657 * \sa rsn_Start, rsn_Stop 658 */ 659 TI_STATUS rsn_getParam(TI_HANDLE hRsn, void *param) 660 { 661 rsn_t *pRsn = (rsn_t *)hRsn; 662 paramInfo_t *pParam = (paramInfo_t *)param; 663 TI_STATUS status = TI_OK; 664 665 if ( (NULL == pRsn) || (NULL == pParam) ) 666 { 667 return TI_NOK; 668 } 669 670 switch (pParam->paramType) 671 { 672 case RSN_PRIVACY_OPTION_IMPLEMENTED_PARAM: 673 pParam->content.rsnPrivacyOptionImplemented = TI_TRUE; 674 break; 675 676 case RSN_KEY_PARAM: 677 pParam->content.pRsnKey = &pRsn->keys[pParam->content.pRsnKey->keyIndex]; 678 if (pParam->content.pRsnKey->keyIndex == pRsn->defaultKeyId) 679 { 680 pParam->content.pRsnKey->keyIndex |= 0x80000000; 681 TRACE1(pRsn->hReport, REPORT_SEVERITY_WARNING, "default Key: %d\n", pRsn->defaultKeyId); 682 } 683 break; 684 685 case RSN_SECURITY_STATE_PARAM: 686 status = pRsn->pMainSecSm->getAuthState (pRsn->pMainSecSm, (TIWLN_SECURITY_STATE*)&(pParam->content.rsnAuthState)); 687 break; 688 689 case RSN_ENCRYPTION_STATUS_PARAM: 690 status = pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &pParam->content.rsnEncryptionStatus); 691 break; 692 693 case RSN_EXT_AUTHENTICATION_MODE: 694 status = pRsn->pAdmCtrl->getExtAuthMode (pRsn->pAdmCtrl, &pParam->content.rsnExtAuthneticationMode); 695 break; 696 697 case RSN_MIXED_MODE: 698 status = pRsn->pAdmCtrl->getMixedMode (pRsn->pAdmCtrl, &pParam->content.rsnMixedMode); 699 break; 700 701 case RSN_AUTH_ENCR_CAPABILITY: 702 status = pRsn->pAdmCtrl->getAuthEncrCap(pRsn->pAdmCtrl, pParam->content.pRsnAuthEncrCapability); 703 break; 704 705 case RSN_PMKID_LIST: 706 pParam->content.rsnPMKIDList.Length = pParam->paramLength; 707 status = pRsn->pAdmCtrl->getPmkidList (pRsn->pAdmCtrl, &pParam->content.rsnPMKIDList); 708 pParam->paramLength = pParam->content.rsnPMKIDList.Length + 2 * sizeof(TI_UINT32); 709 break; 710 711 case RSN_PRE_AUTH_STATUS: 712 { 713 TI_UINT8 cacheIndex; 714 715 pParam->content.rsnPreAuthStatus = pRsn->pAdmCtrl->getPreAuthStatus (pRsn->pAdmCtrl, &pParam->content.rsnApMac, &cacheIndex); 716 } 717 break; 718 719 case RSN_WPA_PROMOTE_AVAILABLE_OPTIONS: 720 status = pRsn->pAdmCtrl->getWPAMixedModeSupport (pRsn->pAdmCtrl, &pParam->content.rsnWPAMixedModeSupport); 721 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get WPA Mixed MODE support %d \n",pParam->content.rsnWPAMixedModeSupport); 722 break; 723 724 case RSN_WPA_PROMOTE_OPTIONS: 725 status = pRsn->pAdmCtrl->getPromoteFlags (pRsn->pAdmCtrl, 726 &pParam->content.rsnWPAPromoteFlags); 727 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get WPA promote flags %d \n",pParam->content.rsnWPAPromoteFlags); 728 729 break; 730 731 #ifdef XCC_MODULE_INCLUDED 732 case RSN_XCC_NETWORK_EAP: 733 status = pRsn->pAdmCtrl->getNetworkEap (pRsn->pAdmCtrl, &pParam->content.networkEap); 734 break; 735 #endif 736 case RSN_EAP_TYPE: 737 pParam->content.eapType = pRsn->eapType; 738 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get RSN_EAP_TYPE eapType %d \n", pParam->content.eapType); 739 break; 740 741 case WPA_801_1X_AKM_EXISTS: 742 743 status = pRsn->pAdmCtrl->get802_1x_AkmExists(pRsn->pAdmCtrl, &pParam->content.wpa_802_1x_AkmExists); 744 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get WPA_801_1X_AKM_EXISTS %d \n", pParam->content.wpa_802_1x_AkmExists); 745 break; 746 747 case RSN_DEFAULT_KEY_ID: 748 pParam->content.rsnDefaultKeyID = pRsn->defaultKeyId; 749 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Get RSN_DEFAULT_KEY_ID %d \n", pParam->content.rsnDefaultKeyID); 750 break; 751 752 default: 753 return TI_NOK; 754 } 755 756 return status; 757 } 758 759 760 /** 761 * 762 * rsn_SetParam - Set a specific parameter to the rsniation SM 763 * 764 * \b Description: 765 * 766 * Set a specific parameter to the rsniation SM. 767 * 768 * \b ARGS: 769 * 770 * I - hRsn - Rsniation SM context \n 771 * I/O - pParam - Parameter \n 772 * 773 * \b RETURNS: 774 * 775 * TI_OK if successful, TI_NOK otherwise. 776 * 777 * \sa rsn_Start, rsn_Stop 778 */ 779 TI_STATUS rsn_setParam (TI_HANDLE hRsn, void *param) 780 { 781 rsn_t *pRsn; 782 paramInfo_t *pParam = (paramInfo_t*)param; 783 TTwdParamInfo tTwdParam; 784 TI_STATUS status = TI_OK; 785 786 pRsn = (rsn_t*)hRsn; 787 788 if ( (NULL == pRsn) || (NULL == pParam) ) 789 { 790 return TI_NOK; 791 } 792 793 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set rsn_setParam %X \n", pParam->paramType); 794 795 switch (pParam->paramType) 796 { 797 798 case RSN_DEFAULT_KEY_ID: 799 { 800 TI_UINT8 defKeyId, i; 801 802 defKeyId = pParam->content.rsnDefaultKeyID; 803 804 if(defKeyId >= MAX_KEYS_NUM) 805 { 806 TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "RSN: Error - the value of the default Key Id is incorrect \n"); 807 return TI_NOK; 808 } 809 810 /* Clean transmit flag (1 in the bit31) in the previous default key */ 811 for(i = 0; i < MAX_KEYS_NUM; i++) 812 { 813 pRsn->keys[i].keyIndex &= 0x7FFFFFFF; 814 } 815 816 /* Set the default key ID value in the RSN data structure */ 817 pRsn->defaultKeyId = defKeyId; 818 819 /* Set the default key ID in the HAL */ 820 tTwdParam.paramType = TWD_RSN_DEFAULT_KEY_ID_PARAM_ID; 821 tTwdParam.content.configureCmdCBParams.pCb = &pRsn->defaultKeyId; 822 tTwdParam.content.configureCmdCBParams.fCb = NULL; 823 tTwdParam.content.configureCmdCBParams.hCb = NULL; 824 status = TWD_SetParam (pRsn->hTWD, &tTwdParam); 825 826 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: default key ID =%d \n", pRsn->defaultKeyId); 827 828 sme_Restart (pRsn->hSmeSm); 829 break; 830 } 831 832 case RSN_ADD_KEY_PARAM: 833 { 834 TI_UINT8 keyIndex, i = 0; 835 ECipherSuite cipherSuite; 836 837 status = pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &cipherSuite); 838 if (status !=TI_OK) 839 { 840 return status; 841 } 842 843 TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_ADD_KEY_PARAM KeyIndex %x , keyLength=%d\n", pParam->content.rsnOsKey.KeyIndex,pParam->content.rsnOsKey.KeyLength); 844 keyIndex = (TI_UINT8)pParam->content.rsnOsKey.KeyIndex; 845 if (keyIndex >= MAX_KEYS_NUM) 846 { 847 return TI_NOK; 848 } 849 850 status = pRsn->pKeyParser->recv (pRsn->pKeyParser, (TI_UINT8*)&pParam->content.rsnOsKey, sizeof(pParam->content.rsnOsKey)); 851 852 if (status != TI_OK) 853 { 854 TRACE1(pRsn->hReport, REPORT_SEVERITY_WARNING, ": pRsn->pKeyParser->recv satus returned with status=%x. returning with NOK\n", status); 855 return TI_NOK; 856 } 857 858 /* If the Key is not BAD, it may be that WEP key is sent before WEP status is set, 859 save the key, and set it later at rsn_start */ 860 861 /* If default Key not cleaned by calling rsn_removedDefKeys for keyIndex, Clean it */ 862 if (pRsn->wepDefaultKeys[keyIndex] == TI_TRUE) 863 { 864 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "Set RSN_ADD_KEY_PARAM KeyIndex %x\n", keyIndex); 865 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "Set RSN_ADD_KEY_PARAM wepDefaultKeys=%d\n", pRsn->wepDefaultKeys[keyIndex]); 866 867 pRsn->wepDefaultKeys[keyIndex] = TI_FALSE; 868 869 } 870 871 pRsn->keys[keyIndex].keyIndex = pParam->content.rsnOsKey.KeyIndex; 872 pRsn->keys[keyIndex].encLen = pParam->content.rsnOsKey.KeyLength; 873 MAC_COPY (pRsn->keys[keyIndex].macAddress, pParam->content.rsnOsKey.BSSID); 874 os_memoryCopy (pRsn->hOs, (void *)pRsn->keys[keyIndex].keyRsc, (TI_UINT8*)&(pParam->content.rsnOsKey.KeyRSC), KEY_RSC_LEN); 875 os_memoryCopy (pRsn->hOs, (void *)pRsn->keys[keyIndex].encKey, pParam->content.rsnOsKey.KeyMaterial, MAX_KEY_LEN); 876 877 /* Process the transmit flag (31-st bit of keyIndex). */ 878 /* If the added key has the TX bit set to TI_TRUE (i.e. the key */ 879 /* is the new transmit key (default key), update */ 880 /* RSN data def.key Id and clean this bit in all other keys */ 881 if (pParam->content.rsnOsKey.KeyIndex & 0x80000000) 882 { 883 pRsn->defaultKeyId = keyIndex; 884 885 for (i = 0; i < MAX_KEYS_NUM; i ++) 886 { 887 if (i != keyIndex) 888 { 889 pRsn->keys[i].keyIndex &= 0x7FFFFFFF; 890 } 891 } 892 } 893 894 if (pRsn->defaultKeysOn) 895 { /* This is a WEP default key */ 896 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN_ADD_KEY_PARAM, Default key configured - keyIndex=%d-TI_TRUE\n", keyIndex); 897 898 pRsn->wepDefaultKeys[keyIndex] = TI_TRUE; 899 pRsn->wepStaticKey = TI_TRUE; 900 status = TI_OK; 901 } 902 break; 903 } 904 case RSN_REMOVE_KEY_PARAM: 905 { 906 TI_UINT8 keyIndex; 907 ECipherSuite cipherSuite; 908 909 status = pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &cipherSuite); 910 if (status !=TI_OK) 911 { 912 return status; 913 } 914 /*if (cipherSuite == RSN_CIPHER_NONE) 915 { 916 TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "RSN: Error Remove Wep/Key when no encryption \n"); 917 return TI_NOK; 918 }*/ 919 920 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_REMOVE_KEY_PARAM KeyIndex %x \n", pParam->content.rsnOsKey.KeyIndex); 921 keyIndex = (TI_UINT8)pParam->content.rsnOsKey.KeyIndex; 922 if (keyIndex >= MAX_KEYS_NUM) 923 { 924 return TI_NOK; 925 } 926 927 status = pRsn->pKeyParser->remove (pRsn->pKeyParser, 928 (TI_UINT8*)&pParam->content.rsnOsKey, 929 sizeof(pParam->content.rsnOsKey)); 930 931 if (status == TI_OK) 932 { 933 pRsn->keys[keyIndex].keyType = KEY_NULL; 934 pRsn->keys[keyIndex].keyIndex &= 0x000000FF; 935 } 936 937 break; 938 } 939 940 case RSN_ENCRYPTION_STATUS_PARAM: 941 { 942 ECipherSuite cipherSuite; 943 944 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_ENCRYPTION_STATUS_PARAM rsnEncryptionStatus %d \n", pParam->content.rsnEncryptionStatus); 945 946 pRsn->pAdmCtrl->getCipherSuite (pRsn->pAdmCtrl, &cipherSuite); 947 if (cipherSuite != pParam->content.rsnEncryptionStatus) 948 { 949 status = pRsn->pAdmCtrl->setUcastSuite (pRsn->pAdmCtrl, pParam->content.rsnEncryptionStatus); 950 status = pRsn->pAdmCtrl->setBcastSuite (pRsn->pAdmCtrl, pParam->content.rsnEncryptionStatus); 951 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, " status = %d \n", status); 952 } 953 pRsn->defaultKeysOn = TI_TRUE; 954 } 955 break; 956 957 case RSN_EXT_AUTHENTICATION_MODE: 958 { 959 EExternalAuthMode extAuthMode; 960 961 pRsn->pAdmCtrl->getExtAuthMode (pRsn->pAdmCtrl, &extAuthMode); 962 if (pParam->content.rsnExtAuthneticationMode!=extAuthMode) 963 { 964 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_EXT_AUTHENTICATION_MODE rsnExtAuthneticationMode %d \n", pParam->content.rsnExtAuthneticationMode); 965 966 /* 967 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: remove all Keys\n"); 968 969 for (keyIndex=0; keyIndex<MAX_KEYS_NUM; keyIndex++) 970 { 971 os_memoryCopy(pRsn->hOs, &key, &pRsn->keys[keyIndex], sizeof(TSecurityKeys)); 972 pRsn->removeKey(pRsn, &key); 973 974 }*/ 975 976 status = pRsn->pAdmCtrl->setExtAuthMode (pRsn->pAdmCtrl, pParam->content.rsnExtAuthneticationMode); 977 } 978 pRsn->defaultKeysOn = TI_TRUE; 979 } 980 break; 981 982 #ifdef XCC_MODULE_INCLUDED 983 case RSN_XCC_NETWORK_EAP: 984 { 985 OS_XCC_NETWORK_EAP networkEap; 986 987 pRsn->pAdmCtrl->getNetworkEap (pRsn->pAdmCtrl, &networkEap); 988 if (networkEap != pParam->content.networkEap) 989 { 990 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_XCC_NETWORK_EAP networkEap %d \n", pParam->content.networkEap); 991 992 status = pRsn->pAdmCtrl->setNetworkEap (pRsn->pAdmCtrl, pParam->content.networkEap); 993 if (status == TI_OK) 994 { 995 /*status = RE_SCAN_NEEDED;*/ 996 } 997 } 998 } 999 break; 1000 #endif 1001 case RSN_MIXED_MODE: 1002 { 1003 TI_BOOL mixedMode; 1004 1005 pRsn->pAdmCtrl->getMixedMode (pRsn->pAdmCtrl, &mixedMode); 1006 if (mixedMode!=pParam->content.rsnMixedMode) 1007 { 1008 status = pRsn->pAdmCtrl->setMixedMode (pRsn->pAdmCtrl, pParam->content.rsnMixedMode); 1009 1010 TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_MIXED_MODE mixedMode %d, status=%d \n", pParam->content.rsnMixedMode, status); 1011 } 1012 break; 1013 } 1014 1015 case RSN_PMKID_LIST: 1016 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_PMKID_LIST \n"); 1017 1018 TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8*)&pParam->content.rsnPMKIDList ,sizeof(OS_802_11_PMKID)); 1019 status = pRsn->pAdmCtrl->setPmkidList (pRsn->pAdmCtrl, 1020 &pParam->content.rsnPMKIDList); 1021 if(status == TI_OK) 1022 { 1023 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_PMKID_LIST: %d PMKID entries has been added to the cache.\n", pParam->content.rsnPMKIDList.BSSIDInfoCount); 1024 } 1025 else 1026 { 1027 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_PMKID_LIST failure"); 1028 } 1029 break; 1030 1031 case RSN_WPA_PROMOTE_OPTIONS: 1032 status = pRsn->pAdmCtrl->setPromoteFlags (pRsn->pAdmCtrl, 1033 pParam->content.rsnWPAPromoteFlags); 1034 if(status == TI_OK) 1035 { 1036 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set WPA promote options: %d \n", pParam->content.rsnWPAPromoteFlags); 1037 } 1038 else 1039 { 1040 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set WPA promote options failure"); 1041 } 1042 break; 1043 1044 case RSN_EAP_TYPE: 1045 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Set RSN_EAP_TYPE eapType %d \n", pParam->content.eapType); 1046 1047 pRsn->eapType = pParam->content.eapType; 1048 pRsn->defaultKeysOn = TI_TRUE; 1049 break; 1050 1051 case RSN_SET_KEY_PARAM: 1052 { 1053 TSecurityKeys *pSecurityKey = pParam->content.pRsnKey; 1054 TI_UINT32 keyIndex; 1055 TI_UINT8 j=0; 1056 1057 TRACE2(pRsn->hReport,REPORT_SEVERITY_INFORMATION,"RSN:Set RSN_SET_KEY_PARAM KeyIndex %x,keyLength=%d\n",pSecurityKey->keyIndex,pSecurityKey->encLen); 1058 1059 if(pSecurityKey->keyIndex >= MAX_KEYS_NUM) 1060 { 1061 return TI_NOK; 1062 } 1063 1064 keyIndex = (TI_UINT8)pSecurityKey->keyIndex; 1065 status = rsn_setKey (pRsn, pSecurityKey); /* send key to FW*/ 1066 1067 if (status == TI_OK) 1068 { 1069 //os_memoryCopy(pKeyDerive->hOs,&pRsn->pKeyParser->pUcastKey/pBcastKey, pEncodedKey, sizeof(encodedKeyMaterial_t)); 1070 } /* check this copy */ 1071 1072 1073 /* If the Key is not BAD, it may be that WEP key is sent before WEP status is set, 1074 save the key, and set it later at rsn_start */ 1075 1076 pRsn->keys[keyIndex].keyIndex = pSecurityKey->keyIndex; 1077 pRsn->keys[keyIndex].encLen = pSecurityKey->encLen; 1078 MAC_COPY (pRsn->keys[keyIndex].macAddress, pSecurityKey->macAddress); 1079 os_memoryCopy(pRsn->hOs,(void*)pRsn->keys[keyIndex].keyRsc, (TI_UINT8*)&(pSecurityKey->keyRsc), KEY_RSC_LEN); 1080 os_memoryCopy (pRsn->hOs, (void *)pRsn->keys[keyIndex].encKey, (void*)pSecurityKey->encKey, MAX_KEY_LEN); 1081 1082 /* Process the transmit flag (31-st bit of keyIndex). */ 1083 /* If the added key has the TX bit set to TI_TRUE (i.e. the key */ 1084 /* is the new transmit key (default key), update */ 1085 /* RSN data def.key Id and clean this bit in all other keys */ 1086 if (pSecurityKey->keyIndex & 0x80000000) 1087 { 1088 pRsn->defaultKeyId = keyIndex; 1089 1090 for (j = 0; j < MAX_KEYS_NUM; j++) 1091 { 1092 if (j != keyIndex) 1093 { 1094 pRsn->keys[j].keyIndex &= 0x7FFFFFFF; 1095 } 1096 } 1097 } 1098 1099 if (pRsn->defaultKeysOn) 1100 { /* This is a WEP default key */ 1101 TRACE1(pRsn->hReport,REPORT_SEVERITY_INFORMATION, "RSN_SET_KEY_PARAM, Default key configured-keyIndex=%d-TI_TRUE\n", keyIndex); 1102 1103 pRsn->wepDefaultKeys[keyIndex] = TI_TRUE; 1104 pRsn->wepStaticKey = TI_TRUE; 1105 status = TI_OK; 1106 } 1107 break; 1108 } 1109 1110 default: 1111 return TI_NOK; 1112 } 1113 1114 return status; 1115 } 1116 1117 1118 /** 1119 * 1120 * rsn_eventRecv - Set a specific parameter to the rsniation SM 1121 * 1122 * \b Description: 1123 * 1124 * Set a specific parameter to the rsniation SM. 1125 * 1126 * \b ARGS: 1127 * 1128 * I - hRsn - Rsniation SM context \n 1129 * I/O - pParam - Parameter \n 1130 * 1131 * \b RETURNS: 1132 * 1133 * TI_OK if successful, TI_NOK otherwise. 1134 * 1135 * \sa rsn_Start, rsn_Stop 1136 */ 1137 TI_STATUS rsn_reportStatus (rsn_t *pRsn, TI_STATUS rsnStatus) 1138 { 1139 TI_STATUS status = TI_OK; 1140 paramInfo_t param; 1141 EExternalAuthMode extAuthMode; 1142 1143 if (pRsn == NULL) 1144 { 1145 return TI_NOK; 1146 } 1147 1148 if (rsnStatus == TI_OK) 1149 { 1150 /* set EAPOL encryption status according to authentication protocol */ 1151 pRsn->rsnCompletedTs = os_timeStampMs (pRsn->hOs); 1152 1153 status = pRsn->pAdmCtrl->getExtAuthMode (pRsn->pAdmCtrl, &extAuthMode); 1154 if (status != TI_OK) 1155 { 1156 return status; 1157 } 1158 1159 if (extAuthMode >= RSN_EXT_AUTH_MODE_WPA) 1160 txCtrlParams_setEapolEncryptionStatus (pRsn->hTxCtrl, TI_TRUE); 1161 else 1162 txCtrlParams_setEapolEncryptionStatus (pRsn->hTxCtrl, TI_FALSE); 1163 1164 /* set WEP invoked mode according to cipher suite */ 1165 switch (pRsn->paeConfig.unicastSuite) 1166 { 1167 case TWD_CIPHER_NONE: 1168 param.content.txDataCurrentPrivacyInvokedMode = TI_FALSE; 1169 break; 1170 1171 default: 1172 param.content.txDataCurrentPrivacyInvokedMode = TI_TRUE; 1173 break; 1174 } 1175 1176 txCtrlParams_setCurrentPrivacyInvokedMode(pRsn->hTxCtrl, param.content.txDataCurrentPrivacyInvokedMode); 1177 /* The value of exclude unencrypted should be as privacy invoked */ 1178 param.paramType = RX_DATA_EXCLUDE_UNENCRYPTED_PARAM; 1179 rxData_setParam (pRsn->hRx, ¶m); 1180 1181 param.paramType = RX_DATA_EXCLUDE_BROADCAST_UNENCRYPTED_PARAM; 1182 if (pRsn->pAdmCtrl->mixedMode) 1183 { /* do not exclude Broadcast packets */ 1184 param.content.txDataCurrentPrivacyInvokedMode = TI_FALSE; 1185 } 1186 rxData_setParam (pRsn->hRx, ¶m); 1187 } 1188 1189 else 1190 rsnStatus = (TI_STATUS)STATUS_SECURITY_FAILURE; 1191 1192 status = conn_reportRsnStatus (pRsn->hConn, (mgmtStatus_e)rsnStatus); 1193 1194 if (status!=TI_OK) 1195 { 1196 return status; 1197 } 1198 1199 if (rsnStatus == TI_OK) 1200 { 1201 EvHandlerSendEvent (pRsn->hEvHandler, IPC_EVENT_AUTH_SUCC, NULL, 0); 1202 } 1203 1204 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_reportStatus \n"); 1205 1206 return TI_OK; 1207 } 1208 1209 1210 /** 1211 * 1212 * rsn_eventRecv - Set a specific parameter to the rsniation SM 1213 * 1214 * \b Description: 1215 * 1216 * Set a specific parameter to the rsniation SM. 1217 * 1218 * \b ARGS: 1219 * 1220 * I - hRsn - Rsniation SM context \n 1221 * I/O - pParam - Parameter \n 1222 * 1223 * \b RETURNS: 1224 * 1225 * TI_OK if successful, TI_NOK otherwise. 1226 * 1227 * \sa rsn_Start, rsn_Stop 1228 */ 1229 TI_STATUS rsn_setPaeConfig(rsn_t *pRsn, TRsnPaeConfig *pPaeConfig) 1230 { 1231 TI_STATUS status; 1232 mainSecInitData_t initData; 1233 1234 if ( (NULL == pRsn) || (NULL == pPaeConfig) ) 1235 { 1236 return TI_NOK; 1237 } 1238 1239 TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: Calling set PAE config..., unicastSuite = %d, broadcastSuite = %d \n", pPaeConfig->unicastSuite, pPaeConfig->broadcastSuite); 1240 1241 os_memoryCopy(pRsn->hOs, &pRsn->paeConfig, pPaeConfig, sizeof(TRsnPaeConfig)); 1242 1243 initData.pPaeConfig = &pRsn->paeConfig; 1244 1245 status = mainSec_config (pRsn->pMainSecSm, 1246 &initData, 1247 pRsn, 1248 pRsn->hReport, 1249 pRsn->hOs, 1250 pRsn->hCtrlData, 1251 pRsn->hEvHandler, 1252 pRsn->hConn, 1253 pRsn->hTimer); 1254 1255 return status; 1256 } 1257 1258 1259 /** 1260 * 1261 * rsn_eventRecv - Set a specific parameter to the rsniation SM 1262 * 1263 * \b Description: 1264 * 1265 * Set a specific parameter to the rsniation SM. 1266 * 1267 * \b ARGS: 1268 * 1269 * I - hRsn - Rsniation SM context \n 1270 * I/O - pParam - Parameter \n 1271 * 1272 * \b RETURNS: 1273 * 1274 * TI_OK if successful, TI_NOK otherwise. 1275 * 1276 * \sa rsn_Start, rsn_Stop 1277 */ 1278 TI_STATUS rsn_getNetworkMode(rsn_t *pRsn, ERsnNetworkMode *pNetMode) 1279 { 1280 paramInfo_t param; 1281 TI_STATUS status; 1282 1283 param.paramType = CTRL_DATA_CURRENT_BSS_TYPE_PARAM; 1284 1285 status = ctrlData_getParam (pRsn->hCtrlData, ¶m); 1286 1287 if (status == TI_OK) 1288 { 1289 if (param.content.ctrlDataCurrentBssType == BSS_INFRASTRUCTURE) 1290 { 1291 *pNetMode = RSN_INFRASTRUCTURE; 1292 } 1293 else 1294 { 1295 *pNetMode = RSN_IBSS; 1296 } 1297 } 1298 else 1299 { 1300 return TI_NOK; 1301 } 1302 1303 return TI_OK; 1304 } 1305 1306 1307 /** 1308 * 1309 * rsn_eventRecv - Set a specific parameter to the rsniation SM 1310 * 1311 * \b Description: 1312 * 1313 * Set a specific parameter to the rsniation SM. 1314 * 1315 * \b ARGS: 1316 * 1317 * I - hRsn - Rsniation SM context \n 1318 * I/O - pParam - Parameter \n 1319 * 1320 * \b RETURNS: 1321 * 1322 * TI_OK if successful, TI_NOK otherwise. 1323 * 1324 * \sa rsn_Start, rsn_Stop 1325 */ 1326 TI_STATUS rsn_evalSite(TI_HANDLE hRsn, TRsnData *pRsnData, TRsnSiteParams *pRsnSiteParams, TI_UINT32 *pMetric) 1327 { 1328 1329 rsn_t *pRsn; 1330 TI_STATUS status; 1331 1332 if ( (NULL == pRsnData) || (NULL == hRsn) ) 1333 { 1334 *pMetric = 0; 1335 return TI_NOK; 1336 } 1337 1338 pRsn = (rsn_t*)hRsn; 1339 1340 if (rsn_isSiteBanned(hRsn, pRsnSiteParams->bssid) == TI_TRUE) 1341 { 1342 *pMetric = 0; 1343 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site is banned!\n"); 1344 return TI_NOK; 1345 } 1346 1347 status = pRsn->pAdmCtrl->evalSite (pRsn->pAdmCtrl, pRsnData, pRsnSiteParams, pMetric); 1348 1349 TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": pMetric=%d status=%d\n", *pMetric, status); 1350 1351 return status; 1352 } 1353 1354 1355 /** 1356 * 1357 * rsn_getInfoElement - 1358 * 1359 * \b Description: 1360 * 1361 * Get the RSN information element. 1362 * 1363 * \b ARGS: 1364 * 1365 * I - hRsn - Rsn SM context \n 1366 * I/O - pRsnIe - Pointer to the return information element \n 1367 * I/O - pRsnIeLen - Pointer to the returned IE's length \n 1368 * 1369 * \b RETURNS: 1370 * 1371 * TI_OK if successful, TI_NOK otherwise. 1372 * 1373 * \sa 1374 */ 1375 TI_STATUS rsn_getInfoElement(TI_HANDLE hRsn, TI_UINT8 *pRsnIe, TI_UINT32 *pRsnIeLen) 1376 { 1377 rsn_t *pRsn; 1378 TI_STATUS status; 1379 1380 if ( (NULL == hRsn) || (NULL == pRsnIe) || (NULL == pRsnIeLen) ) 1381 { 1382 return TI_NOK; 1383 } 1384 1385 pRsn = (rsn_t*)hRsn; 1386 1387 status = pRsn->pAdmCtrl->getInfoElement (pRsn->pAdmCtrl, pRsnIe, pRsnIeLen); 1388 1389 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_getInfoElement pRsnIeLen= %d\n",*pRsnIeLen); 1390 1391 return status; 1392 } 1393 1394 1395 #ifdef XCC_MODULE_INCLUDED 1396 /** 1397 * 1398 * rsn_getXCCExtendedInfoElement - 1399 * 1400 * \b Description: 1401 * 1402 * Get the Aironet information element. 1403 * 1404 * \b ARGS: 1405 * 1406 * I - hRsn - Rsn SM context \n 1407 * I/O - pRsnIe - Pointer to the return information element \n 1408 * I/O - pRsnIeLen - Pointer to the returned IE's length \n 1409 * 1410 * \b RETURNS: 1411 * 1412 * TI_OK if successful, TI_NOK otherwise. 1413 * 1414 * \sa 1415 */ 1416 TI_STATUS rsn_getXCCExtendedInfoElement(TI_HANDLE hRsn, TI_UINT8 *pRsnIe, TI_UINT8 *pRsnIeLen) 1417 { 1418 rsn_t *pRsn; 1419 TI_STATUS status; 1420 1421 if ( (NULL == hRsn) || (NULL == pRsnIe) || (NULL == pRsnIeLen) ) 1422 { 1423 return TI_NOK; 1424 } 1425 1426 pRsn = (rsn_t*)hRsn; 1427 1428 status = admCtrlXCC_getInfoElement (pRsn->pAdmCtrl, pRsnIe, pRsnIeLen); 1429 1430 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_getXCCExtendedInfoElement pRsnIeLen= %d\n",*pRsnIeLen); 1431 1432 return status; 1433 } 1434 #endif 1435 1436 1437 /** 1438 * 1439 * rsn_eventRecv - Set a specific parameter to the rsniation SM 1440 * 1441 * \b Description: 1442 * 1443 * Set a specific parameter to the rsniation SM. 1444 * 1445 * \b ARGS: 1446 * 1447 * I - hRsn - Rsniation SM context \n 1448 * I/O - pParam - Parameter \n 1449 * 1450 * \b RETURNS: 1451 * 1452 * TI_OK if successful, TI_NOK otherwise. 1453 * 1454 * \sa rsn_Start, rsn_Stop 1455 */ 1456 TI_STATUS rsn_setSite(TI_HANDLE hRsn, TRsnData *pRsnData, TI_UINT8 *pAssocIe, TI_UINT8 *pAssocIeLen) 1457 { 1458 rsn_t *pRsn; 1459 TI_STATUS status; 1460 1461 if ( (NULL == pRsnData) || (NULL == hRsn) ) 1462 { 1463 *pAssocIeLen = 0; 1464 return TI_NOK; 1465 } 1466 1467 pRsn = (rsn_t*)hRsn; 1468 1469 status = pRsn->pAdmCtrl->setSite (pRsn->pAdmCtrl, pRsnData, pAssocIe, pAssocIeLen); 1470 1471 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_setSite ieLen= %d\n",pRsnData->ieLen); 1472 return status; 1473 } 1474 1475 1476 TI_STATUS rsn_setKey (rsn_t *pRsn, TSecurityKeys *pKey) 1477 { 1478 TTwdParamInfo tTwdParam; 1479 TI_UINT8 keyIndex; 1480 TI_BOOL macIsBroadcast = TI_FALSE; 1481 TI_STATUS status = TI_OK; 1482 1483 if (pRsn == NULL || pKey == NULL) 1484 { 1485 return TI_NOK; 1486 } 1487 1488 keyIndex = (TI_UINT8)pKey->keyIndex; 1489 if (keyIndex >= MAX_KEYS_NUM) 1490 { 1491 return TI_NOK; 1492 } 1493 1494 if (pKey->keyType != KEY_NULL) 1495 { 1496 /* set the size to reserve for encryption to the tx */ 1497 /* update this parameter only in accordance with pairwise key setting */ 1498 if (!MAC_BROADCAST(pKey->macAddress)) 1499 { 1500 1501 /* set the size to reserve for encryption to the tx */ 1502 switch (pKey->keyType) 1503 { 1504 case KEY_TKIP: 1505 txCtrlParams_setEncryptionFieldSizes (pRsn->hTxCtrl, IV_FIELD_SIZE); 1506 break; 1507 case KEY_AES: 1508 txCtrlParams_setEncryptionFieldSizes (pRsn->hTxCtrl, AES_AFTER_HEADER_FIELD_SIZE); 1509 break; 1510 case KEY_NULL: 1511 case KEY_WEP: 1512 case KEY_XCC: 1513 default: 1514 txCtrlParams_setEncryptionFieldSizes (pRsn->hTxCtrl, 0); 1515 break; 1516 } 1517 1518 } 1519 1520 1521 macIsBroadcast = MAC_BROADCAST (pKey->macAddress); 1522 if ((pRsn->keys[keyIndex].keyType != KEY_NULL )&& 1523 macIsBroadcast && !MAC_BROADCAST((pRsn->keys[keyIndex].macAddress))) 1524 { /* In case a new Group key is set instead of a Unicast key, 1525 first remove the UNIcast key from FW */ 1526 rsn_removeKey(pRsn, &pRsn->keys[keyIndex]); 1527 } 1528 1529 pRsn->keys[keyIndex].keyType = pKey->keyType; 1530 pRsn->keys[keyIndex].keyIndex = keyIndex; 1531 1532 tTwdParam.paramType = TWD_RSN_KEY_ADD_PARAM_ID; 1533 tTwdParam.content.configureCmdCBParams.pCb = (TI_UINT8*) pKey; 1534 tTwdParam.content.configureCmdCBParams.fCb = NULL; 1535 tTwdParam.content.configureCmdCBParams.hCb = NULL; 1536 1537 if (macIsBroadcast) 1538 { 1539 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_setKey, Group ReKey timer started\n"); 1540 tmr_StopTimer (pRsn->hMicFailureGroupReKeyTimer); 1541 tmr_StartTimer (pRsn->hMicFailureGroupReKeyTimer, 1542 rsn_groupReKeyTimeout, 1543 (TI_HANDLE)pRsn, 1544 RSN_MIC_FAILURE_RE_KEY_TIMEOUT, 1545 TI_FALSE); 1546 pRsn->eGroupKeyUpdate = GROUP_KEY_UPDATE_TRUE; 1547 } 1548 else 1549 { 1550 if (pRsn->bPairwiseMicFailureFilter) /* the value of this flag is taken from registry */ 1551 { 1552 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_setKey, Pairwise ReKey timer started\n"); 1553 tmr_StopTimer (pRsn->hMicFailurePairwiseReKeyTimer); 1554 tmr_StartTimer (pRsn->hMicFailurePairwiseReKeyTimer, 1555 rsn_pairwiseReKeyTimeout, 1556 (TI_HANDLE)pRsn, 1557 RSN_MIC_FAILURE_RE_KEY_TIMEOUT, 1558 TI_FALSE); 1559 pRsn->ePairwiseKeyUpdate = PAIRWISE_KEY_UPDATE_TRUE; 1560 } 1561 } 1562 1563 1564 /* Mark key as added */ 1565 pRsn->keys_en [keyIndex] = TI_TRUE; 1566 1567 status = TWD_SetParam (pRsn->hTWD, &tTwdParam); 1568 } 1569 1570 TRACE3(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_setKey, KeyType=%d, KeyId = 0x%lx,encLen=0x%x\n", pKey->keyType,pKey->keyIndex, pKey->encLen); 1571 1572 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nEncKey = "); 1573 1574 TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->encKey, pKey->encLen); 1575 1576 if (pKey->keyType != KEY_WEP) 1577 { 1578 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nMac address = "); 1579 TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->macAddress, MAC_ADDR_LEN); 1580 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nRSC = "); 1581 TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->keyRsc, KEY_RSC_LEN); 1582 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nMic RX = "); 1583 TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->micRxKey, MAX_KEY_LEN); 1584 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "\nMic TX = "); 1585 TRACE_INFO_HEX(pRsn->hReport, (TI_UINT8 *)pKey->micTxKey, MAX_KEY_LEN); 1586 } 1587 1588 return status; 1589 } 1590 1591 1592 TI_STATUS rsn_removeKey (rsn_t *pRsn, TSecurityKeys *pKey) 1593 { 1594 TI_STATUS status = TI_OK; 1595 TTwdParamInfo tTwdParam; 1596 TI_UINT8 keyIndex; 1597 1598 if (pRsn == NULL || pKey == NULL) 1599 { 1600 return TI_NOK; 1601 } 1602 1603 keyIndex = (TI_UINT8)pKey->keyIndex; 1604 if (keyIndex >= MAX_KEYS_NUM) 1605 { 1606 return TI_NOK; 1607 } 1608 1609 TRACE2(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_removeKey Entry, keyType=%d, keyIndex=0x%lx\n",pKey->keyType, keyIndex); 1610 1611 /* Now set to the RSN structure. */ 1612 if (pKey->keyType != KEY_NULL && pRsn->keys_en[keyIndex]) 1613 { 1614 tTwdParam.paramType = TWD_RSN_KEY_REMOVE_PARAM_ID; 1615 /*os_memoryCopy(pRsn->hOs, &tTwdParam.content.rsnKey, pKey, sizeof(TSecurityKeys));*/ 1616 tTwdParam.content.configureCmdCBParams.pCb = (TI_UINT8*) pKey; 1617 tTwdParam.content.configureCmdCBParams.fCb = NULL; 1618 tTwdParam.content.configureCmdCBParams.hCb = NULL; 1619 1620 /* If keyType is TKIP or AES, set the encLen to the KEY enc len - 16 */ 1621 if (pKey->keyType == KEY_TKIP || pKey->keyType == KEY_AES) 1622 { 1623 pKey->encLen = 16; 1624 if (keyIndex != 0) 1625 { 1626 const TI_UINT8 broadcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 1627 /* 1628 * if keyType is TKIP or AES, and the key index is broadcast, overwrite the MAC address as broadcast 1629 * for removing the Broadcast key from the FW 1630 */ 1631 MAC_COPY (pKey->macAddress, broadcast); 1632 } 1633 } 1634 else if (pKey->keyType == KEY_WEP) 1635 { 1636 /* In full driver we use only WEP default keys. To remove it we make sure that the MAC address is NULL */ 1637 os_memoryZero(pRsn->hOs,(void*)pKey->macAddress,sizeof(TMacAddr)); 1638 } 1639 1640 1641 /* Mark key as deleted */ 1642 pRsn->keys_en[keyIndex] = TI_FALSE; 1643 1644 status = TWD_SetParam (pRsn->hTWD, &tTwdParam); 1645 1646 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_removeKey in whal, status =%d\n", status); 1647 1648 /* clean the key flags*/ 1649 pRsn->keys[keyIndex].keyIndex &= 0x000000FF; 1650 pRsn->keys[keyIndex].keyType = KEY_NULL; 1651 pRsn->keys[keyIndex].encLen = 0; 1652 pRsn->wepDefaultKeys[keyIndex] = TI_FALSE; 1653 } 1654 1655 return status; 1656 } 1657 1658 1659 TI_STATUS rsn_setDefaultKeyId(rsn_t *pRsn, TI_UINT8 keyId) 1660 { 1661 TI_STATUS status = TI_OK; 1662 TTwdParamInfo tTwdParam; 1663 1664 if (pRsn == NULL) 1665 { 1666 return TI_NOK; 1667 } 1668 pRsn->defaultKeyId = keyId; 1669 /* Now we configure default key ID to the HAL */ 1670 tTwdParam.paramType = TWD_RSN_DEFAULT_KEY_ID_PARAM_ID; 1671 tTwdParam.content.configureCmdCBParams.pCb = &keyId; 1672 tTwdParam.content.configureCmdCBParams.fCb = NULL; 1673 tTwdParam.content.configureCmdCBParams.hCb = NULL; 1674 status = TWD_SetParam (pRsn->hTWD, &tTwdParam); 1675 1676 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "RSN: rsn_setDefaultKeyId, KeyId = 0x%lx\n", keyId); 1677 return status; 1678 } 1679 1680 1681 TI_STATUS rsn_reportAuthFailure(TI_HANDLE hRsn, EAuthStatus authStatus) 1682 { 1683 TI_STATUS status = TI_OK; 1684 rsn_t *pRsn; 1685 paramInfo_t param; 1686 1687 if (hRsn==NULL) 1688 { 1689 return TI_NOK; 1690 } 1691 1692 pRsn = (rsn_t*)hRsn; 1693 1694 /* Remove AP from candidate list for a specified amount of time */ 1695 param.paramType = CTRL_DATA_CURRENT_BSSID_PARAM; 1696 status = ctrlData_getParam(pRsn->hCtrlData, ¶m); 1697 if (status != TI_OK) 1698 { 1699 TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, "rsn_reportAuthFailure, unable to retrieve BSSID \n"); 1700 } 1701 else 1702 { 1703 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "current station is banned from the roaming candidates list for %d Ms\n", RSN_AUTH_FAILURE_TIMEOUT); 1704 1705 rsn_banSite(hRsn, param.content.ctrlDataCurrentBSSID, RSN_SITE_BAN_LEVEL_FULL, RSN_AUTH_FAILURE_TIMEOUT); 1706 } 1707 1708 1709 #ifdef XCC_MODULE_INCLUDED 1710 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "CALLING rougeAP, status= %d \n",authStatus); 1711 status = XCCMngr_rogueApDetected (pRsn->hXCCMngr, authStatus); 1712 #endif 1713 TI_VOIDCAST(pRsn); 1714 return status; 1715 } 1716 1717 1718 /****** 1719 This is the CB function for mic failure event from the FW 1720 *******/ 1721 TI_STATUS rsn_reportMicFailure(TI_HANDLE hRsn, TI_UINT8 *pType, TI_UINT32 Length) 1722 { 1723 rsn_t *pRsn = (rsn_t *) hRsn; 1724 ERsnSiteBanLevel banLevel; 1725 OS_802_11_AUTHENTICATION_REQUEST *request; 1726 TI_UINT8 AuthBuf[sizeof(TI_UINT32) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)]; 1727 paramInfo_t param; 1728 TI_UINT8 failureType; 1729 1730 failureType = *pType; 1731 1732 if (((pRsn->paeConfig.unicastSuite == TWD_CIPHER_TKIP) && (failureType == KEY_TKIP_MIC_PAIRWISE)) || 1733 ((pRsn->paeConfig.broadcastSuite == TWD_CIPHER_TKIP) && (failureType == KEY_TKIP_MIC_GROUP))) 1734 { 1735 /* check if the MIC failure is group and group key update */ 1736 /* was performed during the last 3 seconds */ 1737 if ((failureType == KEY_TKIP_MIC_GROUP) && 1738 (pRsn->eGroupKeyUpdate == GROUP_KEY_UPDATE_TRUE)) 1739 { 1740 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Group MIC failure ignored, key update was performed within the last 3 seconds.\n"); 1741 return TI_OK; 1742 } 1743 1744 /* check if the MIC failure is pairwise and pairwise key update */ 1745 /* was performed during the last 3 seconds */ 1746 if ((failureType == KEY_TKIP_MIC_PAIRWISE) && 1747 (pRsn->ePairwiseKeyUpdate == PAIRWISE_KEY_UPDATE_TRUE)) 1748 { 1749 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Pairwise MIC failure ignored, key update was performed within the last 3 seconds.\n"); 1750 return TI_OK; 1751 } 1752 1753 /* Prepare the Authentication Request */ 1754 request = (OS_802_11_AUTHENTICATION_REQUEST *)(AuthBuf + sizeof(TI_UINT32)); 1755 request->Length = sizeof(OS_802_11_AUTHENTICATION_REQUEST); 1756 1757 param.paramType = CTRL_DATA_CURRENT_BSSID_PARAM; 1758 if (ctrlData_getParam (pRsn->hCtrlData, ¶m) != TI_OK) 1759 { 1760 return TI_NOK; 1761 } 1762 1763 /* Generate 802 Media specific indication event */ 1764 *(TI_UINT32*)AuthBuf = os802_11StatusType_Authentication; 1765 1766 MAC_COPY (request->BSSID, param.content.ctrlDataCurrentBSSID); 1767 1768 if (failureType == KEY_TKIP_MIC_PAIRWISE) 1769 { 1770 request->Flags = OS_802_11_REQUEST_PAIRWISE_ERROR; 1771 } 1772 else 1773 { 1774 request->Flags = OS_802_11_REQUEST_GROUP_ERROR; 1775 } 1776 1777 EvHandlerSendEvent (pRsn->hEvHandler, 1778 IPC_EVENT_MEDIA_SPECIFIC, 1779 (TI_UINT8*)AuthBuf, 1780 sizeof(TI_UINT32) + sizeof(OS_802_11_AUTHENTICATION_REQUEST)); 1781 /* Update and check the ban level to decide what actions need to take place */ 1782 banLevel = rsn_banSite (hRsn, param.content.ctrlDataCurrentBSSID, RSN_SITE_BAN_LEVEL_HALF, RSN_MIC_FAILURE_TIMEOUT); 1783 if (banLevel == RSN_SITE_BAN_LEVEL_FULL) 1784 { 1785 /* Site is banned so prepare to disconnect */ 1786 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Second MIC failure, closing Rx port...\n"); 1787 1788 param.paramType = RX_DATA_PORT_STATUS_PARAM; 1789 param.content.rxDataPortStatus = CLOSE; 1790 rxData_setParam(pRsn->hRx, ¶m); 1791 1792 /* stop the mic failure Report timer and start a new one for 0.5 seconds */ 1793 tmr_StopTimer (pRsn->hMicFailureReportWaitTimer); 1794 apConn_setDeauthPacketReasonCode(pRsn->hAPConn, STATUS_MIC_FAILURE); 1795 tmr_StartTimer (pRsn->hMicFailureReportWaitTimer, 1796 rsn_micFailureReportTimeout, 1797 (TI_HANDLE)pRsn, 1798 RSN_MIC_FAILURE_REPORT_TIMEOUT, 1799 TI_FALSE); 1800 } 1801 else 1802 { 1803 /* Site is only half banned so nothing needs to be done for now */ 1804 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": First MIC failure, business as usual for now...\n"); 1805 } 1806 } 1807 1808 return TI_OK; 1809 } 1810 1811 1812 void rsn_groupReKeyTimeout(TI_HANDLE hRsn, TI_BOOL bTwdInitOccured) 1813 { 1814 rsn_t *pRsn; 1815 1816 pRsn = (rsn_t*)hRsn; 1817 1818 if (pRsn == NULL) 1819 { 1820 return; 1821 } 1822 1823 pRsn->eGroupKeyUpdate = GROUP_KEY_UPDATE_FALSE; 1824 } 1825 1826 1827 void rsn_pairwiseReKeyTimeout(TI_HANDLE hRsn, TI_BOOL bTwdInitOccured) 1828 { 1829 rsn_t *pRsn; 1830 1831 pRsn = (rsn_t*)hRsn; 1832 1833 if (pRsn == NULL) 1834 { 1835 return; 1836 } 1837 1838 pRsn->ePairwiseKeyUpdate = PAIRWISE_KEY_UPDATE_FALSE; 1839 } 1840 1841 void rsn_micFailureReportTimeout (TI_HANDLE hRsn, TI_BOOL bTwdInitOccured) 1842 { 1843 rsn_t *pRsn; 1844 1845 pRsn = (rsn_t*)hRsn; 1846 1847 if (pRsn == NULL) 1848 { 1849 return; 1850 } 1851 1852 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": MIC failure reported, disassociating...\n"); 1853 1854 apConn_reportRoamingEvent (pRsn->hAPConn, ROAMING_TRIGGER_SECURITY_ATTACK, NULL); 1855 } 1856 1857 1858 /** 1859 * 1860 * rsn_resetPMKIDList - 1861 * 1862 * \b Description: 1863 * Cleans up the PMKID cache. 1864 * Called when SSID is being changed. 1865 * 1866 * \b ARGS: 1867 * 1868 * I - hRsn - Rsniation SM context \n 1869 * 1870 * \b RETURNS: 1871 * 1872 * TI_OK if successful, TI_NOK otherwise. 1873 */ 1874 1875 TI_STATUS rsn_resetPMKIDList(TI_HANDLE hRsn) 1876 { 1877 rsn_t *pRsn = (rsn_t*)hRsn; 1878 1879 if (!pRsn) 1880 return TI_NOK; 1881 1882 return (pRsn->pAdmCtrl->resetPmkidList (pRsn->pAdmCtrl)); 1883 } 1884 1885 1886 void rsn_debugFunc(TI_HANDLE hRsn) 1887 { 1888 rsn_t *pRsn; 1889 1890 if (hRsn == NULL) 1891 { 1892 return; 1893 } 1894 pRsn = (rsn_t*)hRsn; 1895 1896 WLAN_OS_REPORT(("rsnStartedTs, ts = %d\n", pRsn->rsnStartedTs)); 1897 WLAN_OS_REPORT(("rsnCompletedTs, ts = %d\n", pRsn->rsnCompletedTs)); 1898 } 1899 1900 1901 /** 1902 * 1903 * rsn_startPreAuth - 1904 * 1905 * \b Description: 1906 * 1907 * Start pre-authentication on a list of given BSSIDs. 1908 * 1909 * \b ARGS: 1910 * 1911 * I - hRsn - Rsniation SM context \n 1912 * I/O - pBssidList - list of BSSIDs that require Pre-Auth \n 1913 * 1914 * \b RETURNS: 1915 * 1916 * TI_OK if successful, TI_NOK otherwise. 1917 * 1918 * \sa 1919 */ 1920 TI_STATUS rsn_startPreAuth(TI_HANDLE hRsn, TBssidList4PreAuth *pBssidList) 1921 { 1922 rsn_t *pRsn; 1923 TI_STATUS status; 1924 1925 if ( (NULL == hRsn) || (NULL == pBssidList) ) 1926 { 1927 return TI_NOK; 1928 } 1929 1930 pRsn = (rsn_t*)hRsn; 1931 1932 status = pRsn->pAdmCtrl->startPreAuth (pRsn->pAdmCtrl, pBssidList); 1933 1934 TRACE0(pRsn->hReport, REPORT_SEVERITY_INFORMATION, "rsn_startPreAuth \n"); 1935 1936 return status; 1937 } 1938 1939 1940 /** 1941 * 1942 * isSiteBanned - 1943 * 1944 * \b Description: 1945 * 1946 * Returns whether or not the site with the specified Bssid is banned or not. 1947 * 1948 * \b ARGS: 1949 * 1950 * I - hRsn - RSN module context \n 1951 * I - siteBssid - The desired site's bssid \n 1952 * 1953 * \b RETURNS: 1954 * 1955 * TI_NOK iff site is banned. 1956 * 1957 */ 1958 TI_BOOL rsn_isSiteBanned(TI_HANDLE hRsn, TMacAddr siteBssid) 1959 { 1960 rsn_t * pRsn = (rsn_t *) hRsn; 1961 rsn_siteBanEntry_t * entry; 1962 1963 /* Check if site is in the list */ 1964 if ((entry = findBannedSiteAndCleanup(hRsn, siteBssid)) == NULL) 1965 { 1966 return TI_FALSE; 1967 } 1968 1969 TRACE7(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X found with ban level %d...\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5], entry->banLevel); 1970 1971 return (entry->banLevel == RSN_SITE_BAN_LEVEL_FULL); 1972 } 1973 1974 1975 /** 1976 * 1977 * rsn_PortStatus_Set API implementation- 1978 * 1979 * \b Description: 1980 * 1981 * set the status port according to the status flag 1982 * 1983 * \b ARGS: 1984 * 1985 * I - hRsn - RSN module context \n 1986 * I - state - The status flag \n 1987 * 1988 * \b RETURNS: 1989 * 1990 * TI_STATUS. 1991 * 1992 */ 1993 TI_STATUS rsn_setPortStatus(TI_HANDLE hRsn, TI_BOOL state) 1994 { 1995 rsn_t *pRsn = (rsn_t *)hRsn; 1996 struct externalSec_t *pExtSec; 1997 1998 pExtSec = pRsn->pMainSecSm->pExternalSec; 1999 pExtSec->bPortStatus = state; 2000 return externalSec_rsnComplete(pExtSec); 2001 } 2002 2003 2004 /** 2005 * 2006 * rsn_banSite - 2007 * 2008 * \b Description: 2009 * 2010 * Bans the specified site from being associated to for the specified duration. 2011 * If a ban level of WARNING is given and no previous ban was in effect the 2012 * warning is marked down but other than that nothing happens. In case a previous 2013 * warning (or ban of course) is still in effect 2014 * 2015 * \b ARGS: 2016 * 2017 * I - hRsn - RSN module context \n 2018 * I - siteBssid - The desired site's bssid \n 2019 * I - banLevel - The desired level of ban (Warning / Ban) 2020 * I - durationMs - The duration of ban in milliseconds 2021 * 2022 * \b RETURNS: 2023 * 2024 * The level of ban (warning / banned). 2025 * 2026 */ 2027 ERsnSiteBanLevel rsn_banSite(TI_HANDLE hRsn, TMacAddr siteBssid, ERsnSiteBanLevel banLevel, TI_UINT32 durationMs) 2028 { 2029 rsn_t * pRsn = (rsn_t *) hRsn; 2030 rsn_siteBanEntry_t * entry; 2031 2032 /* Try finding the site in the list */ 2033 if ((entry = findBannedSiteAndCleanup(hRsn, siteBssid)) != NULL) 2034 { 2035 /* Site found so a previous ban is still in effect */ 2036 TRACE6(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X found and has been set to ban level full!\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5]); 2037 2038 entry->banLevel = RSN_SITE_BAN_LEVEL_FULL; 2039 } 2040 else 2041 { 2042 /* Site doesn't appear in the list, so find a place to insert it */ 2043 TRACE7(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X added with ban level %d!\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5], banLevel); 2044 2045 entry = findEntryForInsert (hRsn); 2046 2047 MAC_COPY (entry->siteBssid, siteBssid); 2048 entry->banLevel = banLevel; 2049 2050 pRsn->numOfBannedSites++; 2051 } 2052 2053 entry->banStartedMs = os_timeStampMs (pRsn->hOs); 2054 entry->banDurationMs = durationMs; 2055 2056 return entry->banLevel; 2057 } 2058 2059 2060 /** 2061 * 2062 * findEntryForInsert - 2063 * 2064 * \b Description: 2065 * 2066 * Returns a place to insert a new banned site. 2067 * 2068 * \b ARGS: 2069 * 2070 * I - hRsn - RSN module context \n 2071 * 2072 * \b RETURNS: 2073 * 2074 * A pointer to a suitable site entry. 2075 * 2076 */ 2077 static rsn_siteBanEntry_t * findEntryForInsert(TI_HANDLE hRsn) 2078 { 2079 rsn_t * pRsn = (rsn_t *) hRsn; 2080 2081 /* In the extreme case that the list is full we overwrite an old entry */ 2082 if (pRsn->numOfBannedSites == RSN_MAX_NUMBER_OF_BANNED_SITES) 2083 { 2084 TRACE0(pRsn->hReport, REPORT_SEVERITY_ERROR, ": No room left to insert new banned site, overwriting old one!\n"); 2085 2086 return &(pRsn->bannedSites[0]); 2087 } 2088 2089 return &(pRsn->bannedSites[pRsn->numOfBannedSites]); 2090 } 2091 2092 2093 /** 2094 * 2095 * findBannedSiteAndCleanup - 2096 * 2097 * \b Description: 2098 * 2099 * Searches the banned sites list for the desired site while cleaning up 2100 * expired sites found along the way. 2101 * 2102 * Note that this function might change the structure of the banned sites 2103 * list so old iterators into the list might be invalidated. 2104 * 2105 * \b ARGS: 2106 * 2107 * I - hRsn - RSN module context \n 2108 * I - siteBssid - The desired site's bssid \n 2109 * 2110 * \b RETURNS: 2111 * 2112 * A pointer to the desired site's entry if found, 2113 * NULL otherwise. 2114 * 2115 */ 2116 static rsn_siteBanEntry_t * findBannedSiteAndCleanup(TI_HANDLE hRsn, TMacAddr siteBssid) 2117 { 2118 rsn_t * pRsn = (rsn_t *) hRsn; 2119 int iter; 2120 2121 for (iter = 0; iter < pRsn->numOfBannedSites; iter++) 2122 { 2123 /* If this entry has expired we'd like to clean it up */ 2124 if (os_timeStampMs(pRsn->hOs) - pRsn->bannedSites[iter].banStartedMs >= pRsn->bannedSites[iter].banDurationMs) 2125 { 2126 TRACE1(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Found expired entry at index %d, cleaning it up...\n", iter); 2127 2128 /* Replace this entry with the last one */ 2129 pRsn->bannedSites[iter] = pRsn->bannedSites[pRsn->numOfBannedSites - 1]; 2130 pRsn->numOfBannedSites--; 2131 2132 /* we now repeat the iteration on this entry */ 2133 iter--; 2134 2135 continue; 2136 } 2137 2138 /* Is this the entry for the site we're looking for? */ 2139 if (MAC_EQUAL (siteBssid, pRsn->bannedSites[iter].siteBssid)) 2140 { 2141 TRACE7(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X found at index %d!\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5], iter); 2142 2143 return &pRsn->bannedSites[iter]; 2144 } 2145 } 2146 2147 /* Entry not found... */ 2148 TRACE6(pRsn->hReport, REPORT_SEVERITY_INFORMATION, ": Site %02X-%02X-%02X-%02X-%02X-%02X not found...\n", siteBssid[0], siteBssid[1], siteBssid[2], siteBssid[3], siteBssid[4], siteBssid[5]); 2149 2150 return NULL; 2151 } 2152 2153 /** 2154 * 2155 * rsn_getPortStatus - 2156 * 2157 * \b Description: 2158 * 2159 * Returns the extrenalSec port status 2160 * 2161 * \b ARGS: 2162 * 2163 * pRsn - pointer to RSN module context \n 2164 * 2165 * \b RETURNS: 2166 * 2167 * TI_BOOL - the port status True = Open , False = Close 2168 * 2169 */ 2170 TI_BOOL rsn_getPortStatus(rsn_t *pRsn) 2171 { 2172 struct externalSec_t *pExtSec; 2173 2174 pExtSec = pRsn->pMainSecSm->pExternalSec; 2175 return pExtSec->bPortStatus; 2176 } 2177 2178 2179 #ifdef RSN_NOT_USED 2180 2181 static TI_INT16 convertAscii2Unicode(TI_INT8* userPwd, TI_INT16 len) 2182 { 2183 TI_INT16 i; 2184 TI_INT8 unsiiPwd[MAX_PASSWD_LEN]; 2185 2186 2187 for (i=0; i<len; i++) 2188 { 2189 unsiiPwd[i] = userPwd[i]; 2190 } 2191 for (i=0; i<len; i++) 2192 { 2193 userPwd[i*2] = unsiiPwd[i]; 2194 userPwd[i*2+1] = 0; 2195 } 2196 return (TI_INT16)(len*2); 2197 } 2198 2199 #endif 2200 2201 /*************************************************************************** 2202 * rsn_reAuth * 2203 **************************************************************************** 2204 * DESCRIPTION: This is a callback function called by the whalWPA module whenever 2205 * a broadcast TKIP key was configured to the FW. 2206 * It does the following: 2207 * - resets the ReAuth flag 2208 * - stops the ReAuth timer 2209 * - restore the PS state 2210 * - Send RE_AUTH_COMPLETED event to the upper layer. 2211 * 2212 * INPUTS: hRsn - the object 2213 * 2214 * OUTPUT: None 2215 * 2216 * RETURNS: None 2217 * 2218 ***************************************************************************/ 2219 void rsn_reAuth(TI_HANDLE hRsn) 2220 { 2221 rsn_t *pRsn; 2222 2223 pRsn = (rsn_t*)hRsn; 2224 2225 if (pRsn == NULL) 2226 { 2227 return; 2228 } 2229 2230 if (rxData_IsReAuthInProgress(pRsn->hRx)) 2231 { 2232 rxData_SetReAuthInProgress(pRsn->hRx, TI_FALSE); 2233 rxData_StopReAuthActiveTimer(pRsn->hRx); 2234 rxData_ReauthDisablePriority(pRsn->hRx); 2235 EvHandlerSendEvent(pRsn->hEvHandler, IPC_EVENT_RE_AUTH_COMPLETED, NULL, 0); 2236 } 2237 } 2238
