← Back to branch summary

~ubuntu-branches/ubuntu/vivid/wpasupplicant/vivid

« back to all changes in this revision

Viewing changes to src/eap_server/eap_sim.c

  • Committer: Bazaar Package Importer
  • Author(s): Kel Modderman
  • Date: 2008-03-12 20:03:04 UTC
  • mfrom: (1.1.10 upstream)
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20080312200304-4331y9wj46pdd34z
Tags: 0.6.3-1
http://bugs.debian.org/466910
* New upstream release.
* Drop patches applied upstream:
  - debian/patches/30_wpa_gui_qt4_eventhistoryui_rework.patch
  - debian/patches/31_wpa_gui_qt4_eventhistory_always_scrollbar.patch
  - debian/patches/32_wpa_gui_qt4_eventhistory_scroll_with_events.patch
  - debian/patches/40_dbus_ssid_data.patch
* Tidy up the clean target of debian/rules. Now that the madwifi headers are
  handled differently we no longer need to do any cleanup.
* Fix formatting error in debian/ifupdown/wpa_action.8 to make lintian
  quieter.
* Add patch to fix formatting errors in manpages build from sgml source. Use
  <emphasis> tags to hightlight keywords instead of surrounding them in
  strong quotes.
  - debian/patches/41_manpage_format_fixes.patch
* wpasupplicant binary package no longer suggests pcscd, guessnet, iproute
  or wireless-tools, nor does it recommend dhcp3-client. These are not
  needed.
* Add debian/patches/10_silence_siocsiwauth_icotl_failure.patch to disable
  ioctl failure messages that occur under normal conditions.
* Cherry pick two upstream git commits concerning the dbus interface:
  - debian/patches/11_avoid_dbus_version_namespace.patch
  - debian/patches/12_fix_potential_use_after_free.patch
