diff options
Diffstat (limited to 'wilink_6_1/stad/src/Sta_Management/sharedKeyAuthSm.c')
| -rw-r--r-- | wilink_6_1/stad/src/Sta_Management/sharedKeyAuthSm.c | 530 |
1 files changed, 530 insertions, 0 deletions
diff --git a/wilink_6_1/stad/src/Sta_Management/sharedKeyAuthSm.c b/wilink_6_1/stad/src/Sta_Management/sharedKeyAuthSm.c new file mode 100644 index 0000000..6f98628 --- /dev/null +++ b/wilink_6_1/stad/src/Sta_Management/sharedKeyAuthSm.c @@ -0,0 +1,530 @@ +/* + * sharedKeyAuthSm.c + * + * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name Texas Instruments nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** \file sharedKeyAuthSm.c + * \brief shared key 802.11 authentication SM source + * + * \see sharedKeyAuthSm.h + */ + + +/***************************************************************************/ +/* */ +/* MODULE: sharedKeyAuthSm.c */ +/* PURPOSE: shared key 802.11 authentication SM source */ +/* */ +/***************************************************************************/ + +#define __FILE_ID__ FILE_ID_83 +#include "osApi.h" +#include "paramOut.h" +#include "timer.h" +#include "fsm.h" +#include "report.h" +#include "mlmeApi.h" +#include "authSm.h" +#include "sharedKeyAuthSm.h" + +/* Constants */ + +/** number of states in the state machine */ +#define SHARED_KEY_AUTH_SM_NUM_STATES 4 + +/** number of events in the state machine */ +#define SHARED_KEY_AUTH_SM_NUM_EVENTS 8 + +/* Enumerations */ + +/* Typedefs */ + +/* Structures */ + +/* External data definitions */ + +/* External functions definitions */ + +/* Global variables */ + +/* Local function prototypes */ + +/* functions */ + +/** +* +* sharedKeyAuth_smConfig - configure a new authentication SM +* +* \b Description: +* +* Configure a new authentication SM. +* +* \b ARGS: +* +* I - hAuth - Association SM context \n +* I - hMlme - MLME SM context \n +* I - hSiteMgr - Site manager context \n +* I - hCtrlData - Control data context \n +* I - hTxData - TX data context \n +* I - hHalCtrl - Hal control context \n +* I - hReport - Report context \n +* I - hOs - OS context \n +* I - authTimeout - Association SM timeout \n +* I - authMaxCount - Max number of authentication requests to send \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa sharedKeyAuth_Create, sharedKeyAuth_Unload +*/ +TI_STATUS sharedKeyAuth_Config(TI_HANDLE hAuth, TI_HANDLE hOs) +{ + auth_t *pHandle; + TI_STATUS status; + /** Main 802.1X State Machine matrix */ + fsm_actionCell_t sharedKeyAuth_smMatrix[SHARED_KEY_AUTH_SM_NUM_STATES][SHARED_KEY_AUTH_SM_NUM_EVENTS] = + { + /* next state and actions for IDLE state */ + {{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smStartIdle}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smActionUnexpected} + }, + /* next state and actions for WAIT_1 state */ + {{SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopWait}, + {SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smSuccess1Wait1}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smFailure1Wait1}, + {SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_WAIT_1, (fsm_Action_t)sharedKeyAuth_smTimeoutWait1}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smMaxRetryWait} + }, + /* next state and actions for WAIT_2 state */ + {{SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopWait}, + {SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smSuccess2Wait2}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smFailure2Wait2}, + {SHARED_KEY_AUTH_SM_STATE_WAIT_2, (fsm_Action_t)sharedKeyAuth_smTimeoutWait2}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smMaxRetryWait} + }, + /* next state and actions for AUTH state */ + {{SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_IDLE, (fsm_Action_t)sharedKeyAuth_smStopAuth}, + {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected}, + {SHARED_KEY_AUTH_SM_STATE_AUTH, (fsm_Action_t)sharedKeyAuth_smActionUnexpected} + }}; + + + if (hAuth == NULL) + { + return TI_NOK; + } + + pHandle = (auth_t*)hAuth; + + status = fsm_Config(pHandle->pAuthSm, &sharedKeyAuth_smMatrix[0][0], + SHARED_KEY_AUTH_SM_NUM_STATES, SHARED_KEY_AUTH_SM_NUM_EVENTS, auth_skSMEvent, hOs); + if (status != TI_OK) + { + return TI_NOK; + } + + pHandle->currentState = SHARED_KEY_AUTH_SM_STATE_IDLE; + + return TI_OK; +} + + +TI_STATUS auth_skSMEvent(TI_UINT8 *currentState, TI_UINT8 event, TI_HANDLE hAuth) +{ + auth_t *pAuth = (auth_t *)hAuth; + TI_STATUS status; + TI_UINT8 nextState; + + status = fsm_GetNextState(pAuth->pAuthSm, *currentState, event, &nextState); + if (status != TI_OK) + { + TRACE0(pAuth->hReport, REPORT_SEVERITY_SM, "State machine error, failed getting next state\n"); + return(TI_NOK); + } + + TRACE3(pAuth->hReport, REPORT_SEVERITY_INFORMATION, "auth_skSMEvent: <currentState = %d, event = %d> --> nextState = %d\n", *currentState, event, nextState); + + status = fsm_Event(pAuth->pAuthSm, currentState, event, (void *)pAuth); + + return status; +} + + +/** +* +* sharedKeyAuth_Recv - Recive a message from the AP +* +* \b Description: +* +* Parse a message form the AP and perform the appropriate event. +* +* \b ARGS: +* +* I - hAuth - Association SM context \n +* +* \b RETURNS: +* +* TI_OK if successful, TI_NOK otherwise. +* +* \sa sharedKeyAuth_Start, sharedKeyAuth_Stop +*/ +TI_STATUS sharedKeyAuth_Recv(TI_HANDLE hAuth, mlmeFrameInfo_t *pFrame) +{ + TI_STATUS status = TI_NOK; + auth_t *pHandle; + TI_UINT16 authAlgo; + TI_UINT16 rspSeq; + + pHandle = (auth_t*)hAuth; + + if (pHandle == NULL) + { + return TI_NOK; + } + + /* check response status */ + authAlgo = ENDIAN_HANDLE_WORD(pFrame->content.auth.authAlgo); + if (authAlgo != AUTH_LEGACY_SHARED_KEY) + { +TRACE0(pHandle->hReport, REPORT_SEVERITY_SM, "SHARED_KEY_AUTH_SM: DEBUG recieved authentication message with wrong algorithm \n"); + return TI_NOK; + } + + /* check response status */ + rspSeq = pFrame->content.auth.seqNum; + + pHandle->authData.status = pFrame->content.auth.status; + pHandle->authData.pChalange = (char *)(pFrame->content.auth.pChallenge->text); + pHandle->authData.challangeLen = pFrame->content.auth.pChallenge->hdr[1]; + + if (pHandle->authData.status == STATUS_SUCCESSFUL) + { + switch (rspSeq) + { + case 2: +TRACE0(pHandle->hReport, REPORT_SEVERITY_SM, "SHARED_KEY_AUTH_SM: DEBUG Success authenticating to AP stage 1\n"); + + if (pFrame->content.auth.pChallenge->hdr[0] != CHALLANGE_TEXT_IE_ID) + { +TRACE0(pHandle->hReport, REPORT_SEVERITY_ERROR, "SHARED_KEY_AUTH_SM: Wrong element ID for challange \n"); + status = TI_NOK; + break; + } + + status = auth_skSMEvent(&pHandle->currentState, SHARED_KEY_AUTH_SM_EVENT_SUCCESS_1, hAuth); + break; + + case 4: +TRACE0(pHandle->hReport, REPORT_SEVERITY_SM, "SHARED_KEY_AUTH_SM: DEBUG Success authenticating to AP stage 2\n"); + + status = auth_skSMEvent(&pHandle->currentState, SHARED_KEY_AUTH_SM_EVENT_SUCCESS_2, hAuth); + break; + + default: +TRACE0(pHandle->hReport, REPORT_SEVERITY_ERROR, "SHARED_KEY_AUTH_SM: Wrong sequence number \n"); + status = TI_NOK; + break; + } + } + + else + { + switch (rspSeq) + { + case 2: + status = auth_skSMEvent(&pHandle->currentState, SHARED_KEY_AUTH_SM_EVENT_FAIL_1, hAuth); + break; + + case 4: + status = auth_skSMEvent(&pHandle->currentState, SHARED_KEY_AUTH_SM_EVENT_FAIL_2, hAuth); + break; + + default: + status = TI_NOK; + break; + } + } + + return status; +} + +/* state machine functions */ + +TI_STATUS sharedKeyAuth_smStartIdle(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smResetRetry(hAuth); + status = sharedKeyAuth_smSendAuth1(hAuth); + status = sharedKeyAuth_smStartTimer(hAuth); + status = sharedKeyAuth_smIncRetry(hAuth); + + return status; +} + +TI_STATUS sharedKeyAuth_smStopWait(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smStopTimer(hAuth); + + return status; +} + +TI_STATUS sharedKeyAuth_smSuccess1Wait1(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smResetRetry(hAuth); + if (status != TI_OK) + return status; + status = sharedKeyAuth_smStopTimer(hAuth); + if (status != TI_OK) + return status; + status = sharedKeyAuth_smSendAuth2(hAuth); + if (status != TI_OK) + return status; + status = sharedKeyAuth_smStartTimer(hAuth); + if (status != TI_OK) + return status; + status = sharedKeyAuth_smIncRetry(hAuth); + + return status; +} + +TI_STATUS sharedKeyAuth_smFailure1Wait1(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smStopTimer(hAuth); + status = sharedKeyAuth_smReportFailure(hAuth); + + return status; +} + +TI_STATUS sharedKeyAuth_smTimeoutWait1(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smSendAuth1(hAuth); + status = sharedKeyAuth_smStartTimer(hAuth); + status = sharedKeyAuth_smIncRetry(hAuth); + + return status; +} + +TI_STATUS sharedKeyAuth_smMaxRetryWait(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smReportFailure(hAuth); + + return status; +} + +TI_STATUS sharedKeyAuth_smSuccess2Wait2(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smStopTimer(hAuth); + status = sharedKeyAuth_smReportSuccess(hAuth); + + return status; +} + +TI_STATUS sharedKeyAuth_smFailure2Wait2(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smStopTimer(hAuth); + status = sharedKeyAuth_smReportFailure(hAuth); + + return status; +} + +TI_STATUS sharedKeyAuth_smTimeoutWait2(auth_t *hAuth) +{ + TI_STATUS status; + + status = sharedKeyAuth_smSendAuth2(hAuth); + status = sharedKeyAuth_smStartTimer(hAuth); + status = sharedKeyAuth_smIncRetry(hAuth); + + return status; +} + +/* action routines for authentication SM */ + +TI_STATUS sharedKeyAuth_smSendAuth1(auth_t *hAuth) +{ + TI_STATUS status; + + status = auth_smMsgBuild(hAuth, 1, 0, NULL, 0); + + return status; +} + +TI_STATUS sharedKeyAuth_smSendAuth2(auth_t *hAuth) +{ + TI_STATUS status; + + /* GET SECRET */ + + /* ENCRYPT CHALLANGE WITH SECRET */ + + status = auth_smMsgBuild(hAuth, 3, 0, (TI_UINT8 *)(hAuth->authData.pChalange), hAuth->authData.challangeLen); + + return status; +} + +TI_STATUS sharedKeyAuth_smStopAuth(auth_t *hAuth) +{ + return TI_OK; +} + +TI_STATUS sharedKeyAuth_smActionUnexpected(auth_t *hAuth) +{ + return TI_OK; +} + +/* local functions */ + + +TI_STATUS sharedKeyAuth_smResetRetry(auth_t *hAuth) +{ + if (hAuth == NULL) + { + return TI_NOK; + } + + hAuth->retryCount = 0; + + return TI_OK; +} + +TI_STATUS sharedKeyAuth_smIncRetry(auth_t *hAuth) +{ + if (hAuth == NULL) + { + return TI_NOK; + } + + hAuth->retryCount++; + + return TI_OK; +} + +TI_STATUS sharedKeyAuth_smReportSuccess(auth_t *hAuth) +{ + TI_STATUS status; + + if (hAuth == NULL) + { + return TI_NOK; + } + + status = mlme_reportAuthStatus(hAuth->hMlme, hAuth->authData.status); + + return status; +} + +TI_STATUS sharedKeyAuth_smReportFailure(auth_t *hAuth) +{ + TI_STATUS status; + + if (hAuth == NULL) + { + return TI_NOK; + } + + status = mlme_reportAuthStatus(hAuth->hMlme, hAuth->authData.status); + + return status; +} + +TI_STATUS sharedKeyAuth_smStartTimer(auth_t *hAuth) +{ + if (hAuth == NULL) + { + return TI_NOK; + } + + tmr_StartTimer (hAuth->hAuthSmTimer, + auth_smTimeout, + (TI_HANDLE)hAuth, + hAuth->timeout, + TI_FALSE); + + return TI_OK; +} + +TI_STATUS sharedKeyAuth_smStopTimer(auth_t *hAuth) +{ + if (hAuth == NULL) + { + return TI_NOK; + } + + tmr_StopTimer (hAuth->hAuthSmTimer); + + return TI_OK; +} + +TI_STATUS sharedKey_Timeout(auth_t *pAuth) +{ + if (pAuth->retryCount >= pAuth->maxCount) + { + pAuth->authData.status = STATUS_PACKET_REJ_TIMEOUT; + return auth_skSMEvent(&pAuth->currentState, SHARED_KEY_AUTH_SM_EVENT_MAX_RETRY, pAuth); + } + + return auth_skSMEvent(&pAuth->currentState, SHARED_KEY_AUTH_SM_EVENT_TIMEOUT, pAuth); +} + + |