1 /* 2 * broadcastKey802_1x.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 broadcastKey802_1x.c 35 * \brief broadcast key 802.1x implementation 36 * 37 * \see broadcastKey802_1x.h 38 */ 39 40 /**************************************************************************** 41 * * 42 * MODULE: 802.1x station broadcast key SM * 43 * PURPOSE: 802.1x station broadcast key SM implementation * 44 * * 45 ****************************************************************************/ 46 47 #define __FILE_ID__ FILE_ID_22 48 #include "osApi.h" 49 #include "report.h" 50 #include "rsnApi.h" 51 52 #include "keyDerive.h" 53 54 #include "broadcastKey802_1x.h" 55 #include "mainKeysSm.h" 56 57 58 TI_STATUS broadcastKey802_1x_start(struct _broadcastKey_t *pBroadcastKey); 59 60 TI_STATUS broadcastKey802_1x_stop(struct _broadcastKey_t *pBroadcastKey); 61 62 TI_STATUS broadcastKey802_1x_recvSuccess(struct _broadcastKey_t *pBroadcastKey, 63 encodedKeyMaterial_t *pEncodedKeyMaterial); 64 65 TI_STATUS broadcastKey802_1x_recvFailure(struct _broadcastKey_t *pBroadcastKey); 66 67 TI_STATUS broadcastKey802_1x_distribute(struct _broadcastKey_t *pBroadcastKey); 68 69 TI_STATUS broadcastKey802_1x_redistribute(struct _broadcastKey_t *pBroadcastKey); 70 71 TI_STATUS broadcastKey802_1x_event(struct _broadcastKey_t *pBroadcastKey, 72 TI_UINT8 event, 73 void *pData); 74 75 76 /** 77 * 78 * Function - Init KEY Parser module. 79 * 80 * \b Description: 81 * 82 * Called by RSN Manager. 83 * Registers the function 'rsn_BroadcastKeyRecv()' at the distributor to receive KEY frames upon receiving a KEY_RECV event. 84 * 85 * \b ARGS: 86 * 87 * 88 * \b RETURNS: 89 * 90 * TI_STATUS - 0 on success, any other value on failure. 91 * 92 */ 93 94 TI_STATUS broadcastKey802_1x_config(struct _broadcastKey_t *pBroadcastKey) 95 { 96 TI_STATUS status = TI_NOK; 97 98 /** Station broadcast key State Machine matrix */ 99 fsm_actionCell_t broadcastKey802_1x_matrix[BCAST_KEY_802_1X_NUM_STATES][BCAST_KEY_802_1X_NUM_EVENTS] = 100 { 101 /* next state and actions for IDLE state */ 102 { {BCAST_KEY_802_1X_STATE_START, (fsm_Action_t)broadcastKeySmNop}, 103 {BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmNop}, 104 {BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmNop}, 105 {BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmUnexpected} 106 }, 107 108 /* next state and actions for START state */ 109 { {BCAST_KEY_802_1X_STATE_START, (fsm_Action_t)broadcastKeySmUnexpected}, 110 {BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmNop}, 111 {BCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)broadcastKey802_1x_distribute}, 112 {BCAST_KEY_802_1X_STATE_START, (fsm_Action_t)broadcastKeySmNop} 113 }, 114 115 /* next state and actions for COMPLETE state */ 116 { {BCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)broadcastKeySmUnexpected}, 117 {BCAST_KEY_802_1X_STATE_IDLE, (fsm_Action_t)broadcastKeySmNop}, 118 {BCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)broadcastKey802_1x_distribute}, 119 {BCAST_KEY_802_1X_STATE_COMPLETE, (fsm_Action_t)broadcastKeySmUnexpected} 120 } 121 }; 122 123 124 pBroadcastKey->start = broadcastKey802_1x_start; 125 pBroadcastKey->stop = broadcastKey802_1x_stop; 126 pBroadcastKey->recvFailure = broadcastKey802_1x_recvFailure; 127 pBroadcastKey->recvSuccess = broadcastKey802_1x_recvSuccess; 128 129 pBroadcastKey->currentState = BCAST_KEY_802_1X_STATE_IDLE; 130 131 status = fsm_Config(pBroadcastKey->pBcastKeySm, 132 &broadcastKey802_1x_matrix[0][0], 133 BCAST_KEY_802_1X_NUM_STATES, 134 BCAST_KEY_802_1X_NUM_EVENTS, 135 NULL, pBroadcastKey->hOs); 136 137 138 139 return status; 140 } 141 142 143 /** 144 * 145 * broadcastKey802_1x_event 146 * 147 * \b Description: 148 * 149 * broadcast key state machine transition function 150 * 151 * \b ARGS: 152 * 153 * I/O - currentState - current state in the state machine\n 154 * I - event - specific event for the state machine\n 155 * I - pData - Data for state machine action function\n 156 * 157 * \b RETURNS: 158 * 159 * TI_OK on success, TI_NOK otherwise. 160 * 161 * \sa 162 */ 163 TI_STATUS broadcastKey802_1x_event(struct _broadcastKey_t *pBroadcastKey, TI_UINT8 event, void *pData) 164 { 165 TI_STATUS status; 166 TI_UINT8 nextState; 167 168 status = fsm_GetNextState(pBroadcastKey->pBcastKeySm, pBroadcastKey->currentState, event, &nextState); 169 if (status != TI_OK) 170 { 171 TRACE0(pBroadcastKey->hReport, REPORT_SEVERITY_ERROR, "BROADCAST_KEY_SM: ERROR: failed getting next state\n"); 172 return TI_NOK; 173 } 174 175 TRACE3(pBroadcastKey->hReport, REPORT_SEVERITY_INFORMATION, "STATION_BROADCAST_KEY_SM: <currentState = %d, event = %d> --> nextState = %d\n", pBroadcastKey->currentState, event, nextState); 176 177 status = fsm_Event(pBroadcastKey->pBcastKeySm, &pBroadcastKey->currentState, event, pData); 178 179 return status; 180 } 181 182 183 /** 184 * 185 * broadcastKey802_1x_start 186 * 187 * \b Description: 188 * 189 * START event handler 190 * 191 * \b ARGS: 192 * 193 * I - pCtrlB - station control block \n 194 * 195 * \b RETURNS: 196 * 197 * TI_OK on success, TI_NOK otherwise. 198 * 199 * \sa broadcastKey802_1x_stop() 200 */ 201 TI_STATUS broadcastKey802_1x_start(struct _broadcastKey_t *pBroadcastKey) 202 { 203 TI_STATUS status; 204 205 status = broadcastKey802_1x_event(pBroadcastKey, BCAST_KEY_802_1X_EVENT_START, pBroadcastKey); 206 207 return status; 208 } 209 210 211 /** 212 * 213 * broadcastKey802_1x_stop 214 * 215 * \b Description: 216 * 217 * START event handler 218 * 219 * \b ARGS: 220 * 221 * I - pCtrlB - station control block \n 222 * 223 * \b RETURNS: 224 * 225 * TI_OK on success, TI_NOK otherwise. 226 * 227 * \sa broadcastKey802_1x_start() 228 */ 229 TI_STATUS broadcastKey802_1x_stop(struct _broadcastKey_t *pBroadcastKey) 230 { 231 TI_STATUS status; 232 233 status = broadcastKey802_1x_event(pBroadcastKey, BCAST_KEY_802_1X_EVENT_STOP, pBroadcastKey); 234 235 return status; 236 } 237 238 239 /** 240 * 241 * broadcastKey802_1x_recvSuccess 242 * 243 * \b Description: 244 * 245 * SUCCESS event handler 246 * 247 * \b ARGS: 248 * 249 * I - pCtrlB - station control block \n 250 * I - pEncodedKeyMaterial - Encoded key material \n 251 * 252 * \b RETURNS: 253 * 254 * TI_OK on success, TI_NOK otherwise. 255 * 256 */ 257 TI_STATUS broadcastKey802_1x_recvSuccess(struct _broadcastKey_t *pBroadcastKey, encodedKeyMaterial_t *pEncodedKeyMaterial) 258 { 259 TI_STATUS status; 260 261 pBroadcastKey->data.pEncodedKeyMaterial = pEncodedKeyMaterial; 262 263 status = broadcastKey802_1x_event(pBroadcastKey, BCAST_KEY_802_1X_EVENT_SUCCESS, pBroadcastKey); 264 265 return status; 266 } 267 268 269 /** 270 * 271 * broadcastKey802_1x_recvFailure 272 * 273 * \b Description: 274 * 275 * FAILURE event handler 276 * 277 * \b ARGS: 278 * 279 * I - pCtrlB - station control block \n 280 * 281 * \b RETURNS: 282 * 283 * TI_OK on success, TI_NOK otherwise. 284 * 285 */ 286 TI_STATUS broadcastKey802_1x_recvFailure(struct _broadcastKey_t *pBroadcastKey) 287 { 288 TI_STATUS status; 289 290 status = broadcastKey802_1x_event(pBroadcastKey, BCAST_KEY_802_1X_EVENT_FAILURE, pBroadcastKey); 291 292 return status; 293 } 294 295 296 /** 297 * 298 * broadcastKey802_1x_distribute 299 * 300 * \b Description: 301 * 302 * Distribute broadcast key material to the driver and report the main key SM on broadcast complete. 303 * 304 * \b ARGS: 305 * 306 * I - pData - Encoded key material \n 307 * 308 * \b RETURNS: 309 * 310 * TI_OK on success, TI_NOK otherwise. 311 */ 312 TI_STATUS broadcastKey802_1x_distribute(struct _broadcastKey_t *pBroadcastKey) 313 { 314 TI_STATUS status=TI_NOK; 315 316 if (pBroadcastKey->pKeyDerive->derive!=NULL) 317 { 318 status = pBroadcastKey->pKeyDerive->derive(pBroadcastKey->pKeyDerive, 319 pBroadcastKey->data.pEncodedKeyMaterial); 320 } 321 if (status != TI_OK) 322 { 323 return TI_NOK; 324 } 325 326 if (pBroadcastKey->pParent->reportBcastStatus!=NULL) 327 { 328 status = pBroadcastKey->pParent->reportBcastStatus(pBroadcastKey->pParent, TI_OK); 329 } 330 331 mainKeys_reAuth(pBroadcastKey->pParent); 332 333 return status; 334 } 335 336