* Add debian/patches/42_manpage_explain_available_drivers.patch to explain
  that not all of the driver backends are available in the provided
  wpa_supplicant binary, and that the canonical list of supported driver
  backends can be retrieved from the wpa_supplicant -h (help) output.
  (Closes: #466910)
* Add debian/patches/20_wpa_gui_qt4_disable_link_prl.patch to remove
  link_prl CONFIG compile flag added by qmake-qt4 >= 4.3.4-2 to avoid excess
  linking.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/eap_server/eap_sim.c
 
1
/*
 
2
 * hostapd / EAP-SIM (RFC 4186)
 
3
 * Copyright (c) 2005-2008, Jouni Malinen <j@w1.fi>
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License version 2 as
 
7
 * published by the Free Software Foundation.
 
8
 *
 
9
 * Alternatively, this software may be distributed under the terms of BSD
 
10
 * license.
 
11
 *
 
12
 * See README and COPYING for more details.
 
13
 */
 
14
 
 
15
#include "includes.h"
 
16
 
 
17
#include "common.h"
 
18
#include "eap_server/eap_i.h"
 
19
#include "eap_common/eap_sim_common.h"
 
20
#include "eap_server/eap_sim_db.h"
 
21
 
 
22
 
 
23
struct eap_sim_data {
 
24
        u8 mk[EAP_SIM_MK_LEN];
 
25
        u8 nonce_mt[EAP_SIM_NONCE_MT_LEN];
 
26
        u8 nonce_s[EAP_SIM_NONCE_S_LEN];
 
27
        u8 k_aut[EAP_SIM_K_AUT_LEN];
 
28
        u8 k_encr[EAP_SIM_K_ENCR_LEN];
 
29
        u8 msk[EAP_SIM_KEYING_DATA_LEN];
 
30
        u8 emsk[EAP_EMSK_LEN];
 
31
        u8 kc[EAP_SIM_MAX_CHAL][EAP_SIM_KC_LEN];
 
32
        u8 sres[EAP_SIM_MAX_CHAL][EAP_SIM_SRES_LEN];
 
33
        u8 rand[EAP_SIM_MAX_CHAL][GSM_RAND_LEN];
 
34
        int num_chal;
 
35
        enum {
 
36
                START, CHALLENGE, REAUTH, NOTIFICATION, SUCCESS, FAILURE
 
37
        } state;
 
38
        char *next_pseudonym;
 
39
        char *next_reauth_id;
 
40
        u16 counter;
 
41
        struct eap_sim_reauth *reauth;
 
42
        u16 notification;
 
43
        int use_result_ind;
 
44
};
 
45
 
 
46
 
 
47
static const char * eap_sim_state_txt(int state)
 
48
{
 
49
        switch (state) {
 
50
        case START:
 
51
                return "START";
 
52
        case CHALLENGE:
 
53
                return "CHALLENGE";
 
54
        case REAUTH:
 
55
                return "REAUTH";
 
56
        case SUCCESS:
 
57
                return "SUCCESS";
 
58
        case FAILURE:
 
59
                return "FAILURE";
 
60
        case NOTIFICATION:
 
61
                return "NOTIFICATION";
 
62
        default:
 
63
                return "Unknown?!";
 
64
        }
 
65
}
 
66
 
 
67
 
 
68
static void eap_sim_state(struct eap_sim_data *data, int state)
 
69
{
 
70
        wpa_printf(MSG_DEBUG, "EAP-SIM: %s -> %s",
 
71
                   eap_sim_state_txt(data->state),
 
72
                   eap_sim_state_txt(state));
 
73
        data->state = state;
 
74
}
 
75
 
 
76
 
 
77
static void * eap_sim_init(struct eap_sm *sm)
 
78
{
 
79
        struct eap_sim_data *data;
 
80
 
 
81
        if (sm->eap_sim_db_priv == NULL) {
 
82
                wpa_printf(MSG_WARNING, "EAP-SIM: eap_sim_db not configured");
 
83
                return NULL;
 
84
        }
 
85
 
 
86
        data = os_zalloc(sizeof(*data));
 
87
        if (data == NULL)
 
88
                return NULL;
 
89
        data->state = START;
 
90
 
 
91
        return data;
 
92
}
 
93
 
 
94
 
 
95
static void eap_sim_reset(struct eap_sm *sm, void *priv)
 
96
{
 
97
        struct eap_sim_data *data = priv;
 
98
        os_free(data->next_pseudonym);
 
99
        os_free(data->next_reauth_id);
 
100
        os_free(data);
 
101
}
 
102
 
 
103
 
 
104
static struct wpabuf * eap_sim_build_start(struct eap_sm *sm,
 
105
                                           struct eap_sim_data *data, u8 id)
 
106
{
 
107
        struct eap_sim_msg *msg;
 
108
        u8 ver[2];
 
109
 
 
110
        wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Start");
 
111
        msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
 
112
                               EAP_SIM_SUBTYPE_START);
 
113
        if (eap_sim_db_identity_known(sm->eap_sim_db_priv, sm->identity,
 
114
                                      sm->identity_len)) {
 
115
                wpa_printf(MSG_DEBUG, "   AT_PERMANENT_ID_REQ");
 
116
                eap_sim_msg_add(msg, EAP_SIM_AT_PERMANENT_ID_REQ, 0, NULL, 0);
 
117
        } else {
 
118
                /*
 
119
                 * RFC 4186, Chap. 4.2.4 recommends that identity from EAP is
 
120
                 * ignored and the SIM/Start is used to request the identity.
 
121
                 */
 
122
                wpa_printf(MSG_DEBUG, "   AT_ANY_ID_REQ");
 
123
                eap_sim_msg_add(msg, EAP_SIM_AT_ANY_ID_REQ, 0, NULL, 0);
 
124
        }
 
125
        wpa_printf(MSG_DEBUG, "   AT_VERSION_LIST");
 
126
        ver[0] = 0;
 
127
        ver[1] = EAP_SIM_VERSION;
 
128
        eap_sim_msg_add(msg, EAP_SIM_AT_VERSION_LIST, sizeof(ver),
 
129
                        ver, sizeof(ver));
 
130
        return eap_sim_msg_finish(msg, NULL, NULL, 0);
 
131
}
 
132
 
 
133
 
 
134
static int eap_sim_build_encr(struct eap_sm *sm, struct eap_sim_data *data,
 
135
                              struct eap_sim_msg *msg, u16 counter,
 
136
                              const u8 *nonce_s)
 
137
{
 
138
        os_free(data->next_pseudonym);
 
139
        data->next_pseudonym =
 
140
                eap_sim_db_get_next_pseudonym(sm->eap_sim_db_priv, 0);
 
141
        os_free(data->next_reauth_id);
 
142
        if (data->counter <= EAP_SIM_MAX_FAST_REAUTHS) {
 
143
                data->next_reauth_id =
 
144
                        eap_sim_db_get_next_reauth_id(sm->eap_sim_db_priv, 0);
 
145
        } else {
 
146
                wpa_printf(MSG_DEBUG, "EAP-SIM: Max fast re-authentication "
 
147
                           "count exceeded - force full authentication");
 
148
                data->next_reauth_id = NULL;
 
149
        }
 
150
 
 
151
        if (data->next_pseudonym == NULL && data->next_reauth_id == NULL &&
 
152
            counter == 0 && nonce_s == NULL)
 
153
                return 0;
 
154
 
 
155
        wpa_printf(MSG_DEBUG, "   AT_IV");
 
156
        wpa_printf(MSG_DEBUG, "   AT_ENCR_DATA");
 
157
        eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV, EAP_SIM_AT_ENCR_DATA);
 
