1 /* 2 * sharedKeyAuthSm.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 /** \file sharedKeyAuthSm.c 35 * \brief shared key 802.11 authentication SM source 36 * 37 * \see sharedKeyAuthSm.h 38 */ 39 40 41 /***************************************************************************/ 42 /* */ 43 /* MODULE: sharedKeyAuthSm.c */ 44 /* PURPOSE: shared key 802.11 authentication SM source */ 45 /* */ 46 /***************************************************************************/ 47 48 #define __FILE_ID__ FILE_ID_83 49 #include "osApi.h" 50 #include "paramOut.h" 51 #include "timer.h" 52 #include "fsm.h" 53 #include "report.h" 54 #include "mlmeApi.h" 55 #include "authSm.h" 56 #include "sharedKeyAuthSm.h" 57 58 /* Constants */ 59 60 /** number of states in the state machine */ 61 #define SHARED_KEY_AUTH_SM_NUM_STATES 4 62 63 /** number of events in the state machine */ 64 #define SHARED_KEY_AUTH_SM_NUM_EVENTS 8 65 66 /* Enumerations */ 67 68 /* Typedefs */ 69 70 /* Structures */ 71 72 /* External data definitions */ 73 74 /* External functions definitions */ 75 76 /* Global variables */ 77 78 /* Local function prototypes */ 79 80 /* functions */ 81 82 /** 83 * 84 * sharedKeyAuth_smConfig - configure a new authentication SM 85 * 86 * \b Description: 87 * 88 * Configure a new authentication SM. 89 * 90 * \b ARGS: 91 * 92 * I - hAuth - Association SM context \n 93 * I - hMlme - MLME SM context \n 94 * I - hSiteMgr - Site manager context \n 95 * I - hCtrlData - Control data context \n 96 * I - hTxData - TX data context \n 97 * I - hHalCtrl - Hal control context \n 98 * I - hReport - Report context \n 99 * I - hOs - OS context \n 100 * I - authTimeout - Association SM timeout \n 101 * I - authMaxCount - Max number of authentication requests to send \n 102 * 103 * \b RETURNS: 104 * 105 * TI_OK if successful, TI_NOK otherwise. 106 * 107 * \sa sharedKeyAuth_Create, sharedKeyAuth_Unload 108 */ 109 TI_STATUS sharedKeyAuth_Config(TI_HANDLE hAuth, TI_HANDLE hOs) 110 { 111 auth_t *pHandle; 112 TI_STATUS status; 113 /** Main 802.1X State Machine matrix */ 114 fsm_actionCell_t sharedKeyAuth_smMatrix[SHARED_KEY_AUTH_SM_NUM_STATES][SHARED_KEY_AUTH_SM_NUM_EVENTS] = 115 { 116 /* next state and actions for IDLE state */ 117 {{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smStartIdle}, 118 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 119 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 120 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 121 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 122 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 123 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 124 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected} 125 }, 126 /* next state and actions for WAIT_1 state */ 127 {{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 128 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopWait}, 129 {SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smSuccess1Wait1}, 130 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smFailure1Wait1}, 131 {SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 132 {SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 133 {SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smTimeoutWait1}, 134 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smMaxRetryWait} 135 }, 136 /* next state and actions for WAIT_2 state */ 137 {{SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 138 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopWait}, 139 {SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 140 {SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 141 {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smSuccess2Wait2}, 142 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smFailure2Wait2}, 143 {SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smTimeoutWait2}, 144 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smMaxRetryWait} 145 }, 146 /* next state and actions for AUTH state */ 147 {{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 148 {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopAuth}, 149 {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 150 {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 151 {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 152 {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 153 {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, 154 {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected} 155 }}; 156 157 158 if (hAuth == NULL) 159 { 160 return TI_NOK; 161 } 162 163 pHandle = (auth_t*)hAuth; 164 165 status = fsm_Config(pHandle->pAuthSm, &sharedKeyAuth_smMatrix[0][0], 166 SHARED_KEY_AUTH_SM_NUM_STATES, SHARED_KEY_AUTH_SM_NUM_EVENTS, auth_skSMEvent, hOs); 167 if (status != TI_OK) 168 { 169 return TI_NOK; 170 } 171 172 pHandle->currentState = SHARED_KEY_AUTH_SM_STATE_IDLE; 173 174 return TI_OK; 175 } 176 177 178 TI_STATUS auth_skSMEvent(TI_UINT8 *currentState, TI_UINT8 event, TI_HANDLE hAuth) 179 { 180 auth_t *pAuth = (auth_t *)hAuth; 181 TI_STATUS status; 182 TI_UINT8 nextState; 183 184 status = fsm_GetNextState(pAuth->pAuthSm, *currentState, event, &nextState); 185 if (status != TI_OK) 186 { 187 TRACE0(pAuth->hReport, REPORT_SEVERITY_SM, "State machine error, failed getting next state\n"); 188 return(TI_NOK); 189 } 190 191 TRACE3(pAuth->hReport, REPORT_SEVERITY_INFORMATION, "auth_skSMEvent: <currentState = %d, event = %d> --> nextState = %d\n", *currentState, event, nextState); 192 193 status = fsm_Event(pAuth->pAuthSm, currentState, event, (void *)pAuth); 194 195 return status; 196 } 197 198 199 /** 200 * 201 * sharedKeyAuth_Recv - Recive a message from the AP 202 * 203 * \b Description: 204 * 205 * Parse a message form the AP and perform the appropriate event. 206 * 207 * \b ARGS: 208 * 209 * I - hAuth - Association SM context \n 210 * 211 * \b RETURNS: 212 * 213 * TI_OK if successful, TI_NOK otherwise. 214 * 215 * \sa sharedKeyAuth_Start, sharedKeyAuth_Stop 216 */ 217 TI_STATUS sharedKeyAuth_Recv(TI_HANDLE hAuth, mlmeFrameInfo_t *pFrame) 218 { 219 TI_STATUS status = TI_NOK; 220 auth_t *pHandle; 221 TI_UINT16 authAlgo; 222 TI_UINT16 rspSeq; 223 224 pHandle = (auth_t*)hAuth; 225 226 if (pHandle == NULL) 227 { 228 return TI_NOK; 229 } 230 231 /* check response status */ 232 authAlgo = ENDIAN_HANDLE_WORD(pFrame->content.auth.authAlgo); 233 if (authAlgo != AUTH_LEGACY_SHARED_KEY) 234 { 235 TRACE0(pHandle->hReport, REPORT_SEVERITY_SM, "SHARED_KEY_AUTH_SM: DEBUG recieved authentication message with wrong algorithm \n"); 236 return TI_NOK; 237 } 238 239 /* check response status */ 240 rspSeq = pFrame->content.auth.seqNum; 241 242 pHandle->authData.status = pFrame->content.auth.status; 243 pHandle->authData.pChalange = (char *)(pFrame->content.auth.pChallenge->text); 244 pHandle->authData.challangeLen = pFrame->content.auth.pChallenge->hdr[1]; 245 246 if (pHandle->authData.status == STATUS_SUCCESSFUL) 247 { 248 switch (rspSeq) 249 { 250 case 2: 251 TRACE0(pHandle->hReport, REPORT_SEVERITY_SM, "SHARED_KEY_AUTH_SM: DEBUG Success authenticating to AP stage 1\n"); 252 253 if (pFrame->content.auth.pChallenge->hdr[0] != CHALLANGE_TEXT_IE_ID) 254 { 255 TRACE0(pHandle->hReport, REPORT_SEVERITY_ERROR, "SHARED_KEY_AUTH_SM: Wrong element ID for challange \n"); 256 status = TI_NOK; 257 break; 258 } 259 260 status = auth_skSMEvent(&pHandle->currentState, SHARED_KEY_AUTH_SM_EVENT_SUCCESS_1, hAuth); 261 break; 262 263 case 4: 264 TRACE0(pHandle->hReport, REPORT_SEVERITY_SM, "SHARED_KEY_AUTH_SM: DEBUG Success authenticating to AP stage 2\n"); 265 266 status = auth_skSMEvent(&pHandle->currentState, SHARED_KEY_AUTH_SM_EVENT_SUCCESS_2, hAuth); 267 break; 268 269 default: 270 TRACE0(pHandle->hReport, REPORT_SEVERITY_ERROR, "SHARED_KEY_AUTH_SM: Wrong sequence number \n"); 271 status = TI_NOK; 272 break; 273 } 274 } 275 276 else 277 { 278 switch (rspSeq) 279 { 280 case 2: 281 status = auth_skSMEvent(&pHandle->currentState, SHARED_KEY_AUTH_SM_EVENT_FAIL_1, hAuth); 282 break; 283 284 case 4: 285 status = auth_skSMEvent(&pHandle->currentState, SHARED_KEY_AUTH_SM_EVENT_FAIL_2, hAuth); 286 break; 287 288 default: 289 status = TI_NOK; 290 break; 291 } 292 } 293 294 return status; 295 } 296 297 /* state machine functions */ 298 299 TI_STATUS sharedKeyAuth_smStartIdle(auth_t *hAuth) 300 { 301 TI_STATUS status; 302 303 status = sharedKeyAuth_smResetRetry(hAuth); 304 status = sharedKeyAuth_smSendAuth1(hAuth); 305 status = sharedKeyAuth_smStartTimer(hAuth); 306 status = sharedKeyAuth_smIncRetry(hAuth); 307 308 return status; 309 } 310 311 TI_STATUS sharedKeyAuth_smStopWait(auth_t *hAuth) 312 { 313 TI_STATUS status; 314 315 status = sharedKeyAuth_smStopTimer(hAuth); 316 317 return status; 318 } 319 320 TI_STATUS sharedKeyAuth_smSuccess1Wait1(auth_t *hAuth) 321 { 322 TI_STATUS status; 323 324 status = sharedKeyAuth_smResetRetry(hAuth); 325 if (status != TI_OK) 326 return status; 327 status = sharedKeyAuth_smStopTimer(hAuth); 328 if (status != TI_OK) 329 return status; 330 status = sharedKeyAuth_smSendAuth2(hAuth); 331 if (status != TI_OK) 332 return status; 333 status = sharedKeyAuth_smStartTimer(hAuth); 334 if (status != TI_OK) 335 return status; 336 status = sharedKeyAuth_smIncRetry(hAuth); 337 338 return status; 339 } 340 341 TI_STATUS sharedKeyAuth_smFailure1Wait1(auth_t *hAuth) 342 { 343 TI_STATUS status; 344 345 status = sharedKeyAuth_smStopTimer(hAuth); 346 status = sharedKeyAuth_smReportFailure(hAuth); 347 348 return status; 349 } 350 351 TI_STATUS sharedKeyAuth_smTimeoutWait1(auth_t *hAuth) 352 { 353 TI_STATUS status; 354 355 status = sharedKeyAuth_smSendAuth1(hAuth); 356 status = sharedKeyAuth_smStartTimer(hAuth); 357 status = sharedKeyAuth_smIncRetry(hAuth); 358 359 return status; 360 } 361 362 TI_STATUS sharedKeyAuth_smMaxRetryWait(auth_t *hAuth) 363 { 364 TI_STATUS status; 365 366 status = sharedKeyAuth_smReportFailure(hAuth); 367 368 return status; 369 } 370 371 TI_STATUS sharedKeyAuth_smSuccess2Wait2(auth_t *hAuth) 372 { 373 TI_STATUS status; 374 375 status = sharedKeyAuth_smStopTimer(hAuth); 376 status = sharedKeyAuth_smReportSuccess(hAuth); 377 378 return status; 379 } 380 381 TI_STATUS sharedKeyAuth_smFailure2Wait2(auth_t *hAuth) 382 { 383 TI_STATUS status; 384 385 status = sharedKeyAuth_smStopTimer(hAuth); 386 status = sharedKeyAuth_smReportFailure(hAuth); 387 388 return status; 389 } 390 391 TI_STATUS sharedKeyAuth_smTimeoutWait2(auth_t *hAuth) 392 { 393 TI_STATUS status; 394 395 status = sharedKeyAuth_smSendAuth2(hAuth); 396 status = sharedKeyAuth_smStartTimer(hAuth); 397 status = sharedKeyAuth_smIncRetry(hAuth); 398 399 return status; 400 } 401 402 /* action routines for authentication SM */ 403 404 TI_STATUS sharedKeyAuth_smSendAuth1(auth_t *hAuth) 405 { 406 TI_STATUS status; 407 408 status = auth_smMsgBuild(hAuth, 1, 0, NULL, 0); 409 410 return status; 411 } 412 413 TI_STATUS sharedKeyAuth_smSendAuth2(auth_t *hAuth) 414 { 415 TI_STATUS status; 416 417 /* GET SECRET */ 418 419 /* ENCRYPT CHALLANGE WITH SECRET */ 420 421 status = auth_smMsgBuild(hAuth, 3, 0, (TI_UINT8 *)(hAuth->authData.pChalange), hAuth->authData.challangeLen); 422 423 return status; 424 } 425 426 TI_STATUS sharedKeyAuth_smStopAuth(auth_t *hAuth) 427 { 428 return TI_OK; 429 } 430 431 TI_STATUS sharedKeyAuth_smActionUnexpected(auth_t *hAuth) 432 { 433 return TI_OK; 434 } 435 436 /* local functions */ 437 438 439 TI_STATUS sharedKeyAuth_smResetRetry(auth_t *hAuth) 440 { 441 if (hAuth == NULL) 442 { 443 return TI_NOK; 444 } 445 446 hAuth->retryCount = 0; 447 448 return TI_OK; 449 } 450 451 TI_STATUS sharedKeyAuth_smIncRetry(auth_t *hAuth) 452 { 453 if (hAuth == NULL) 454 { 455 return TI_NOK; 456 } 457 458 hAuth->retryCount++; 459 460 return TI_OK; 461 } 462 463 TI_STATUS sharedKeyAuth_smReportSuccess(auth_t *hAuth) 464 { 465 TI_STATUS status; 466 467 if (hAuth == NULL) 468 { 469 return TI_NOK; 470 } 471 472 status = mlme_reportAuthStatus(hAuth->hMlme, hAuth->authData.status); 473 474 return status; 475 } 476 477 TI_STATUS sharedKeyAuth_smReportFailure(auth_t *hAuth) 478 { 479 TI_STATUS status; 480 481 if (hAuth == NULL) 482 { 483 return TI_NOK; 484 } 485 486 status = mlme_reportAuthStatus(hAuth->hMlme, hAuth->authData.status); 487 488 return status; 489 } 490 491 TI_STATUS sharedKeyAuth_smStartTimer(auth_t *hAuth) 492 { 493 if (hAuth == NULL) 494 { 495 return TI_NOK; 496 } 497 498 tmr_StartTimer (hAuth->hAuthSmTimer, 499 auth_smTimeout, 500 (TI_HANDLE)hAuth, 501 hAuth->timeout, 502 TI_FALSE); 503 504 return TI_OK; 505 } 506 507 TI_STATUS sharedKeyAuth_smStopTimer(auth_t *hAuth) 508 { 509 if (hAuth == NULL) 510 { 511 return TI_NOK; 512 } 513 514 tmr_StopTimer (hAuth->hAuthSmTimer); 515 516 return TI_OK; 517 } 518 519 TI_STATUS sharedKey_Timeout(auth_t *pAuth) 520 { 521 if (pAuth->retryCount >= pAuth->maxCount) 522 { 523 pAuth->authData.status = STATUS_PACKET_REJ_TIMEOUT; 524 return auth_skSMEvent(&pAuth->currentState, SHARED_KEY_AUTH_SM_EVENT_MAX_RETRY, pAuth); 525 } 526 527 return auth_skSMEvent(&pAuth->currentState, SHARED_KEY_AUTH_SM_EVENT_TIMEOUT, pAuth); 528 } 529 530 531
