/* * mainSecKeysOnly.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 mainSecSm.c * \brief 802.1X finite state machine header file * * \see mainSecSm.h */ /***************************************************************************/ /* */ /* MODULE: mainSecSm.c */ /* PURPOSE: Main Security State Machine API */ /* */ /***************************************************************************/ #define __FILE_ID__ FILE_ID_37 #include "osApi.h" #include "paramOut.h" #include "fsm.h" #include "report.h" #include "DataCtrl_Api.h" #include "smeApi.h" #include "rsn.h" #include "rsnApi.h" #include "mainSecSm.h" #include "mainSecKeysOnly.h" #include "mainKeysSm.h" /* Constants */ /* Enumerations */ /* Typedefs */ /* Structures */ /* External data definitions */ /* External functions definitions */ /* Global variables */ /* functions */ TI_STATUS mainSecKeysOnly_getAuthState(mainSec_t *pMainSec, TIWLN_SECURITY_STATE *supp1XState); TI_STATUS mainSecKeysOnly_reportAuthFailure(mainSec_t *pMainSec, EAuthStatus authStatus) ; TI_STATUS mainSecKeysOnly_setAuthIdentity(mainSec_t *pMainSec, authIdentity_t *authIdentity); /** * * rsn_mainSecSmKeysOnlyInit * * \b Description: * * Init main security state machine state machine * * \b ARGS: * * none * * \b RETURNS: * * TI_OK on success, TI_NOK otherwise. * * \sa */ TI_STATUS mainSecKeysOnly_config(mainSec_t *pMainSec, TRsnPaeConfig *pPaeConfig) { TI_STATUS status; /** Main 802.1X State Machine matrix */ fsm_actionCell_t mainSecKeysOnly_matrix[MAIN_SEC_KEYS_ONLY_NUM_STATES][MAIN_SEC_KEYS_ONLY_NUM_EVENTS] = { /* next state and actions for IDLE state */ {{MAIN_KO_STATE_START, (fsm_Action_t)mainSecKeysOnly_startIdle}, {MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_Nop}, {MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_unexpected}, {MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_unexpected} }, /* next state and actions for START state */ {{MAIN_KO_STATE_START, (fsm_Action_t)mainSecKeysOnly_Nop}, {MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_stopStart}, {MAIN_KO_STATE_AUTHORIZED, (fsm_Action_t)mainSecKeysOnly_keysCompleteStart}, {MAIN_KO_STATE_NONAUTHORIZED, (fsm_Action_t)mainSecKeysOnly_keysTOStart}, }, /* next state and actions for AUTHORIZED state */ {{MAIN_KO_STATE_AUTHORIZED, (fsm_Action_t)mainSecKeysOnly_unexpected}, {MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_stopAuthorized}, {MAIN_KO_STATE_AUTHORIZED, (fsm_Action_t)mainSecKeysOnly_Nop}, {MAIN_KO_STATE_AUTHORIZED, (fsm_Action_t)mainSecKeysOnly_unexpected}, }, /* next state and actions for NONAUTORIZED state */ {{MAIN_KO_STATE_START, (fsm_Action_t)mainSecKeysOnly_unexpected}, {MAIN_KO_STATE_IDLE, (fsm_Action_t)mainSecKeysOnly_stopNonAuthorized}, {MAIN_KO_STATE_NONAUTHORIZED, (fsm_Action_t)mainSecKeysOnly_unexpected}, {MAIN_KO_STATE_NONAUTHORIZED, (fsm_Action_t)mainSecKeysOnly_unexpected}, } }; status = fsm_Config(pMainSec->pMainSecSm, &mainSecKeysOnly_matrix[0][0], MAIN_SEC_KEYS_ONLY_NUM_STATES, MAIN_SEC_KEYS_ONLY_NUM_EVENTS, NULL, pMainSec->hOs); if (status != TI_OK) { TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error in configuring full SM\n"); return status; } pMainSec->currentState = MAIN_KO_STATE_IDLE; pMainSec->start = mainSecKeysOnly_start; pMainSec->stop = mainSecKeysOnly_stop; pMainSec->reportKeysStatus = mainSecKeysOnly_reportKeysStatus; pMainSec->getAuthState = (mainSecSm_getAuthState_t)mainSecKeysOnly_getAuthState; pMainSec->reportReAuthenticate = (mainSecSmReportReauthentication_t)mainSecKeysOnly_unexpected; pMainSec->setSessionKey = (mainSecSmSetSessionKey_t)mainSecKeysOnly_unexpected; pMainSec->getSessionKey = (mainSecSmGetSessionKey_t)mainSecKeysOnly_unexpected; pMainSec->reportAuthStatus = (mainSecSmReportAuthStatus_t)mainSecKeysOnly_unexpected; pMainSec->getAuthIdentity = (mainSecSm_getAuthIdentity_t)mainSecKeysOnly_unexpected; pMainSec->setAuthIdentity = (mainSecSm_getAuthIdentity_t)mainSecKeysOnly_setAuthIdentity; pMainSec->reportAuthFailure = (mainSecSm_reportAuthFailure_t)mainSecKeysOnly_reportAuthFailure; TRACE0(pMainSec->hReport, REPORT_SEVERITY_INFORMATION, "mainSecKeysOnly_config\n"); return TI_OK; } /** * * mainSecSmNull_Start * * \b Description: * * Start the NULL main security SM. Reports success to the rsn module immediately. * * \b ARGS: * * none * * \b RETURNS: * * TI_OK on success, TI_NOK otherwise. * * \sa */ TI_STATUS mainSecKeysOnly_start(mainSec_t *pMainSec) { TI_STATUS status; status = fsm_Event(pMainSec->pMainSecSm, &pMainSec->currentState, MAIN_KO_EVENT_START, pMainSec); return status; } /** * * mainSecSmNull_Stop * * \b Description: * * Start the NULL main security SM. Reports success to the rsn module immediately. * * \b ARGS: * * none * * \b RETURNS: * * TI_OK on success, TI_NOK otherwise. * * \sa */ TI_STATUS mainSecKeysOnly_stop(mainSec_t *pMainSec) { TI_STATUS status; status = fsm_Event(pMainSec->pMainSecSm, &pMainSec->currentState, MAIN_KO_EVENT_STOP, pMainSec); return status; } /** * * mainSecSmNull_Stop * * \b Description: * * Start the NULL main security SM. Reports success to the rsn module immediately. * * \b ARGS: * * none * * \b RETURNS: * * TI_OK on success, TI_NOK otherwise. * * \sa */ TI_STATUS mainSecKeysOnly_reportKeysStatus(mainSec_t *pMainSec, TI_STATUS keysStatus) { TI_STATUS status; pMainSec->data.status = keysStatus; if (keysStatus == TI_OK) { status = fsm_Event(pMainSec->pMainSecSm, &pMainSec->currentState, MAIN_KO_EVENT_KEYS_COMPLETE, pMainSec); } else { TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error in Keys\n"); status = TI_OK; } return status; } /** * * mainSecSmNull_setKey * * \b Description: * * Start the NULL main security SM. Reports success to the rsn module immediately. * * \b ARGS: * * none * * \b RETURNS: * * TI_OK on success, TI_NOK otherwise. * * \sa */ TI_STATUS mainSecKeysOnly_setSessionKey(mainSec_t *pMainSec, TI_UINT8* pKey, TI_UINT8 keyLen) { os_memoryCopy(pMainSec->hOs, pMainSec->sessionKey, pKey, keyLen); pMainSec->sessionKeyLen = keyLen; return TI_OK; } /** * * mainSecSmNull_setKey * * \b Description: * * Start the NULL main security SM. Reports success to the rsn module immediately. * * \b ARGS: * * none * * \b RETURNS: * * TI_OK on success, TI_NOK otherwise. * * \sa */ TI_STATUS mainSecKeysOnly_getSessionKey(mainSec_t *pMainSec, TI_UINT8* pKey, TI_UINT32* pKeyLen) { os_memoryCopy(pMainSec->hOs, pKey, pMainSec->sessionKey, pMainSec->sessionKeyLen); *pKeyLen = pMainSec->sessionKeyLen; return TI_OK; } /* State machine implementation functions */ TI_STATUS mainSecKeysOnly_startIdle(struct _mainSec_t *pMainSec) { TI_STATUS status = TI_OK; TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_StartIdle...\n"); status = pMainSec->pMainKeys->start(pMainSec->pMainKeys); return status; } TI_STATUS mainSecKeysOnly_stopStart(struct _mainSec_t *pMainSec) { TI_STATUS status = TI_OK; TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_StopStart...\n"); status = pMainSec->pMainKeys->stop(pMainSec->pMainKeys); return status; } TI_STATUS mainSecKeysOnly_keysCompleteStart(struct _mainSec_t *pMainSec) { TI_STATUS status = TI_OK; TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_KeysCompleteAuthenticated...\n"); status = pMainSec->pParent->reportStatus(pMainSec->pParent, pMainSec->data.status); return(status); } TI_STATUS mainSecKeysOnly_keysTOStart(struct _mainSec_t *pMainSec) { TI_STATUS status = TI_OK; return(status); } TI_STATUS mainSecKeysOnly_stopAuthorized(struct _mainSec_t *pMainSec) { TI_STATUS status = TI_OK; TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_StopAuthorized...\n"); status = pMainSec->pMainKeys->stop(pMainSec->pMainKeys); return(status); } TI_STATUS mainSecKeysOnly_stopNonAuthorized(struct _mainSec_t *pMainSec) { TI_STATUS status = TI_OK; TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: mainSecKeysOnly_StopNonAuthorized...\n"); status = pMainSec->pMainKeys->stop(pMainSec->pMainKeys); return(status); } /* state machine action functions */ TI_STATUS mainSecKeysOnly_Nop(void* pData) { return(TI_OK); } TI_STATUS mainSecKeysOnly_unexpected(void* pData) { return TI_NOK; } /** * * mainSecKeysOnly_getAuthState: \n * * \b Description: * * Get authentication state from supp1x SM. * * \b ARGS: * * I - pMainSec - pMainSec SM context \n * I - authIdentity - pointer to authentication state \n * * \b RETURNS: * * TI_OK if successful, TI_NOK otherwise. * * \sa */ TI_STATUS mainSecKeysOnly_getAuthState(mainSec_t *pMainSec, TIWLN_SECURITY_STATE *secState) { switch (pMainSec->currentState) { case MAIN_KO_STATE_START: *secState = eSecurityStateAuthenticating; break; case MAIN_KO_STATE_AUTHORIZED: *secState = eSecurityStateAuthenticated; break; case MAIN_KO_STATE_NONAUTHORIZED: *secState = eSecurityStateNotAuthenticated ; break; default: *secState = eSecurityStateHalted; break; } return TI_OK; } /*mainSecKeysOnly_getAuthState*/ TI_STATUS mainSecKeysOnly_reportAuthFailure(mainSec_t *pMainSec, EAuthStatus authStatus) { return TI_OK; } TI_STATUS mainSecKeysOnly_setAuthIdentity(mainSec_t *pMainSec, authIdentity_t *authIdentity) { return TI_OK; }