158
 
 
159
        if (counter > 0) {
 
160
                wpa_printf(MSG_DEBUG, "   *AT_COUNTER (%u)", counter);
 
161
                eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, counter, NULL, 0);
 
162
        }
 
163
 
 
164
        if (nonce_s) {
 
165
                wpa_printf(MSG_DEBUG, "   *AT_NONCE_S");
 
166
                eap_sim_msg_add(msg, EAP_SIM_AT_NONCE_S, 0, nonce_s,
 
167
                                EAP_SIM_NONCE_S_LEN);
 
168
        }
 
169
 
 
170
        if (data->next_pseudonym) {
 
171
                wpa_printf(MSG_DEBUG, "   *AT_NEXT_PSEUDONYM (%s)",
 
172
                           data->next_pseudonym);
 
173
                eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_PSEUDONYM,
 
174
                                os_strlen(data->next_pseudonym),
 
175
                                (u8 *) data->next_pseudonym,
 
176
                                os_strlen(data->next_pseudonym));
 
177
        }
 
178
 
 
179
        if (data->next_reauth_id) {
 
180
                wpa_printf(MSG_DEBUG, "   *AT_NEXT_REAUTH_ID (%s)",
 
181
                           data->next_reauth_id);
 
182
                eap_sim_msg_add(msg, EAP_SIM_AT_NEXT_REAUTH_ID,
 
183
                                os_strlen(data->next_reauth_id),
 
184
                                (u8 *) data->next_reauth_id,
 
185
                                os_strlen(data->next_reauth_id));
 
186
        }
 
187
 
 
188
        if (eap_sim_msg_add_encr_end(msg, data->k_encr, EAP_SIM_AT_PADDING)) {
 
189
                wpa_printf(MSG_WARNING, "EAP-SIM: Failed to encrypt "
 
190
                           "AT_ENCR_DATA");
 
191
                return -1;
 
192
        }
 
193
 
 
194
        return 0;
 
195
}
 
196
 
 
197
 
 
198
static struct wpabuf * eap_sim_build_challenge(struct eap_sm *sm,
 
199
                                               struct eap_sim_data *data,
 
200
                                               u8 id)
 
201
{
 
202
        struct eap_sim_msg *msg;
 
203
 
 
204
        wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Challenge");
 
205
        msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
 
206
                               EAP_SIM_SUBTYPE_CHALLENGE);
 
207
        wpa_printf(MSG_DEBUG, "   AT_RAND");
 
208
        eap_sim_msg_add(msg, EAP_SIM_AT_RAND, 0, (u8 *) data->rand,
 
209
                        data->num_chal * GSM_RAND_LEN);
 
210
 
 
211
        if (eap_sim_build_encr(sm, data, msg, 0, NULL)) {
 
212
                eap_sim_msg_free(msg);
 
213
                return NULL;
 
214
        }
 
215
 
 
216
        if (sm->eap_sim_aka_result_ind) {
 
217
                wpa_printf(MSG_DEBUG, "   AT_RESULT_IND");
 
218
                eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0);
 
219
        }
 
220
 
 
221
        wpa_printf(MSG_DEBUG, "   AT_MAC");
 
222
        eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
 
223
        return eap_sim_msg_finish(msg, data->k_aut, data->nonce_mt,
 
224
                                  EAP_SIM_NONCE_MT_LEN);
 
225
}
 
226
 
 
227
 
 
228
static struct wpabuf * eap_sim_build_reauth(struct eap_sm *sm,
 
229
                                            struct eap_sim_data *data, u8 id)
 
230
{
 
231
        struct eap_sim_msg *msg;
 
232
 
 
233
        wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Re-authentication");
 
234
 
 
235
        if (os_get_random(data->nonce_s, EAP_SIM_NONCE_S_LEN))
 
236
                return NULL;
 
237
        wpa_hexdump_key(MSG_MSGDUMP, "EAP-SIM: NONCE_S",
 
238
                        data->nonce_s, EAP_SIM_NONCE_S_LEN);
 
239
 
 
240
        eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk,
 
241
                            data->emsk);
 
242
        eap_sim_derive_keys_reauth(data->counter, sm->identity,
 
243
                                   sm->identity_len, data->nonce_s, data->mk,
 
244
                                   data->msk, data->emsk);
 
245
 
 
246
        msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
 
247
                               EAP_SIM_SUBTYPE_REAUTHENTICATION);
 
248
 
 
249
        if (eap_sim_build_encr(sm, data, msg, data->counter, data->nonce_s)) {
 
250
                eap_sim_msg_free(msg);
 
251
                return NULL;
 
252
        }
 
253
 
 
254
        if (sm->eap_sim_aka_result_ind) {
 
255
                wpa_printf(MSG_DEBUG, "   AT_RESULT_IND");
 
256
                eap_sim_msg_add(msg, EAP_SIM_AT_RESULT_IND, 0, NULL, 0);
 
257
        }
 
