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
broadcastKey802_1x_config(struct _broadcastKey_t * pBroadcastKey)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 */
broadcastKey802_1x_event(struct _broadcastKey_t * pBroadcastKey,TI_UINT8 event,void * pData)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 */
broadcastKey802_1x_start(struct _broadcastKey_t * pBroadcastKey)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 */
broadcastKey802_1x_stop(struct _broadcastKey_t * pBroadcastKey)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 */
broadcastKey802_1x_recvSuccess(struct _broadcastKey_t * pBroadcastKey,encodedKeyMaterial_t * pEncodedKeyMaterial)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 */
broadcastKey802_1x_recvFailure(struct _broadcastKey_t * pBroadcastKey)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 */
broadcastKey802_1x_distribute(struct _broadcastKey_t * pBroadcastKey)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