Home | History | Annotate | Download | only in Connection_Managment 
      1 /*
      2  * mainSecSm.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 mainSecSm.c
     35  *  \brief 802.1X finite state machine header file
     36  *
     37  *  \see mainSecSm.h
     38  */
     39 
     40 
     41 /***************************************************************************/
     42 /*                                                                         */
     43 /*      MODULE: mainSecSm.c                                                */
     44 /*    PURPOSE:  Main Security State Machine API                            */
     45 /*                                                                         */
     46 /***************************************************************************/
     47 
     48 #define __FILE_ID__  FILE_ID_39
     49 #include "osApi.h"
     50 #include "paramOut.h"
     51 #include "report.h"
     52 #include "DataCtrl_Api.h"
     53 #include "smeApi.h"
     54 #include "rsn.h"
     55 #include "rsnApi.h"
     56 #include "mainSecSm.h"
     57 #include "mainSecNull.h"
     58 #include "mainSecKeysOnly.h"
     59 #include "mainKeysSm.h"
     60 #include "externalSec.h"
     61 
     62 /* Constants */
     63 
     64 /** number of events in the state machine */
     65 #define MAIN_SEC_MAX_NUM_EVENTS     7
     66 
     67 /** number of states in the state machine */
     68 #define MAIN_SEC_MAX_NUM_STATES     6
     69 
     70 /* Enumerations */
     71 
     72 /* Typedefs */
     73 
     74 /* Structures */
     75 
     76 /* External data definitions */
     77 
     78 /* External functions definitions */
     79 
     80 /* Global variables */
     81 
     82 /* Local function prototypes */
     83 
     84 TI_STATUS mainSec_setKey(struct _mainSec_t *pMainSec, TSecurityKeys *pKey);
     85 TI_STATUS mainSec_removeKey(struct _mainSec_t *pMainSec, TSecurityKeys *pKey);
     86 TI_STATUS mainSec_setDefaultKeyId(struct _mainSec_t *pMainSec, TI_UINT8 keyId);
     87 
     88 /* functions */
     89 
     90 /**
     91 *
     92 * mainSec_create
     93 *
     94 * \b Description:
     95 *
     96 * Allocate memory for the main security context, and create all the rest of the needed contexts.
     97 *
     98 * \b ARGS:
     99 *
    100 *  I - hOs - OS handle for OS operations.
    101 *
    102 * \b RETURNS:
    103 *
    104 *  pointer to main security context. If failed, returns NULL.
    105 *
    106 * \sa
    107 */
    108 mainSec_t* mainSec_create(TI_HANDLE hOs)
    109 {
    110     mainSec_t   *pHandle;
    111     TI_STATUS       status;
    112 
    113     /* allocate association context memory */
    114     pHandle = (mainSec_t*)os_memoryAlloc(hOs, sizeof(mainSec_t));
    115     if (pHandle == NULL)
    116     {
    117         return NULL;
    118     }
    119 
    120     os_memoryZero(hOs, pHandle, sizeof(mainSec_t));
    121 
    122     /* allocate memory for association state machine */
    123     status = fsm_Create(hOs, &pHandle->pMainSecSm, MAIN_SEC_MAX_NUM_STATES, MAIN_SEC_MAX_NUM_EVENTS);
    124     if (status != TI_OK)
    125     {
    126         os_memoryFree(hOs, pHandle, sizeof(mainSec_t));
    127         return NULL;
    128     }
    129 
    130     pHandle->pMainKeys = mainKeys_create(hOs);
    131     if (pHandle->pMainKeys == NULL)
    132     {
    133         fsm_Unload(hOs, pHandle->pMainSecSm);
    134         os_memoryFree(hOs, pHandle, sizeof(mainSec_t));
    135         return NULL;
    136     }
    137 
    138     pHandle->pKeyParser = pHandle->pMainKeys->pKeyParser;
    139     pHandle->hOs = hOs;
    140 
    141     /* created only for external security mode */
    142     pHandle->pExternalSec = externalSec_create(hOs);
    143     if (pHandle->pExternalSec == NULL)
    144     {
    145         mainKeys_unload(pHandle->pMainKeys);
    146         fsm_Unload(hOs, pHandle->pMainSecSm);
    147         os_memoryFree(hOs, pHandle, sizeof(mainSec_t));
    148         return NULL;
    149     }
    150 
    151     return pHandle;
    152 }
    153 
    154 /**
    155 *
    156 * mainSec_config
    157 *
    158 * \b Description:
    159 *
    160 * Init main security state machine state machine
    161 *
    162 * \b ARGS:
    163 *
    164 *  none
    165 *
    166 * \b RETURNS:
    167 *
    168 *  TI_OK on success, TI_NOK otherwise.
    169 *
    170 * \sa
    171 */
    172 TI_STATUS mainSec_config (mainSec_t *pMainSec,
    173                           mainSecInitData_t *pInitData,
    174                           void *pParent,
    175                           TI_HANDLE hReport,
    176                           TI_HANDLE hOs,
    177                           TI_HANDLE hCtrlData,
    178                           TI_HANDLE hEvHandler,
    179                           TI_HANDLE hConn,
    180                           TI_HANDLE hTimer)
    181 {
    182     TI_STATUS               status;
    183 
    184     pMainSec->setKey = mainSec_setKey;
    185     pMainSec->removeKey = mainSec_removeKey;
    186     pMainSec->setDefaultKeyId = mainSec_setDefaultKeyId;
    187 
    188     pMainSec->pParent = pParent;
    189     pMainSec->hReport = hReport;
    190     pMainSec->hOs = hOs;
    191 
    192     TRACE4(pMainSec->hReport, REPORT_SEVERITY_SM, "MainSec SM: config, authProtocol = %d, keyExchangeProtocol=%d, unicastSuite=%d, broadcastSuite=%d\n", pInitData->pPaeConfig->authProtocol, pInitData->pPaeConfig->keyExchangeProtocol, pInitData->pPaeConfig->unicastSuite, pInitData->pPaeConfig->broadcastSuite);
    193 
    194     if (TI_TRUE == pMainSec->pParent->bRsnExternalMode)
    195     {
    196             status = externalSec_config(pMainSec);
    197     }
    198     else
    199     {
    200          switch (pInitData->pPaeConfig->keyExchangeProtocol)
    201          {
    202             case RSN_KEY_MNG_NONE:
    203                 status = mainSecSmNull_config(pMainSec, pInitData->pPaeConfig);
    204                 break;
    205             case RSN_KEY_MNG_802_1X:
    206                 status = mainSecKeysOnly_config(pMainSec, pInitData->pPaeConfig);
    207                 break;
    208             default:
    209                 status = mainSecSmNull_config(pMainSec, pInitData->pPaeConfig);
    210                 break;
    211          }
    212     }
    213 
    214     status  = mainKeys_config (pMainSec->pMainKeys,
    215                                pInitData->pPaeConfig,
    216                                pMainSec,
    217                                pMainSec->hReport,
    218                                pMainSec->hOs,
    219                                hCtrlData,
    220                                hEvHandler,
    221                                hConn,
    222                                pMainSec->pParent,
    223                                hTimer);
    224     if (status != TI_OK)
    225     {
    226         TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: error in configuring mainKeys SM\n");
    227         return status;
    228     }
    229 
    230     TRACE0(pMainSec->hReport, REPORT_SEVERITY_SM, "MAIN_SEC_SM: successful configuration SM\n");
    231 
    232     return status;
    233 }
    234 
    235 /**
    236 *
    237 * mainSec_config
    238 *
    239 * \b Description:
    240 *
    241 * Init main security state machine state machine
    242 *
    243 * \b ARGS:
    244 *
    245 *  none
    246 *
    247 * \b RETURNS:
    248 *
    249 *  TI_OK on success, TI_NOK otherwise.
    250 *
    251 * \sa
    252 */
    253 TI_STATUS mainSec_unload(mainSec_t *pMainSec)
    254 {
    255     TI_STATUS   status;
    256 
    257     if (pMainSec == NULL)
    258     {
    259         return TI_NOK;
    260     }
    261 
    262     status = mainKeys_unload(pMainSec->pMainKeys);
    263     if (status != TI_OK)
    264     {
    265         /* report failure but don't stop... */
    266         TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error releasing Main Keys SM memory \n");
    267     }
    268 
    269     status = fsm_Unload(pMainSec->hOs, pMainSec->pMainSecSm);
    270     if (status != TI_OK)
    271     {
    272         /* report failure but don't stop... */
    273         TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error releasing FSM memory \n");
    274     }
    275 
    276     status = externalSec_unload(pMainSec->pExternalSec);
    277     if (status != TI_OK)
    278     {
    279         /* report failure but don't stop... */
    280         TRACE0(pMainSec->hReport, REPORT_SEVERITY_ERROR, "MAIN_SEC_SM: Error releasing ExternalSec memory \n");
    281     }
    282 
    283     os_memoryFree(pMainSec->hOs, pMainSec, sizeof(mainSec_t));
    284 
    285     return TI_OK;
    286 }
    287 
    288 /**
    289 *
    290 * mainSec_setKey
    291 *
    292 * \b Description:
    293 *
    294 * Start the NULL main security SM. Reports success to the rsn module immediately.
    295 *
    296 * \b ARGS:
    297 *
    298 *  none
    299 *
    300 * \b RETURNS:
    301 *
    302 *  TI_OK on success, TI_NOK otherwise.
    303 *
    304 * \sa
    305 */
    306 TI_STATUS mainSec_setKey(struct _mainSec_t *pMainSec, TSecurityKeys *pKey)
    307 {
    308     TI_STATUS               status = TI_OK;
    309 
    310     if ((pMainSec == NULL) || (pKey == NULL))
    311     {
    312         return TI_NOK;
    313     }
    314 
    315     if (pKey->keyType != KEY_NULL)
    316     {
    317         TRACE6(pMainSec->hReport, REPORT_SEVERITY_INFORMATION, "MAIN_SEC_SM: setting key #%d, value = 0x%X 0x%X 0x%X 0x%X 0x%X\n", pKey->keyIndex, (TI_UINT8)pKey->encKey[0], (TI_UINT8)pKey->encKey[1], (TI_UINT8)pKey->encKey[2], (TI_UINT8)pKey->encKey[3], (TI_UINT8)pKey->encKey[4]);
    318 
    319         status = pMainSec->pParent->setKey(pMainSec->pParent, pKey);
    320     }
    321 
    322     return status;
    323 }
    324 
    325 /**
    326 *
    327 * mainSec_removeKey
    328 *
    329 * \b Description:
    330 *
    331 * Start the NULL main security SM. Reports success to the rsn module immediately.
    332 *
    333 * \b ARGS:
    334 *
    335 *  none
    336 *
    337 * \b RETURNS:
    338 *
    339 *  TI_OK on success, TI_NOK otherwise.
    340 *
    341 * \sa
    342 */
    343 TI_STATUS mainSec_removeKey(struct _mainSec_t *pMainSec, TSecurityKeys *pKey)
    344 {
    345     TI_STATUS               status = TI_OK;
    346 
    347     if ((pMainSec == NULL) || (pKey == NULL))
    348     {
    349         return TI_NOK;
    350     }
    351 
    352     if (pKey->keyType != KEY_NULL)
    353     {
    354         TRACE1(pMainSec->hReport, REPORT_SEVERITY_INFORMATION, "MAIN_SEC_SM: removing key #%d, \n", pKey->keyIndex);
    355 
    356         status = pMainSec->pParent->removeKey(pMainSec->pParent, pKey);
    357     }
    358 
    359     return status;
    360 }
    361 
    362 /**
    363 *
    364 * mainSec_setDefaultKeyId
    365 *
    366 * \b Description:
    367 *
    368 * Start the NULL main security SM. Reports success to the rsn module immediately.
    369 *
    370 * \b ARGS:
    371 *
    372 *  none
    373 *
    374 * \b RETURNS:
    375 *
    376 *  TI_OK on success, TI_NOK otherwise.
    377 *
    378 * \sa
    379 */
    380 TI_STATUS mainSec_setDefaultKeyId(struct _mainSec_t *pMainSec, TI_UINT8 keyId)
    381 {
    382     TI_STATUS               status = TI_OK;
    383 
    384     if (pMainSec == NULL)
    385     {
    386         return TI_NOK;
    387     }
    388 
    389     status = pMainSec->pParent->setDefaultKeyId(pMainSec->pParent, keyId);
    390 
    391     return status;
    392 }
    393 
    394 
    395