258
 
 
259
        wpa_printf(MSG_DEBUG, "   AT_MAC");
 
260
        eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
 
261
        return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
 
262
}
 
263
 
 
264
 
 
265
static struct wpabuf * eap_sim_build_notification(struct eap_sm *sm,
 
266
                                                  struct eap_sim_data *data,
 
267
                                                  u8 id)
 
268
{
 
269
        struct eap_sim_msg *msg;
 
270
 
 
271
        wpa_printf(MSG_DEBUG, "EAP-SIM: Generating Notification");
 
272
        msg = eap_sim_msg_init(EAP_CODE_REQUEST, id, EAP_TYPE_SIM,
 
273
                               EAP_SIM_SUBTYPE_NOTIFICATION);
 
274
        wpa_printf(MSG_DEBUG, "   AT_NOTIFICATION (%d)", data->notification);
 
275
        eap_sim_msg_add(msg, EAP_SIM_AT_NOTIFICATION, data->notification,
 
276
                        NULL, 0);
 
277
        if (data->use_result_ind) {
 
278
                if (data->reauth) {
 
279
                        wpa_printf(MSG_DEBUG, "   AT_IV");
 
280
                        wpa_printf(MSG_DEBUG, "   AT_ENCR_DATA");
 
281
                        eap_sim_msg_add_encr_start(msg, EAP_SIM_AT_IV,
 
282
                                                   EAP_SIM_AT_ENCR_DATA);
 
283
                        wpa_printf(MSG_DEBUG, "   *AT_COUNTER (%u)",
 
284
                                   data->counter);
 
285
                        eap_sim_msg_add(msg, EAP_SIM_AT_COUNTER, data->counter,
 
286
                                        NULL, 0);
 
287
 
 
288
                        if (eap_sim_msg_add_encr_end(msg, data->k_encr,
 
289
                                                     EAP_SIM_AT_PADDING)) {
 
290
                                wpa_printf(MSG_WARNING, "EAP-SIM: Failed to "
 
291
                                           "encrypt AT_ENCR_DATA");
 
292
                                eap_sim_msg_free(msg);
 
293
                                return NULL;
 
294
                        }
 
295
                }
 
296
 
 
297
                wpa_printf(MSG_DEBUG, "   AT_MAC");
 
298
                eap_sim_msg_add_mac(msg, EAP_SIM_AT_MAC);
 
299
        }
 
300
        return eap_sim_msg_finish(msg, data->k_aut, NULL, 0);
 
301
}
 
302
 
 
303
 
 
304
static struct wpabuf * eap_sim_buildReq(struct eap_sm *sm, void *priv, u8 id)
 
305
{
 
306
        struct eap_sim_data *data = priv;
 
307
 
 
308
        switch (data->state) {
 
309
        case START:
 
310
                return eap_sim_build_start(sm, data, id);
 
311
        case CHALLENGE:
 
312
                return eap_sim_build_challenge(sm, data, id);
 
313
        case REAUTH:
 
314
                return eap_sim_build_reauth(sm, data, id);
 
315
        case NOTIFICATION:
 
316
                return eap_sim_build_notification(sm, data, id);
 
317
        default:
 
318
                wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown state %d in "
 
319
                           "buildReq", data->state);
 
320
                break;
 
321
        }
 
322
        return NULL;
 
323
}
 
324
 
 
325
 
 
326
static Boolean eap_sim_check(struct eap_sm *sm, void *priv,
 
327
                             struct wpabuf *respData)
 
328
{
 
329
        struct eap_sim_data *data = priv;
 
330
        const u8 *pos;
 
331
        size_t len;
 
332
        u8 subtype;
 
333
 
 
334
        pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, respData, &len);
 
335
        if (pos == NULL || len < 3) {
 
336
                wpa_printf(MSG_INFO, "EAP-SIM: Invalid frame");
 
337
                return TRUE;
 
338
        }
 
339
        subtype = *pos;
 
340
 
 
341
        if (subtype == EAP_SIM_SUBTYPE_CLIENT_ERROR)
 
342
                return FALSE;
 
343
 
 
344
        switch (data->state) {
 
345
        case START:
 
346
                if (subtype != EAP_SIM_SUBTYPE_START) {
 
347
                        wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
 
348
                                   "subtype %d", subtype);
 
349
                        return TRUE;
 
350
                }
 
351
                break;
 
352
        case CHALLENGE:
 
353
                if (subtype != EAP_SIM_SUBTYPE_CHALLENGE) {
 
354
                        wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
 
355
                                   "subtype %d", subtype);
 
356
                        return TRUE;
 
357
                }
 
358
                break;
 
359
        case REAUTH:
 
360
                if (subtype != EAP_SIM_SUBTYPE_REAUTHENTICATION) {
 
361
                        wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
 
362
                                   "subtype %d", subtype);
 
