Branch data Line data Source code
1 : : /*
2 : : * hostapd / EAP-SAKE (RFC 4763) server
3 : : * Copyright (c) 2006-2007, Jouni Malinen <j@w1.fi>
4 : : *
5 : : * This software may be distributed under the terms of the BSD license.
6 : : * See README for more details.
7 : : */
8 : :
9 : : #include "includes.h"
10 : :
11 : : #include "common.h"
12 : : #include "crypto/random.h"
13 : : #include "eap_server/eap_i.h"
14 : : #include "eap_common/eap_sake_common.h"
15 : :
16 : :
17 : : struct eap_sake_data {
18 : : enum { IDENTITY, CHALLENGE, CONFIRM, SUCCESS, FAILURE } state;
19 : : u8 rand_s[EAP_SAKE_RAND_LEN];
20 : : u8 rand_p[EAP_SAKE_RAND_LEN];
21 : : struct {
22 : : u8 auth[EAP_SAKE_TEK_AUTH_LEN];
23 : : u8 cipher[EAP_SAKE_TEK_CIPHER_LEN];
24 : : } tek;
25 : : u8 msk[EAP_MSK_LEN];
26 : : u8 emsk[EAP_EMSK_LEN];
27 : : u8 session_id;
28 : : u8 *peerid;
29 : : size_t peerid_len;
30 : : };
31 : :
32 : :
33 : 10 : static const char * eap_sake_state_txt(int state)
34 : : {
35 [ - + + + : 10 : switch (state) {
+ - ]
36 : : case IDENTITY:
37 : 0 : return "IDENTITY";
38 : : case CHALLENGE:
39 : 3 : return "CHALLENGE";
40 : : case CONFIRM:
41 : 4 : return "CONFIRM";
42 : : case SUCCESS:
43 : 2 : return "SUCCESS";
44 : : case FAILURE:
45 : 1 : return "FAILURE";
46 : : default:
47 : 10 : return "?";
48 : : }
49 : : }
50 : :
51 : :
52 : 5 : static void eap_sake_state(struct eap_sake_data *data, int state)
53 : : {
54 : 5 : wpa_printf(MSG_DEBUG, "EAP-SAKE: %s -> %s",
55 : 5 : eap_sake_state_txt(data->state),
56 : : eap_sake_state_txt(state));
57 : 5 : data->state = state;
58 : 5 : }
59 : :
60 : :
61 : 3 : static void * eap_sake_init(struct eap_sm *sm)
62 : : {
63 : : struct eap_sake_data *data;
64 : :
65 : 3 : data = os_zalloc(sizeof(*data));
66 [ - + ]: 3 : if (data == NULL)
67 : 0 : return NULL;
68 : 3 : data->state = CHALLENGE;
69 : :
70 [ - + ]: 3 : if (os_get_random(&data->session_id, 1)) {
71 : 0 : wpa_printf(MSG_ERROR, "EAP-SAKE: Failed to get random data");
72 : 0 : os_free(data);
73 : 0 : return NULL;
74 : : }
75 : 3 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Initialized Session ID %d",
76 : 3 : data->session_id);
77 : :
78 : 3 : return data;
79 : : }
80 : :
81 : :
82 : 3 : static void eap_sake_reset(struct eap_sm *sm, void *priv)
83 : : {
84 : 3 : struct eap_sake_data *data = priv;
85 : 3 : os_free(data->peerid);
86 : 3 : os_free(data);
87 : 3 : }
88 : :
89 : :
90 : 5 : static struct wpabuf * eap_sake_build_msg(struct eap_sake_data *data,
91 : : u8 id, size_t length, u8 subtype)
92 : : {
93 : : struct eap_sake_hdr *sake;
94 : : struct wpabuf *msg;
95 : : size_t plen;
96 : :
97 : 5 : plen = sizeof(struct eap_sake_hdr) + length;
98 : :
99 : 5 : msg = eap_msg_alloc(EAP_VENDOR_IETF, EAP_TYPE_SAKE, plen,
100 : : EAP_CODE_REQUEST, id);
101 [ - + ]: 5 : if (msg == NULL) {
102 : 0 : wpa_printf(MSG_ERROR, "EAP-SAKE: Failed to allocate memory "
103 : : "request");
104 : 0 : return NULL;
105 : : }
106 : :
107 : 5 : sake = wpabuf_put(msg, sizeof(*sake));
108 : 5 : sake->version = EAP_SAKE_VERSION;
109 : 5 : sake->session_id = data->session_id;
110 : 5 : sake->subtype = subtype;
111 : :
112 : 5 : return msg;
113 : : }
114 : :
115 : :
116 : 0 : static struct wpabuf * eap_sake_build_identity(struct eap_sm *sm,
117 : : struct eap_sake_data *data,
118 : : u8 id)
119 : : {
120 : : struct wpabuf *msg;
121 : : size_t plen;
122 : :
123 : 0 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Request/Identity");
124 : :
125 : 0 : plen = 4;
126 : 0 : plen += 2 + sm->server_id_len;
127 : 0 : msg = eap_sake_build_msg(data, id, plen, EAP_SAKE_SUBTYPE_IDENTITY);
128 [ # # ]: 0 : if (msg == NULL) {
129 : 0 : data->state = FAILURE;
130 : 0 : return NULL;
131 : : }
132 : :
133 : 0 : wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_PERM_ID_REQ");
134 : 0 : eap_sake_add_attr(msg, EAP_SAKE_AT_PERM_ID_REQ, NULL, 2);
135 : :
136 : 0 : wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_SERVERID");
137 : 0 : eap_sake_add_attr(msg, EAP_SAKE_AT_SERVERID,
138 : : sm->server_id, sm->server_id_len);
139 : :
140 : 0 : return msg;
141 : : }
142 : :
143 : :
144 : 3 : static struct wpabuf * eap_sake_build_challenge(struct eap_sm *sm,
145 : : struct eap_sake_data *data,
146 : : u8 id)
147 : : {
148 : : struct wpabuf *msg;
149 : : size_t plen;
150 : :
151 : 3 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Request/Challenge");
152 : :
153 [ - + ]: 3 : if (random_get_bytes(data->rand_s, EAP_SAKE_RAND_LEN)) {
154 : 0 : wpa_printf(MSG_ERROR, "EAP-SAKE: Failed to get random data");
155 : 0 : data->state = FAILURE;
156 : 0 : return NULL;
157 : : }
158 : 3 : wpa_hexdump(MSG_MSGDUMP, "EAP-SAKE: RAND_S (server rand)",
159 : 3 : data->rand_s, EAP_SAKE_RAND_LEN);
160 : :
161 : 3 : plen = 2 + EAP_SAKE_RAND_LEN + 2 + sm->server_id_len;
162 : 3 : msg = eap_sake_build_msg(data, id, plen, EAP_SAKE_SUBTYPE_CHALLENGE);
163 [ - + ]: 3 : if (msg == NULL) {
164 : 0 : data->state = FAILURE;
165 : 0 : return NULL;
166 : : }
167 : :
168 : 3 : wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_RAND_S");
169 : 3 : eap_sake_add_attr(msg, EAP_SAKE_AT_RAND_S,
170 : 3 : data->rand_s, EAP_SAKE_RAND_LEN);
171 : :
172 : 3 : wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_SERVERID");
173 : 3 : eap_sake_add_attr(msg, EAP_SAKE_AT_SERVERID,
174 : : sm->server_id, sm->server_id_len);
175 : :
176 : 3 : return msg;
177 : : }
178 : :
179 : :
180 : 2 : static struct wpabuf * eap_sake_build_confirm(struct eap_sm *sm,
181 : : struct eap_sake_data *data,
182 : : u8 id)
183 : : {
184 : : struct wpabuf *msg;
185 : : u8 *mic;
186 : :
187 : 2 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Request/Confirm");
188 : :
189 : 2 : msg = eap_sake_build_msg(data, id, 2 + EAP_SAKE_MIC_LEN,
190 : : EAP_SAKE_SUBTYPE_CONFIRM);
191 [ - + ]: 2 : if (msg == NULL) {
192 : 0 : data->state = FAILURE;
193 : 0 : return NULL;
194 : : }
195 : :
196 : 2 : wpa_printf(MSG_DEBUG, "EAP-SAKE: * AT_MIC_S");
197 : 2 : wpabuf_put_u8(msg, EAP_SAKE_AT_MIC_S);
198 : 2 : wpabuf_put_u8(msg, 2 + EAP_SAKE_MIC_LEN);
199 : 2 : mic = wpabuf_put(msg, EAP_SAKE_MIC_LEN);
200 [ - + ]: 4 : if (eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
201 : : sm->server_id, sm->server_id_len,
202 : 2 : data->peerid, data->peerid_len, 0,
203 : 2 : wpabuf_head(msg), wpabuf_len(msg), mic, mic))
204 : : {
205 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Failed to compute MIC");
206 : 0 : data->state = FAILURE;
207 : 0 : os_free(msg);
208 : 0 : return NULL;
209 : : }
210 : :
211 : 2 : return msg;
212 : : }
213 : :
214 : :
215 : 5 : static struct wpabuf * eap_sake_buildReq(struct eap_sm *sm, void *priv, u8 id)
216 : : {
217 : 5 : struct eap_sake_data *data = priv;
218 : :
219 [ - + + - ]: 5 : switch (data->state) {
220 : : case IDENTITY:
221 : 0 : return eap_sake_build_identity(sm, data, id);
222 : : case CHALLENGE:
223 : 3 : return eap_sake_build_challenge(sm, data, id);
224 : : case CONFIRM:
225 : 2 : return eap_sake_build_confirm(sm, data, id);
226 : : default:
227 : 0 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Unknown state %d in buildReq",
228 : 0 : data->state);
229 : 0 : break;
230 : : }
231 : 5 : return NULL;
232 : : }
233 : :
234 : :
235 : 5 : static Boolean eap_sake_check(struct eap_sm *sm, void *priv,
236 : : struct wpabuf *respData)
237 : : {
238 : 5 : struct eap_sake_data *data = priv;
239 : : struct eap_sake_hdr *resp;
240 : : size_t len;
241 : : u8 version, session_id, subtype;
242 : : const u8 *pos;
243 : :
244 : 5 : pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SAKE, respData, &len);
245 [ - + ][ + - ]: 5 : if (pos == NULL || len < sizeof(struct eap_sake_hdr)) {
246 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Invalid frame");
247 : 0 : return TRUE;
248 : : }
249 : :
250 : 5 : resp = (struct eap_sake_hdr *) pos;
251 : 5 : version = resp->version;
252 : 5 : session_id = resp->session_id;
253 : 5 : subtype = resp->subtype;
254 : :
255 [ - + ]: 5 : if (version != EAP_SAKE_VERSION) {
256 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Unknown version %d", version);
257 : 0 : return TRUE;
258 : : }
259 : :
260 [ - + ]: 5 : if (session_id != data->session_id) {
261 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Session ID mismatch (%d,%d)",
262 : 0 : session_id, data->session_id);
263 : 0 : return TRUE;
264 : : }
265 : :
266 : 5 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Received frame: subtype=%d", subtype);
267 : :
268 [ # # ][ - + ]: 5 : if (data->state == IDENTITY && subtype == EAP_SAKE_SUBTYPE_IDENTITY)
269 : 0 : return FALSE;
270 : :
271 [ + + ][ + - ]: 5 : if (data->state == CHALLENGE && subtype == EAP_SAKE_SUBTYPE_CHALLENGE)
272 : 3 : return FALSE;
273 : :
274 [ + - ][ + - ]: 2 : if (data->state == CONFIRM && subtype == EAP_SAKE_SUBTYPE_CONFIRM)
275 : 2 : return FALSE;
276 : :
277 [ # # ]: 0 : if (subtype == EAP_SAKE_SUBTYPE_AUTH_REJECT)
278 : 0 : return FALSE;
279 : :
280 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Unexpected subtype=%d in state=%d",
281 : 0 : subtype, data->state);
282 : :
283 : 5 : return TRUE;
284 : : }
285 : :
286 : :
287 : 0 : static void eap_sake_process_identity(struct eap_sm *sm,
288 : : struct eap_sake_data *data,
289 : : const struct wpabuf *respData,
290 : : const u8 *payload, size_t payloadlen)
291 : : {
292 [ # # ]: 0 : if (data->state != IDENTITY)
293 : 0 : return;
294 : :
295 : 0 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Response/Identity");
296 : : /* TODO: update identity and select new user data */
297 : 0 : eap_sake_state(data, CHALLENGE);
298 : : }
299 : :
300 : :
301 : 3 : static void eap_sake_process_challenge(struct eap_sm *sm,
302 : : struct eap_sake_data *data,
303 : : const struct wpabuf *respData,
304 : : const u8 *payload, size_t payloadlen)
305 : : {
306 : : struct eap_sake_parse_attr attr;
307 : : u8 mic_p[EAP_SAKE_MIC_LEN];
308 : :
309 [ - + ]: 3 : if (data->state != CHALLENGE)
310 : 0 : return;
311 : :
312 : 3 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Response/Challenge");
313 : :
314 [ - + ]: 3 : if (eap_sake_parse_attributes(payload, payloadlen, &attr))
315 : 0 : return;
316 : :
317 [ + - ][ - + ]: 3 : if (!attr.rand_p || !attr.mic_p) {
318 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Response/Challenge did not "
319 : : "include AT_RAND_P or AT_MIC_P");
320 : 0 : return;
321 : : }
322 : :
323 : 3 : os_memcpy(data->rand_p, attr.rand_p, EAP_SAKE_RAND_LEN);
324 : :
325 : 3 : os_free(data->peerid);
326 : 3 : data->peerid = NULL;
327 : 3 : data->peerid_len = 0;
328 [ + - ]: 3 : if (attr.peerid) {
329 : 3 : data->peerid = os_malloc(attr.peerid_len);
330 [ - + ]: 3 : if (data->peerid == NULL)
331 : 0 : return;
332 : 3 : os_memcpy(data->peerid, attr.peerid, attr.peerid_len);
333 : 3 : data->peerid_len = attr.peerid_len;
334 : : }
335 : :
336 [ + - ][ + - ]: 3 : if (sm->user == NULL || sm->user->password == NULL ||
[ - + ]
337 : 3 : sm->user->password_len != 2 * EAP_SAKE_ROOT_SECRET_LEN) {
338 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Plaintext password with "
339 : : "%d-byte key not configured",
340 : : 2 * EAP_SAKE_ROOT_SECRET_LEN);
341 : 0 : data->state = FAILURE;
342 : 0 : return;
343 : : }
344 : 3 : eap_sake_derive_keys(sm->user->password,
345 : 3 : sm->user->password + EAP_SAKE_ROOT_SECRET_LEN,
346 : 3 : data->rand_s, data->rand_p,
347 : 3 : (u8 *) &data->tek, data->msk, data->emsk);
348 : :
349 : 6 : eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
350 : : sm->server_id, sm->server_id_len,
351 : 3 : data->peerid, data->peerid_len, 1,
352 : 3 : wpabuf_head(respData), wpabuf_len(respData),
353 : : attr.mic_p, mic_p);
354 [ + + ]: 3 : if (os_memcmp(attr.mic_p, mic_p, EAP_SAKE_MIC_LEN) != 0) {
355 : 1 : wpa_printf(MSG_INFO, "EAP-SAKE: Incorrect AT_MIC_P");
356 : 1 : eap_sake_state(data, FAILURE);
357 : 1 : return;
358 : : }
359 : :
360 : 3 : eap_sake_state(data, CONFIRM);
361 : : }
362 : :
363 : :
364 : 2 : static void eap_sake_process_confirm(struct eap_sm *sm,
365 : : struct eap_sake_data *data,
366 : : const struct wpabuf *respData,
367 : : const u8 *payload, size_t payloadlen)
368 : : {
369 : : struct eap_sake_parse_attr attr;
370 : : u8 mic_p[EAP_SAKE_MIC_LEN];
371 : :
372 [ - + ]: 2 : if (data->state != CONFIRM)
373 : 0 : return;
374 : :
375 : 2 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Response/Confirm");
376 : :
377 [ - + ]: 2 : if (eap_sake_parse_attributes(payload, payloadlen, &attr))
378 : 0 : return;
379 : :
380 [ - + ]: 2 : if (!attr.mic_p) {
381 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Response/Confirm did not "
382 : : "include AT_MIC_P");
383 : 0 : return;
384 : : }
385 : :
386 : 4 : eap_sake_compute_mic(data->tek.auth, data->rand_s, data->rand_p,
387 : : sm->server_id, sm->server_id_len,
388 : 2 : data->peerid, data->peerid_len, 1,
389 : 2 : wpabuf_head(respData), wpabuf_len(respData),
390 : : attr.mic_p, mic_p);
391 [ - + ]: 2 : if (os_memcmp(attr.mic_p, mic_p, EAP_SAKE_MIC_LEN) != 0) {
392 : 0 : wpa_printf(MSG_INFO, "EAP-SAKE: Incorrect AT_MIC_P");
393 : 0 : eap_sake_state(data, FAILURE);
394 : : } else
395 : 2 : eap_sake_state(data, SUCCESS);
396 : : }
397 : :
398 : :
399 : 0 : static void eap_sake_process_auth_reject(struct eap_sm *sm,
400 : : struct eap_sake_data *data,
401 : : const struct wpabuf *respData,
402 : : const u8 *payload, size_t payloadlen)
403 : : {
404 : 0 : wpa_printf(MSG_DEBUG, "EAP-SAKE: Received Response/Auth-Reject");
405 : 0 : eap_sake_state(data, FAILURE);
406 : 0 : }
407 : :
408 : :
409 : 5 : static void eap_sake_process(struct eap_sm *sm, void *priv,
410 : : struct wpabuf *respData)
411 : : {
412 : 5 : struct eap_sake_data *data = priv;
413 : : struct eap_sake_hdr *resp;
414 : : u8 subtype;
415 : : size_t len;
416 : : const u8 *pos, *end;
417 : :
418 : 5 : pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SAKE, respData, &len);
419 [ - + ][ + - ]: 5 : if (pos == NULL || len < sizeof(struct eap_sake_hdr))
420 : 5 : return;
421 : :
422 : 5 : resp = (struct eap_sake_hdr *) pos;
423 : 5 : end = pos + len;
424 : 5 : subtype = resp->subtype;
425 : 5 : pos = (u8 *) (resp + 1);
426 : :
427 : 5 : wpa_hexdump(MSG_DEBUG, "EAP-SAKE: Received attributes",
428 : 5 : pos, end - pos);
429 : :
430 [ - + + - : 5 : switch (subtype) {
- ]
431 : : case EAP_SAKE_SUBTYPE_IDENTITY:
432 : 0 : eap_sake_process_identity(sm, data, respData, pos, end - pos);
433 : 0 : break;
434 : : case EAP_SAKE_SUBTYPE_CHALLENGE:
435 : 3 : eap_sake_process_challenge(sm, data, respData, pos, end - pos);
436 : 3 : break;
437 : : case EAP_SAKE_SUBTYPE_CONFIRM:
438 : 2 : eap_sake_process_confirm(sm, data, respData, pos, end - pos);
439 : 2 : break;
440 : : case EAP_SAKE_SUBTYPE_AUTH_REJECT:
441 : 0 : eap_sake_process_auth_reject(sm, data, respData, pos,
442 : 0 : end - pos);
443 : 0 : break;
444 : : }
445 : : }
446 : :
447 : :
448 : 6 : static Boolean eap_sake_isDone(struct eap_sm *sm, void *priv)
449 : : {
450 : 6 : struct eap_sake_data *data = priv;
451 [ + + ][ + + ]: 6 : return data->state == SUCCESS || data->state == FAILURE;
452 : : }
453 : :
454 : :
455 : 3 : static u8 * eap_sake_getKey(struct eap_sm *sm, void *priv, size_t *len)
456 : : {
457 : 3 : struct eap_sake_data *data = priv;
458 : : u8 *key;
459 : :
460 [ + + ]: 3 : if (data->state != SUCCESS)
461 : 1 : return NULL;
462 : :
463 : 2 : key = os_malloc(EAP_MSK_LEN);
464 [ - + ]: 2 : if (key == NULL)
465 : 0 : return NULL;
466 : 2 : os_memcpy(key, data->msk, EAP_MSK_LEN);
467 : 2 : *len = EAP_MSK_LEN;
468 : :
469 : 3 : return key;
470 : : }
471 : :
472 : :
473 : 0 : static u8 * eap_sake_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
474 : : {
475 : 0 : struct eap_sake_data *data = priv;
476 : : u8 *key;
477 : :
478 [ # # ]: 0 : if (data->state != SUCCESS)
479 : 0 : return NULL;
480 : :
481 : 0 : key = os_malloc(EAP_EMSK_LEN);
482 [ # # ]: 0 : if (key == NULL)
483 : 0 : return NULL;
484 : 0 : os_memcpy(key, data->emsk, EAP_EMSK_LEN);
485 : 0 : *len = EAP_EMSK_LEN;
486 : :
487 : 0 : return key;
488 : : }
489 : :
490 : :
491 : 4 : static Boolean eap_sake_isSuccess(struct eap_sm *sm, void *priv)
492 : : {
493 : 4 : struct eap_sake_data *data = priv;
494 : 4 : return data->state == SUCCESS;
495 : : }
496 : :
497 : :
498 : 2 : int eap_server_sake_register(void)
499 : : {
500 : : struct eap_method *eap;
501 : : int ret;
502 : :
503 : 2 : eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
504 : : EAP_VENDOR_IETF, EAP_TYPE_SAKE, "SAKE");
505 [ - + ]: 2 : if (eap == NULL)
506 : 0 : return -1;
507 : :
508 : 2 : eap->init = eap_sake_init;
509 : 2 : eap->reset = eap_sake_reset;
510 : 2 : eap->buildReq = eap_sake_buildReq;
511 : 2 : eap->check = eap_sake_check;
512 : 2 : eap->process = eap_sake_process;
513 : 2 : eap->isDone = eap_sake_isDone;
514 : 2 : eap->getKey = eap_sake_getKey;
515 : 2 : eap->isSuccess = eap_sake_isSuccess;
516 : 2 : eap->get_emsk = eap_sake_get_emsk;
517 : :
518 : 2 : ret = eap_server_method_register(eap);
519 [ - + ]: 2 : if (ret)
520 : 0 : eap_server_method_free(eap);
521 : 2 : return ret;
522 : : }
|