363
                        return TRUE;
 
364
                }
 
365
                break;
 
366
        case NOTIFICATION:
 
367
                if (subtype != EAP_SIM_SUBTYPE_NOTIFICATION) {
 
368
                        wpa_printf(MSG_INFO, "EAP-SIM: Unexpected response "
 
369
                                   "subtype %d", subtype);
 
370
                        return TRUE;
 
371
                }
 
372
                break;
 
373
        default:
 
374
                wpa_printf(MSG_INFO, "EAP-SIM: Unexpected state (%d) for "
 
375
                           "processing a response", data->state);
 
376
                return TRUE;
 
377
        }
 
378
 
 
379
        return FALSE;
 
380
}
 
381
 
 
382
 
 
383
static int eap_sim_supported_ver(struct eap_sim_data *data, int version)
 
384
{
 
385
        return version == EAP_SIM_VERSION;
 
386
}
 
387
 
 
388
 
 
389
static void eap_sim_process_start(struct eap_sm *sm,
 
390
                                  struct eap_sim_data *data,
 
391
                                  struct wpabuf *respData,
 
392
                                  struct eap_sim_attrs *attr)
 
393
{
 
394
        const u8 *identity;
 
395
        size_t identity_len;
 
396
        u8 ver_list[2];
 
397
 
 
398
        wpa_printf(MSG_DEBUG, "EAP-SIM: Receive start response");
 
399
 
 
400
        if (attr->identity) {
 
401
                os_free(sm->identity);
 
402
                sm->identity = os_malloc(attr->identity_len);
 
403
                if (sm->identity) {
 
404
                        os_memcpy(sm->identity, attr->identity,
 
405
                                  attr->identity_len);
 
406
                        sm->identity_len = attr->identity_len;
 
407
                }
 
408
        }
 
409
 
 
410
        identity = NULL;
 
411
        identity_len = 0;
 
412
 
 
413
        if (sm->identity && sm->identity_len > 0 &&
 
414
            sm->identity[0] == EAP_SIM_PERMANENT_PREFIX) {
 
415
                identity = sm->identity;
 
416
                identity_len = sm->identity_len;
 
417
        } else {
 
418
                identity = eap_sim_db_get_permanent(sm->eap_sim_db_priv,
 
419
                                                    sm->identity,
 
420
                                                    sm->identity_len,
 
421
                                                    &identity_len);
 
422
                if (identity == NULL) {
 
423
                        data->reauth = eap_sim_db_get_reauth_entry(
 
424
                                sm->eap_sim_db_priv, sm->identity,
 
425
                                sm->identity_len);
 
426
                        if (data->reauth) {
 
427
                                wpa_printf(MSG_DEBUG, "EAP-SIM: Using fast "
 
428
                                           "re-authentication");
 
429
                                identity = data->reauth->identity;
 
430
                                identity_len = data->reauth->identity_len;
 
431
                                data->counter = data->reauth->counter;
 
432
                                os_memcpy(data->mk, data->reauth->mk,
 
433
                                          EAP_SIM_MK_LEN);
 
434
                        }
 
435
                }
 
436
        }
 
437
 
 
438
        if (identity == NULL) {
 
439
                wpa_printf(MSG_DEBUG, "EAP-SIM: Could not get proper permanent"
 
440
                           " user name");
 
441
                eap_sim_state(data, FAILURE);
 
442
                return;
 
443
        }
 
444
 
 
445
        wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Identity",
 
446
                          identity, identity_len);
 
447
 
 
448
        if (data->reauth) {
 
449
                eap_sim_state(data, REAUTH);
 
450
                return;
 
451
        }
 
452
 
 
453
        if (attr->nonce_mt == NULL || attr->selected_version < 0) {
 
454
                wpa_printf(MSG_DEBUG, "EAP-SIM: Start/Response missing "
 
455
                           "required attributes");
 
456
                eap_sim_state(data, FAILURE);
 
457
                return;
 
458
        }
 
459
 
 
460
        if (!eap_sim_supported_ver(data, attr->selected_version)) {
 
461
                wpa_printf(MSG_DEBUG, "EAP-SIM: Peer selected unsupported "
 
462
                           "version %d", attr->selected_version);
 
463
                eap_sim_state(data, FAILURE);
 
464
                return;
 
465
        }
 
466
 
 
467
        data->counter = 0; /* reset re-auth counter since this is full auth */
 
468
        data->reauth = NULL;
 
469
 
 
470
        data->num_chal = eap_sim_db_get_gsm_triplets(
 
471
                sm->eap_sim_db_priv, identity, identity_len,
 
472
                EAP_SIM_MAX_CHAL,
 
473
                (u8 *) data->rand, (u8 *) data->kc, (u8 *) data->sres, sm);
 
474
        if (data->num_chal == EAP_SIM_DB_PENDING) {
 
475
                wpa_printf(MSG_DEBUG, "EAP-SIM: GSM authentication triplets "
 
476
                           "not yet available - pending request");
 
477
                sm->method_pending = METHOD_PENDING_WAIT;
 
478
                return;
 
479
        }
 
480
        if (data->num_chal < 2) {
 
481
                wpa_printf(MSG_INFO, "EAP-SIM: Failed to get GSM "
 
482
                           "authentication triplets for the peer");
 
483
                eap_sim_state(data, FAILURE);
 
484
                return;
 
485
        }
 
486
 
 
487
        identity_len = sm->identity_len;
 
488
        while (identity_len > 0 && sm->identity[identity_len - 1] == '\0') {
 
489
                wpa_printf(MSG_DEBUG, "EAP-SIM: Workaround - drop last null "
 
490
                           "character from identity");
 
491
                identity_len--;
 
492
        }
 
493
        wpa_hexdump_ascii(MSG_DEBUG, "EAP-SIM: Identity for MK derivation",
 
494
                          sm->identity, identity_len);
 
495
 
 
496
        os_memcpy(data->nonce_mt, attr->nonce_mt, EAP_SIM_NONCE_MT_LEN);
 
497
        WPA_PUT_BE16(ver_list, EAP_SIM_VERSION);
 
498
        eap_sim_derive_mk(sm->identity, identity_len, attr->nonce_mt,
 
499
                          attr->selected_version, ver_list, sizeof(ver_list),
 
500
                          data->num_chal, (const u8 *) data->kc, data->mk);
 
501
        eap_sim_derive_keys(data->mk, data->k_encr, data->k_aut, data->msk,
 
502
                            data->emsk);
 
503
 
 
504
        eap_sim_state(data, CHALLENGE);
 
505
}
 
506
 
 
507
 
 
508
static void eap_sim_process_challenge(struct eap_sm *sm,
 
509
                                      struct eap_sim_data *data,
 
510
                                      struct wpabuf *respData,
 
511
                                      struct eap_sim_attrs *attr)
 
512
{
 
513
        const u8 *identity;
 
514
        size_t identity_len;
 
515
 
 
516
        if (attr->mac == NULL ||
 
517
            eap_sim_verify_mac(data->k_aut, respData, attr->mac,
 
518
                               (u8 *) data->sres,
 
519
                               data->num_chal * EAP_SIM_SRES_LEN)) {
 
520
                wpa_printf(MSG_WARNING, "EAP-SIM: Challenge message "
 
521
                           "did not include valid AT_MAC");
 
522
                eap_sim_state(data, FAILURE);
 
523
                return;
 
524
        }
 
525
 
 
526
        wpa_printf(MSG_DEBUG, "EAP-SIM: Challenge response includes the "
 
527
                   "correct AT_MAC");
 
528
        if (sm->eap_sim_aka_result_ind && attr->result_ind) {
 
529
                data->use_result_ind = 1;
 
530
                data->notification = EAP_SIM_SUCCESS;
 
531
                eap_sim_state(data, NOTIFICATION);
 
532
        } else
 
533
                eap_sim_state(data, SUCCESS);
 
534
 
 
535
        identity = eap_sim_db_get_permanent(sm->eap_sim_db_priv, sm->identity,
 
536
                                            sm->identity_len, &identity_len);
 
537
        if (identity == NULL) {
 
538
                identity = sm->identity;
 
539
                identity_len = sm->identity_len;
 
540
        }
 
541
 
 
542
        if (data->next_pseudonym) {
 
543
                eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, identity,
 
544
                                         identity_len,
 
545
                                         data->next_pseudonym);
 
546
                data->next_pseudonym = NULL;
 
547
        }
 
548
        if (data->next_reauth_id) {
 
549
                eap_sim_db_add_reauth(sm->eap_sim_db_priv, identity,
 
550
                                      identity_len,
 
551
                                      data->next_reauth_id, data->counter + 1,
 
552
                                      data->mk);
 
553
                data->next_reauth_id = NULL;
 
554
        }
 
555
}
 
556
 
 
557
 
 
558
static void eap_sim_process_reauth(struct eap_sm *sm,
 
559
                                   struct eap_sim_data *data,
 
560
                                   struct wpabuf *respData,
 
561
                                   struct eap_sim_attrs *attr)
 
562
{
 
563
        struct eap_sim_attrs eattr;
 
564
        u8 *decrypted = NULL;
 
565
        const u8 *identity, *id2;
 
566
        size_t identity_len, id2_len;
 
567
 
 
568
        if (attr->mac == NULL ||
 
569
            eap_sim_verify_mac(data->k_aut, respData, attr->mac, data->nonce_s,
 
570
                               EAP_SIM_NONCE_S_LEN)) {
 
571
                wpa_printf(MSG_WARNING, "EAP-SIM: Re-authentication message "
 
572
                           "did not include valid AT_MAC");
 
573
                goto fail;
 
574
        }
 
575
 
 
576
        if (attr->encr_data == NULL || attr->iv == NULL) {
 
577
                wpa_printf(MSG_WARNING, "EAP-SIM: Reauthentication "
 
578
                           "message did not include encrypted data");
 
579
                goto fail;
 
580
        }
 
581
 
 
582
        decrypted = eap_sim_parse_encr(data->k_encr, attr->encr_data,
 
583
                                       attr->encr_data_len, attr->iv, &eattr,
 
584
                                       0);
 
585
        if (decrypted == NULL) {
 
586
                wpa_printf(MSG_WARNING, "EAP-SIM: Failed to parse encrypted "
 
587
                           "data from reauthentication message");
 
588
                goto fail;
 
589
        }
 
590
 
 
591
        if (eattr.counter != data->counter) {
 
592
                wpa_printf(MSG_WARNING, "EAP-SIM: Re-authentication message "
 
593
                           "used incorrect counter %u, expected %u",
 
594
                           eattr.counter, data->counter);
 
595
                goto fail;
 
596
        }
 
597
        os_free(decrypted);
 
598
        decrypted = NULL;
 
599
 
 
600
        wpa_printf(MSG_DEBUG, "EAP-SIM: Re-authentication response includes "
 
601
                   "the correct AT_MAC");
 
602
        if (sm->eap_sim_aka_result_ind && attr->result_ind) {
 
603
                data->use_result_ind = 1;
 
604
                data->notification = EAP_SIM_SUCCESS;
 
605
                eap_sim_state(data, NOTIFICATION);
 
606
        } else
 
607
                eap_sim_state(data, SUCCESS);
 
608
 
 
609
        if (data->reauth) {
 
610
                identity = data->reauth->identity;
 
611
                identity_len = data->reauth->identity_len;
 
612
        } else {
 
613
                identity = sm->identity;
 
614
                identity_len = sm->identity_len;
 
615
        }
 
616
 
 
617
        id2 = eap_sim_db_get_permanent(sm->eap_sim_db_priv, identity,
 
618
                                       identity_len, &id2_len);
 
619
        if (id2) {
 
620
                identity = id2;
 
621
                identity_len = id2_len;
 
622
        }
 
623
 
 
624
        if (data->next_pseudonym) {
 
625
                eap_sim_db_add_pseudonym(sm->eap_sim_db_priv, identity,
 
626
                                         identity_len, data->next_pseudonym);
 
627
                data->next_pseudonym = NULL;
 
628
        }
 
629
        if (data->next_reauth_id) {
 
630
                eap_sim_db_add_reauth(sm->eap_sim_db_priv, identity,
 
631
                                      identity_len, data->next_reauth_id,
 
632
                                      data->counter + 1, data->mk);
 
633
                data->next_reauth_id = NULL;
 
634
        } else {
 
635
                eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth);
 
636
                data->reauth = NULL;
 
637
        }
 
638
 
 
639
        return;
 
640
 
 
641
fail:
 
642
        eap_sim_state(data, FAILURE);
 
643
        eap_sim_db_remove_reauth(sm->eap_sim_db_priv, data->reauth);
 
644
        data->reauth = NULL;
 
645
        os_free(decrypted);
 
646
}
 
647
 
 
648
 
 
649
static void eap_sim_process_client_error(struct eap_sm *sm,
 
650
                                         struct eap_sim_data *data,
 
651
                                         struct wpabuf *respData,
 
652
                                         struct eap_sim_attrs *attr)
 
653
{
 
654
        wpa_printf(MSG_DEBUG, "EAP-SIM: Client reported error %d",
 
655
                   attr->client_error_code);
 
656
        if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind)
 
657
                eap_sim_state(data, SUCCESS);
 
658
        else
 
659
                eap_sim_state(data, FAILURE);
 
660
}
 
661
 
 
662
 
 
663
static void eap_sim_process_notification(struct eap_sm *sm,
 
664
                                         struct eap_sim_data *data,
 
665
                                         struct wpabuf *respData,
 
666
                                         struct eap_sim_attrs *attr)
 
667
{
 
668
        wpa_printf(MSG_DEBUG, "EAP-SIM: Client replied to notification");
 
669
        if (data->notification == EAP_SIM_SUCCESS && data->use_result_ind)
 
670
                eap_sim_state(data, SUCCESS);
 
671
        else
 
672
                eap_sim_state(data, FAILURE);
 
673
}
 
674
 
 
675
 
 
676
static void eap_sim_process(struct eap_sm *sm, void *priv,
 
677
                            struct wpabuf *respData)
 
678
{
 
679
        struct eap_sim_data *data = priv;
 
680
        const u8 *pos, *end;
 
681
        u8 subtype;
 
682
        size_t len;
 
683
        struct eap_sim_attrs attr;
 
684
 
 
685
        pos = eap_hdr_validate(EAP_VENDOR_IETF, EAP_TYPE_SIM, respData, &len);
 
686
        if (pos == NULL || len < 3)
 
687
                return;
 
688
 
 
689
        end = pos + len;
 
690
        subtype = *pos;
 
691
        pos += 3;
 
692
 
 
693
        if (eap_sim_parse_attr(pos, end, &attr, 0, 0)) {
 
694
                wpa_printf(MSG_DEBUG, "EAP-SIM: Failed to parse attributes");
 
695
                eap_sim_state(data, FAILURE);
 
696
                return;
 
697
        }
 
698
 
 
699
        if (subtype == EAP_SIM_SUBTYPE_CLIENT_ERROR) {
 
700
                eap_sim_process_client_error(sm, data, respData, &attr);
 
701
                return;
 
702
        }
 
703
 
 
704
        switch (data->state) {
 
705
        case START:
 
706
                eap_sim_process_start(sm, data, respData, &attr);
 
707
                break;
 
708
        case CHALLENGE:
 
709
                eap_sim_process_challenge(sm, data, respData, &attr);
 
710
                break;
 
711
        case REAUTH:
 
712
                eap_sim_process_reauth(sm, data, respData, &attr);
 
713
                break;
 
714
        case NOTIFICATION:
 
715
                eap_sim_process_notification(sm, data, respData, &attr);
 
716
                break;
 
717
        default:
 
718
                wpa_printf(MSG_DEBUG, "EAP-SIM: Unknown state %d in "
 
719
                           "process", data->state);
 
720
                break;
 
721
        }
 
722
}
 
723
 
 
724
 
 
725
static Boolean eap_sim_isDone(struct eap_sm *sm, void *priv)
 
726
{
 
727
        struct eap_sim_data *data = priv;
 
728
        return data->state == SUCCESS || data->state == FAILURE;
 
729
}
 
730
 
 
731
 
 
732
static u8 * eap_sim_getKey(struct eap_sm *sm, void *priv, size_t *len)
 
733
{
 
734
        struct eap_sim_data *data = priv;
 
735
        u8 *key;
 
736
 
 
737
        if (data->state != SUCCESS)
 
738
                return NULL;
 
739
 
 
740
        key = os_malloc(EAP_SIM_KEYING_DATA_LEN);
 
741
        if (key == NULL)
 
742
                return NULL;
 
743
        os_memcpy(key, data->msk, EAP_SIM_KEYING_DATA_LEN);
 
744
        *len = EAP_SIM_KEYING_DATA_LEN;
 
745
        return key;
 
746
}
 
747
 
 
748
 
 
749
static u8 * eap_sim_get_emsk(struct eap_sm *sm, void *priv, size_t *len)
 
750
{
 
751
        struct eap_sim_data *data = priv;
 
752
        u8 *key;
 
753
 
 
754
        if (data->state != SUCCESS)
 
755
                return NULL;
 
756
 
 
757
        key = os_malloc(EAP_EMSK_LEN);
 
758
        if (key == NULL)
 
759
                return NULL;
 
760
        os_memcpy(key, data->emsk, EAP_EMSK_LEN);
 
761
        *len = EAP_EMSK_LEN;
 
762
        return key;
 
763
}
 
764
 
 
765
 
 
766
static Boolean eap_sim_isSuccess(struct eap_sm *sm, void *priv)
 
767
{
 
768
        struct eap_sim_data *data = priv;
 
769
        return data->state == SUCCESS;
 
770
}
 
771
 
 
772
 
 
773
int eap_server_sim_register(void)
 
774
{
 
775
        struct eap_method *eap;
 
776
        int ret;
 
777
 
 
778
        eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
 
779
                                      EAP_VENDOR_IETF, EAP_TYPE_SIM, "SIM");
 
780
        if (eap == NULL)
 
781
                return -1;
 
782
 
 
783
        eap->init = eap_sim_init;
 
784
        eap->reset = eap_sim_reset;
 
785
        eap->buildReq = eap_sim_buildReq;
 
786
        eap->check = eap_sim_check;
 
787
        eap->process = eap_sim_process;
 
788
        eap->isDone = eap_sim_isDone;
 
789
        eap->getKey = eap_sim_getKey;
 
790
        eap->isSuccess = eap_sim_isSuccess;
 
791
        eap->get_emsk = eap_sim_get_emsk;
 
792
 
 
793
        ret = eap_server_method_register(eap);
 
794
        if (ret)
 
795
                eap_server_method_free(eap);
 
796
        return ret;
 
797
}