Branch data Line data Source code
1 : : /*
2 : : * hostapd / EAP-SIM database/authenticator gateway
3 : : * Copyright (c) 2005-2010, 2012, 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 : : * This is an example implementation of the EAP-SIM/AKA database/authentication
9 : : * gateway interface that is using an external program as an SS7 gateway to
10 : : * GSM/UMTS authentication center (HLR/AuC). hlr_auc_gw is an example
11 : : * implementation of such a gateway program. This eap_sim_db.c takes care of
12 : : * EAP-SIM/AKA pseudonyms and re-auth identities. It can be used with different
13 : : * gateway implementations for HLR/AuC access. Alternatively, it can also be
14 : : * completely replaced if the in-memory database of pseudonyms/re-auth
15 : : * identities is not suitable for some cases.
16 : : */
17 : :
18 : : #include "includes.h"
19 : : #include <sys/un.h>
20 : : #ifdef CONFIG_SQLITE
21 : : #include <sqlite3.h>
22 : : #endif /* CONFIG_SQLITE */
23 : :
24 : : #include "common.h"
25 : : #include "crypto/random.h"
26 : : #include "eap_common/eap_sim_common.h"
27 : : #include "eap_server/eap_sim_db.h"
28 : : #include "eloop.h"
29 : :
30 : : struct eap_sim_pseudonym {
31 : : struct eap_sim_pseudonym *next;
32 : : char *permanent; /* permanent username */
33 : : char *pseudonym; /* pseudonym username */
34 : : };
35 : :
36 : : struct eap_sim_db_pending {
37 : : struct eap_sim_db_pending *next;
38 : : char imsi[20];
39 : : enum { PENDING, SUCCESS, FAILURE } state;
40 : : void *cb_session_ctx;
41 : : int aka;
42 : : union {
43 : : struct {
44 : : u8 kc[EAP_SIM_MAX_CHAL][EAP_SIM_KC_LEN];
45 : : u8 sres[EAP_SIM_MAX_CHAL][EAP_SIM_SRES_LEN];
46 : : u8 rand[EAP_SIM_MAX_CHAL][GSM_RAND_LEN];
47 : : int num_chal;
48 : : } sim;
49 : : struct {
50 : : u8 rand[EAP_AKA_RAND_LEN];
51 : : u8 autn[EAP_AKA_AUTN_LEN];
52 : : u8 ik[EAP_AKA_IK_LEN];
53 : : u8 ck[EAP_AKA_CK_LEN];
54 : : u8 res[EAP_AKA_RES_MAX_LEN];
55 : : size_t res_len;
56 : : } aka;
57 : : } u;
58 : : };
59 : :
60 : : struct eap_sim_db_data {
61 : : int sock;
62 : : char *fname;
63 : : char *local_sock;
64 : : void (*get_complete_cb)(void *ctx, void *session_ctx);
65 : : void *ctx;
66 : : struct eap_sim_pseudonym *pseudonyms;
67 : : struct eap_sim_reauth *reauths;
68 : : struct eap_sim_db_pending *pending;
69 : : #ifdef CONFIG_SQLITE
70 : : sqlite3 *sqlite_db;
71 : : char db_tmp_identity[100];
72 : : char db_tmp_pseudonym_str[100];
73 : : struct eap_sim_pseudonym db_tmp_pseudonym;
74 : : struct eap_sim_reauth db_tmp_reauth;
75 : : #endif /* CONFIG_SQLITE */
76 : : };
77 : :
78 : :
79 : : #ifdef CONFIG_SQLITE
80 : :
81 : 0 : static int db_table_exists(sqlite3 *db, const char *name)
82 : : {
83 : : char cmd[128];
84 : 0 : os_snprintf(cmd, sizeof(cmd), "SELECT 1 FROM %s;", name);
85 : 0 : return sqlite3_exec(db, cmd, NULL, NULL, NULL) == SQLITE_OK;
86 : : }
87 : :
88 : :
89 : 0 : static int db_table_create_pseudonym(sqlite3 *db)
90 : : {
91 : 0 : char *err = NULL;
92 : 0 : const char *sql =
93 : : "CREATE TABLE pseudonyms("
94 : : " permanent CHAR(21) PRIMARY KEY,"
95 : : " pseudonym CHAR(21) NOT NULL"
96 : : ");";
97 : :
98 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Adding database table for "
99 : : "pseudonym information");
100 [ # # ]: 0 : if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) {
101 : 0 : wpa_printf(MSG_ERROR, "EAP-SIM DB: SQLite error: %s", err);
102 : 0 : sqlite3_free(err);
103 : 0 : return -1;
104 : : }
105 : :
106 : 0 : return 0;
107 : : }
108 : :
109 : :
110 : 0 : static int db_table_create_reauth(sqlite3 *db)
111 : : {
112 : 0 : char *err = NULL;
113 : 0 : const char *sql =
114 : : "CREATE TABLE reauth("
115 : : " permanent CHAR(21) PRIMARY KEY,"
116 : : " reauth_id CHAR(21) NOT NULL,"
117 : : " counter INTEGER,"
118 : : " mk CHAR(40),"
119 : : " k_encr CHAR(32),"
120 : : " k_aut CHAR(64),"
121 : : " k_re CHAR(64)"
122 : : ");";
123 : :
124 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Adding database table for "
125 : : "reauth information");
126 [ # # ]: 0 : if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) {
127 : 0 : wpa_printf(MSG_ERROR, "EAP-SIM DB: SQLite error: %s", err);
128 : 0 : sqlite3_free(err);
129 : 0 : return -1;
130 : : }
131 : :
132 : 0 : return 0;
133 : : }
134 : :
135 : :
136 : 0 : static sqlite3 * db_open(const char *db_file)
137 : : {
138 : : sqlite3 *db;
139 : :
140 [ # # ]: 0 : if (sqlite3_open(db_file, &db)) {
141 : 0 : wpa_printf(MSG_ERROR, "EAP-SIM DB: Failed to open database "
142 : : "%s: %s", db_file, sqlite3_errmsg(db));
143 : 0 : sqlite3_close(db);
144 : 0 : return NULL;
145 : : }
146 : :
147 [ # # # # ]: 0 : if (!db_table_exists(db, "pseudonyms") &&
148 : 0 : db_table_create_pseudonym(db) < 0) {
149 : 0 : sqlite3_close(db);
150 : 0 : return NULL;
151 : : }
152 : :
153 [ # # # # ]: 0 : if (!db_table_exists(db, "reauth") &&
154 : 0 : db_table_create_reauth(db) < 0) {
155 : 0 : sqlite3_close(db);
156 : 0 : return NULL;
157 : : }
158 : :
159 : 0 : return db;
160 : : }
161 : :
162 : :
163 : 0 : static int valid_db_string(const char *str)
164 : : {
165 : 0 : const char *pos = str;
166 [ # # ]: 0 : while (*pos) {
167 [ # # ][ # # ]: 0 : if ((*pos < '0' || *pos > '9') &&
[ # # ]
168 [ # # ]: 0 : (*pos < 'a' || *pos > 'f'))
169 : 0 : return 0;
170 : 0 : pos++;
171 : : }
172 : 0 : return 1;
173 : : }
174 : :
175 : :
176 : 0 : static int db_add_pseudonym(struct eap_sim_db_data *data,
177 : : const char *permanent, char *pseudonym)
178 : : {
179 : : char cmd[128];
180 : 0 : char *err = NULL;
181 : :
182 [ # # ][ # # ]: 0 : if (!valid_db_string(permanent) || !valid_db_string(pseudonym)) {
183 : 0 : os_free(pseudonym);
184 : 0 : return -1;
185 : : }
186 : :
187 : 0 : os_snprintf(cmd, sizeof(cmd), "INSERT OR REPLACE INTO pseudonyms "
188 : : "(permanent, pseudonym) VALUES ('%s', '%s');",
189 : : permanent, pseudonym);
190 : 0 : os_free(pseudonym);
191 [ # # ]: 0 : if (sqlite3_exec(data->sqlite_db, cmd, NULL, NULL, &err) != SQLITE_OK)
192 : : {
193 : 0 : wpa_printf(MSG_ERROR, "EAP-SIM DB: SQLite error: %s", err);
194 : 0 : sqlite3_free(err);
195 : 0 : return -1;
196 : : }
197 : :
198 : 0 : return 0;
199 : : }
200 : :
201 : :
202 : 0 : static int get_pseudonym_cb(void *ctx, int argc, char *argv[], char *col[])
203 : : {
204 : 0 : struct eap_sim_db_data *data = ctx;
205 : : int i;
206 : :
207 [ # # ]: 0 : for (i = 0; i < argc; i++) {
208 [ # # ][ # # ]: 0 : if (os_strcmp(col[i], "permanent") == 0 && argv[i]) {
209 : 0 : os_strlcpy(data->db_tmp_identity, argv[i],
210 : : sizeof(data->db_tmp_identity));
211 : : }
212 : : }
213 : :
214 : 0 : return 0;
215 : : }
216 : :
217 : :
218 : : static char *
219 : 0 : db_get_pseudonym(struct eap_sim_db_data *data, const char *pseudonym)
220 : : {
221 : : char cmd[128];
222 : :
223 [ # # ]: 0 : if (!valid_db_string(pseudonym))
224 : 0 : return NULL;
225 : 0 : os_memset(&data->db_tmp_identity, 0, sizeof(data->db_tmp_identity));
226 : 0 : os_snprintf(cmd, sizeof(cmd),
227 : : "SELECT permanent FROM pseudonyms WHERE pseudonym='%s';",
228 : : pseudonym);
229 [ # # ]: 0 : if (sqlite3_exec(data->sqlite_db, cmd, get_pseudonym_cb, data, NULL) !=
230 : : SQLITE_OK)
231 : 0 : return NULL;
232 [ # # ]: 0 : if (data->db_tmp_identity[0] == '\0')
233 : 0 : return NULL;
234 : 0 : return data->db_tmp_identity;
235 : : }
236 : :
237 : :
238 : 0 : static int db_add_reauth(struct eap_sim_db_data *data, const char *permanent,
239 : : char *reauth_id, u16 counter, const u8 *mk,
240 : : const u8 *k_encr, const u8 *k_aut, const u8 *k_re)
241 : : {
242 : : char cmd[2000], *pos, *end;
243 : 0 : char *err = NULL;
244 : :
245 [ # # ][ # # ]: 0 : if (!valid_db_string(permanent) || !valid_db_string(reauth_id)) {
246 : 0 : os_free(reauth_id);
247 : 0 : return -1;
248 : : }
249 : :
250 : 0 : pos = cmd;
251 : 0 : end = pos + sizeof(cmd);
252 [ # # ][ # # ]: 0 : pos += os_snprintf(pos, end - pos, "INSERT OR REPLACE INTO reauth "
[ # # ][ # # ]
253 : : "(permanent, reauth_id, counter%s%s%s%s) "
254 : : "VALUES ('%s', '%s', %u",
255 : : mk ? ", mk" : "",
256 : : k_encr ? ", k_encr" : "",
257 : : k_aut ? ", k_aut" : "",
258 : : k_re ? ", k_re" : "",
259 : : permanent, reauth_id, counter);
260 : 0 : os_free(reauth_id);
261 : :
262 [ # # ]: 0 : if (mk) {
263 : 0 : pos += os_snprintf(pos, end - pos, ", '");
264 : 0 : pos += wpa_snprintf_hex(pos, end - pos, mk, EAP_SIM_MK_LEN);
265 : 0 : pos += os_snprintf(pos, end - pos, "'");
266 : : }
267 : :
268 [ # # ]: 0 : if (k_encr) {
269 : 0 : pos += os_snprintf(pos, end - pos, ", '");
270 : 0 : pos += wpa_snprintf_hex(pos, end - pos, k_encr,
271 : : EAP_SIM_K_ENCR_LEN);
272 : 0 : pos += os_snprintf(pos, end - pos, "'");
273 : : }
274 : :
275 [ # # ]: 0 : if (k_aut) {
276 : 0 : pos += os_snprintf(pos, end - pos, ", '");
277 : 0 : pos += wpa_snprintf_hex(pos, end - pos, k_aut,
278 : : EAP_AKA_PRIME_K_AUT_LEN);
279 : 0 : pos += os_snprintf(pos, end - pos, "'");
280 : : }
281 : :
282 [ # # ]: 0 : if (k_re) {
283 : 0 : pos += os_snprintf(pos, end - pos, ", '");
284 : 0 : pos += wpa_snprintf_hex(pos, end - pos, k_re,
285 : : EAP_AKA_PRIME_K_RE_LEN);
286 : 0 : pos += os_snprintf(pos, end - pos, "'");
287 : : }
288 : :
289 : 0 : os_snprintf(pos, end - pos, ");");
290 : :
291 [ # # ]: 0 : if (sqlite3_exec(data->sqlite_db, cmd, NULL, NULL, &err) != SQLITE_OK)
292 : : {
293 : 0 : wpa_printf(MSG_ERROR, "EAP-SIM DB: SQLite error: %s", err);
294 : 0 : sqlite3_free(err);
295 : 0 : return -1;
296 : : }
297 : :
298 : 0 : return 0;
299 : : }
300 : :
301 : :
302 : 0 : static int get_reauth_cb(void *ctx, int argc, char *argv[], char *col[])
303 : : {
304 : 0 : struct eap_sim_db_data *data = ctx;
305 : : int i;
306 : 0 : struct eap_sim_reauth *reauth = &data->db_tmp_reauth;
307 : :
308 [ # # ]: 0 : for (i = 0; i < argc; i++) {
309 [ # # ][ # # ]: 0 : if (os_strcmp(col[i], "permanent") == 0 && argv[i]) {
310 : 0 : os_strlcpy(data->db_tmp_identity, argv[i],
311 : : sizeof(data->db_tmp_identity));
312 : 0 : reauth->permanent = data->db_tmp_identity;
313 [ # # ][ # # ]: 0 : } else if (os_strcmp(col[i], "counter") == 0 && argv[i]) {
314 : 0 : reauth->counter = atoi(argv[i]);
315 [ # # ][ # # ]: 0 : } else if (os_strcmp(col[i], "mk") == 0 && argv[i]) {
316 : 0 : hexstr2bin(argv[i], reauth->mk, sizeof(reauth->mk));
317 [ # # ][ # # ]: 0 : } else if (os_strcmp(col[i], "k_encr") == 0 && argv[i]) {
318 : 0 : hexstr2bin(argv[i], reauth->k_encr,
319 : : sizeof(reauth->k_encr));
320 [ # # ][ # # ]: 0 : } else if (os_strcmp(col[i], "k_aut") == 0 && argv[i]) {
321 : 0 : hexstr2bin(argv[i], reauth->k_aut,
322 : : sizeof(reauth->k_aut));
323 [ # # ][ # # ]: 0 : } else if (os_strcmp(col[i], "k_re") == 0 && argv[i]) {
324 : 0 : hexstr2bin(argv[i], reauth->k_re,
325 : : sizeof(reauth->k_re));
326 : : }
327 : : }
328 : :
329 : 0 : return 0;
330 : : }
331 : :
332 : :
333 : : static struct eap_sim_reauth *
334 : 0 : db_get_reauth(struct eap_sim_db_data *data, const char *reauth_id)
335 : : {
336 : : char cmd[256];
337 : :
338 [ # # ]: 0 : if (!valid_db_string(reauth_id))
339 : 0 : return NULL;
340 : 0 : os_memset(&data->db_tmp_reauth, 0, sizeof(data->db_tmp_reauth));
341 : 0 : os_strlcpy(data->db_tmp_pseudonym_str, reauth_id,
342 : : sizeof(data->db_tmp_pseudonym_str));
343 : 0 : data->db_tmp_reauth.reauth_id = data->db_tmp_pseudonym_str;
344 : 0 : os_snprintf(cmd, sizeof(cmd),
345 : : "SELECT * FROM reauth WHERE reauth_id='%s';", reauth_id);
346 [ # # ]: 0 : if (sqlite3_exec(data->sqlite_db, cmd, get_reauth_cb, data, NULL) !=
347 : : SQLITE_OK)
348 : 0 : return NULL;
349 [ # # ]: 0 : if (data->db_tmp_reauth.permanent == NULL)
350 : 0 : return NULL;
351 : 0 : return &data->db_tmp_reauth;
352 : : }
353 : :
354 : :
355 : 0 : static void db_remove_reauth(struct eap_sim_db_data *data,
356 : : struct eap_sim_reauth *reauth)
357 : : {
358 : : char cmd[256];
359 : :
360 [ # # ]: 0 : if (!valid_db_string(reauth->permanent))
361 : 0 : return;
362 : 0 : os_snprintf(cmd, sizeof(cmd),
363 : : "DELETE FROM reauth WHERE permanent='%s';",
364 : : reauth->permanent);
365 : 0 : sqlite3_exec(data->sqlite_db, cmd, NULL, NULL, NULL);
366 : : }
367 : :
368 : : #endif /* CONFIG_SQLITE */
369 : :
370 : :
371 : : static struct eap_sim_db_pending *
372 : 27 : eap_sim_db_get_pending(struct eap_sim_db_data *data, const char *imsi, int aka)
373 : : {
374 : 27 : struct eap_sim_db_pending *entry, *prev = NULL;
375 : :
376 : 27 : entry = data->pending;
377 [ + + ]: 27 : while (entry) {
378 [ + - ][ + - ]: 18 : if (entry->aka == aka && os_strcmp(entry->imsi, imsi) == 0) {
379 [ - + ]: 18 : if (prev)
380 : 0 : prev->next = entry->next;
381 : : else
382 : 18 : data->pending = entry->next;
383 : 18 : break;
384 : : }
385 : 0 : prev = entry;
386 : 0 : entry = entry->next;
387 : : }
388 : 27 : return entry;
389 : : }
390 : :
391 : :
392 : 18 : static void eap_sim_db_add_pending(struct eap_sim_db_data *data,
393 : : struct eap_sim_db_pending *entry)
394 : : {
395 : 18 : entry->next = data->pending;
396 : 18 : data->pending = entry;
397 : 18 : }
398 : :
399 : :
400 : 4 : static void eap_sim_db_sim_resp_auth(struct eap_sim_db_data *data,
401 : : const char *imsi, char *buf)
402 : : {
403 : : char *start, *end, *pos;
404 : : struct eap_sim_db_pending *entry;
405 : : int num_chal;
406 : :
407 : : /*
408 : : * SIM-RESP-AUTH <IMSI> Kc(i):SRES(i):RAND(i) ...
409 : : * SIM-RESP-AUTH <IMSI> FAILURE
410 : : * (IMSI = ASCII string, Kc/SRES/RAND = hex string)
411 : : */
412 : :
413 : 4 : entry = eap_sim_db_get_pending(data, imsi, 0);
414 [ - + ]: 4 : if (entry == NULL) {
415 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: No pending entry for the "
416 : : "received message found");
417 : 0 : return;
418 : : }
419 : :
420 : 4 : start = buf;
421 [ - + ]: 4 : if (os_strncmp(start, "FAILURE", 7) == 0) {
422 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: External server reported "
423 : : "failure");
424 : 0 : entry->state = FAILURE;
425 : 0 : eap_sim_db_add_pending(data, entry);
426 : 0 : data->get_complete_cb(data->ctx, entry->cb_session_ctx);
427 : 0 : return;
428 : : }
429 : :
430 : 4 : num_chal = 0;
431 [ + - ]: 12 : while (num_chal < EAP_SIM_MAX_CHAL) {
432 : 12 : end = os_strchr(start, ' ');
433 [ + + ]: 12 : if (end)
434 : 8 : *end = '\0';
435 : :
436 : 12 : pos = os_strchr(start, ':');
437 [ - + ]: 12 : if (pos == NULL)
438 : 0 : goto parse_fail;
439 : 12 : *pos = '\0';
440 [ - + ]: 12 : if (hexstr2bin(start, entry->u.sim.kc[num_chal],
441 : : EAP_SIM_KC_LEN))
442 : 0 : goto parse_fail;
443 : :
444 : 12 : start = pos + 1;
445 : 12 : pos = os_strchr(start, ':');
446 [ - + ]: 12 : if (pos == NULL)
447 : 0 : goto parse_fail;
448 : 12 : *pos = '\0';
449 [ - + ]: 12 : if (hexstr2bin(start, entry->u.sim.sres[num_chal],
450 : : EAP_SIM_SRES_LEN))
451 : 0 : goto parse_fail;
452 : :
453 : 12 : start = pos + 1;
454 [ - + ]: 12 : if (hexstr2bin(start, entry->u.sim.rand[num_chal],
455 : : GSM_RAND_LEN))
456 : 0 : goto parse_fail;
457 : :
458 : 12 : num_chal++;
459 [ + + ]: 12 : if (end == NULL)
460 : 4 : break;
461 : : else
462 : 8 : start = end + 1;
463 : : }
464 : 4 : entry->u.sim.num_chal = num_chal;
465 : :
466 : 4 : entry->state = SUCCESS;
467 : 4 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Authentication data parsed "
468 : : "successfully - callback");
469 : 4 : eap_sim_db_add_pending(data, entry);
470 : 4 : data->get_complete_cb(data->ctx, entry->cb_session_ctx);
471 : 4 : return;
472 : :
473 : : parse_fail:
474 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failed to parse response string");
475 : 4 : os_free(entry);
476 : : }
477 : :
478 : :
479 : 5 : static void eap_sim_db_aka_resp_auth(struct eap_sim_db_data *data,
480 : : const char *imsi, char *buf)
481 : : {
482 : : char *start, *end;
483 : : struct eap_sim_db_pending *entry;
484 : :
485 : : /*
486 : : * AKA-RESP-AUTH <IMSI> <RAND> <AUTN> <IK> <CK> <RES>
487 : : * AKA-RESP-AUTH <IMSI> FAILURE
488 : : * (IMSI = ASCII string, RAND/AUTN/IK/CK/RES = hex string)
489 : : */
490 : :
491 : 5 : entry = eap_sim_db_get_pending(data, imsi, 1);
492 [ - + ]: 5 : if (entry == NULL) {
493 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: No pending entry for the "
494 : : "received message found");
495 : 0 : return;
496 : : }
497 : :
498 : 5 : start = buf;
499 [ - + ]: 5 : if (os_strncmp(start, "FAILURE", 7) == 0) {
500 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: External server reported "
501 : : "failure");
502 : 0 : entry->state = FAILURE;
503 : 0 : eap_sim_db_add_pending(data, entry);
504 : 0 : data->get_complete_cb(data->ctx, entry->cb_session_ctx);
505 : 0 : return;
506 : : }
507 : :
508 : 5 : end = os_strchr(start, ' ');
509 [ - + ]: 5 : if (end == NULL)
510 : 0 : goto parse_fail;
511 : 5 : *end = '\0';
512 [ - + ]: 5 : if (hexstr2bin(start, entry->u.aka.rand, EAP_AKA_RAND_LEN))
513 : 0 : goto parse_fail;
514 : :
515 : 5 : start = end + 1;
516 : 5 : end = os_strchr(start, ' ');
517 [ - + ]: 5 : if (end == NULL)
518 : 0 : goto parse_fail;
519 : 5 : *end = '\0';
520 [ - + ]: 5 : if (hexstr2bin(start, entry->u.aka.autn, EAP_AKA_AUTN_LEN))
521 : 0 : goto parse_fail;
522 : :
523 : 5 : start = end + 1;
524 : 5 : end = os_strchr(start, ' ');
525 [ - + ]: 5 : if (end == NULL)
526 : 0 : goto parse_fail;
527 : 5 : *end = '\0';
528 [ - + ]: 5 : if (hexstr2bin(start, entry->u.aka.ik, EAP_AKA_IK_LEN))
529 : 0 : goto parse_fail;
530 : :
531 : 5 : start = end + 1;
532 : 5 : end = os_strchr(start, ' ');
533 [ - + ]: 5 : if (end == NULL)
534 : 0 : goto parse_fail;
535 : 5 : *end = '\0';
536 [ - + ]: 5 : if (hexstr2bin(start, entry->u.aka.ck, EAP_AKA_CK_LEN))
537 : 0 : goto parse_fail;
538 : :
539 : 5 : start = end + 1;
540 : 5 : end = os_strchr(start, ' ');
541 [ - + ]: 5 : if (end)
542 : 0 : *end = '\0';
543 : : else {
544 : 5 : end = start;
545 [ + + ]: 85 : while (*end)
546 : 80 : end++;
547 : : }
548 : 5 : entry->u.aka.res_len = (end - start) / 2;
549 [ - + ]: 5 : if (entry->u.aka.res_len > EAP_AKA_RES_MAX_LEN) {
550 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Too long RES");
551 : 0 : entry->u.aka.res_len = 0;
552 : 0 : goto parse_fail;
553 : : }
554 [ - + ]: 5 : if (hexstr2bin(start, entry->u.aka.res, entry->u.aka.res_len))
555 : 0 : goto parse_fail;
556 : :
557 : 5 : entry->state = SUCCESS;
558 : 5 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Authentication data parsed "
559 : : "successfully - callback");
560 : 5 : eap_sim_db_add_pending(data, entry);
561 : 5 : data->get_complete_cb(data->ctx, entry->cb_session_ctx);
562 : 5 : return;
563 : :
564 : : parse_fail:
565 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failed to parse response string");
566 : 5 : os_free(entry);
567 : : }
568 : :
569 : :
570 : 9 : static void eap_sim_db_receive(int sock, void *eloop_ctx, void *sock_ctx)
571 : : {
572 : 9 : struct eap_sim_db_data *data = eloop_ctx;
573 : : char buf[1000], *pos, *cmd, *imsi;
574 : : int res;
575 : :
576 : 9 : res = recv(sock, buf, sizeof(buf), 0);
577 [ - + ]: 9 : if (res < 0)
578 : 0 : return;
579 : 9 : wpa_hexdump_ascii_key(MSG_MSGDUMP, "EAP-SIM DB: Received from an "
580 : : "external source", (u8 *) buf, res);
581 [ - + ]: 9 : if (res == 0)
582 : 0 : return;
583 [ - + ]: 9 : if (res >= (int) sizeof(buf))
584 : 0 : res = sizeof(buf) - 1;
585 : 9 : buf[res] = '\0';
586 : :
587 [ - + ]: 9 : if (data->get_complete_cb == NULL) {
588 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: No get_complete_cb "
589 : : "registered");
590 : 0 : return;
591 : : }
592 : :
593 : : /* <cmd> <IMSI> ... */
594 : :
595 : 9 : cmd = buf;
596 : 9 : pos = os_strchr(cmd, ' ');
597 [ - + ]: 9 : if (pos == NULL)
598 : 0 : goto parse_fail;
599 : 9 : *pos = '\0';
600 : 9 : imsi = pos + 1;
601 : 9 : pos = os_strchr(imsi, ' ');
602 [ - + ]: 9 : if (pos == NULL)
603 : 0 : goto parse_fail;
604 : 9 : *pos = '\0';
605 : 9 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: External response=%s for IMSI %s",
606 : : cmd, imsi);
607 : :
608 [ + + ]: 9 : if (os_strcmp(cmd, "SIM-RESP-AUTH") == 0)
609 : 4 : eap_sim_db_sim_resp_auth(data, imsi, pos + 1);
610 [ + - ]: 5 : else if (os_strcmp(cmd, "AKA-RESP-AUTH") == 0)
611 : 5 : eap_sim_db_aka_resp_auth(data, imsi, pos + 1);
612 : : else
613 : 0 : wpa_printf(MSG_INFO, "EAP-SIM DB: Unknown external response "
614 : : "'%s'", cmd);
615 : 9 : return;
616 : :
617 : : parse_fail:
618 : 9 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failed to parse response string");
619 : : }
620 : :
621 : :
622 : 1 : static int eap_sim_db_open_socket(struct eap_sim_db_data *data)
623 : : {
624 : : struct sockaddr_un addr;
625 : : static int counter = 0;
626 : :
627 [ - + ]: 1 : if (os_strncmp(data->fname, "unix:", 5) != 0)
628 : 0 : return -1;
629 : :
630 : 1 : data->sock = socket(PF_UNIX, SOCK_DGRAM, 0);
631 [ - + ]: 1 : if (data->sock < 0) {
632 : 0 : wpa_printf(MSG_INFO, "socket(eap_sim_db): %s", strerror(errno));
633 : 0 : return -1;
634 : : }
635 : :
636 : 1 : os_memset(&addr, 0, sizeof(addr));
637 : 1 : addr.sun_family = AF_UNIX;
638 : 1 : os_snprintf(addr.sun_path, sizeof(addr.sun_path),
639 : : "/tmp/eap_sim_db_%d-%d", getpid(), counter++);
640 : 1 : os_free(data->local_sock);
641 : 1 : data->local_sock = os_strdup(addr.sun_path);
642 [ - + ]: 1 : if (bind(data->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
643 : 0 : wpa_printf(MSG_INFO, "bind(eap_sim_db): %s", strerror(errno));
644 : 0 : close(data->sock);
645 : 0 : data->sock = -1;
646 : 0 : return -1;
647 : : }
648 : :
649 : 1 : os_memset(&addr, 0, sizeof(addr));
650 : 1 : addr.sun_family = AF_UNIX;
651 : 1 : os_strlcpy(addr.sun_path, data->fname + 5, sizeof(addr.sun_path));
652 [ - + ]: 1 : if (connect(data->sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
653 : 0 : wpa_printf(MSG_INFO, "connect(eap_sim_db): %s",
654 : 0 : strerror(errno));
655 : 0 : wpa_hexdump_ascii(MSG_INFO, "HLR/AuC GW socket",
656 : : (u8 *) addr.sun_path,
657 : : os_strlen(addr.sun_path));
658 : 0 : close(data->sock);
659 : 0 : data->sock = -1;
660 : 0 : return -1;
661 : : }
662 : :
663 : 1 : eloop_register_read_sock(data->sock, eap_sim_db_receive, data, NULL);
664 : :
665 : 1 : return 0;
666 : : }
667 : :
668 : :
669 : 1 : static void eap_sim_db_close_socket(struct eap_sim_db_data *data)
670 : : {
671 [ + - ]: 1 : if (data->sock >= 0) {
672 : 1 : eloop_unregister_read_sock(data->sock);
673 : 1 : close(data->sock);
674 : 1 : data->sock = -1;
675 : : }
676 [ + - ]: 1 : if (data->local_sock) {
677 : 1 : unlink(data->local_sock);
678 : 1 : os_free(data->local_sock);
679 : 1 : data->local_sock = NULL;
680 : : }
681 : 1 : }
682 : :
683 : :
684 : : /**
685 : : * eap_sim_db_init - Initialize EAP-SIM DB / authentication gateway interface
686 : : * @config: Configuration data (e.g., file name)
687 : : * @get_complete_cb: Callback function for reporting availability of triplets
688 : : * @ctx: Context pointer for get_complete_cb
689 : : * Returns: Pointer to a private data structure or %NULL on failure
690 : : */
691 : : struct eap_sim_db_data *
692 : 1 : eap_sim_db_init(const char *config,
693 : : void (*get_complete_cb)(void *ctx, void *session_ctx),
694 : : void *ctx)
695 : : {
696 : : struct eap_sim_db_data *data;
697 : : char *pos;
698 : :
699 : 1 : data = os_zalloc(sizeof(*data));
700 [ - + ]: 1 : if (data == NULL)
701 : 0 : return NULL;
702 : :
703 : 1 : data->sock = -1;
704 : 1 : data->get_complete_cb = get_complete_cb;
705 : 1 : data->ctx = ctx;
706 : 1 : data->fname = os_strdup(config);
707 [ - + ]: 1 : if (data->fname == NULL)
708 : 0 : goto fail;
709 : 1 : pos = os_strstr(data->fname, " db=");
710 [ - + ]: 1 : if (pos) {
711 : 0 : *pos = '\0';
712 : : #ifdef CONFIG_SQLITE
713 : 0 : pos += 4;
714 : 0 : data->sqlite_db = db_open(pos);
715 [ # # ]: 0 : if (data->sqlite_db == NULL)
716 : 0 : goto fail;
717 : : #endif /* CONFIG_SQLITE */
718 : : }
719 : :
720 [ + - ]: 1 : if (os_strncmp(data->fname, "unix:", 5) == 0) {
721 [ - + ]: 1 : if (eap_sim_db_open_socket(data)) {
722 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: External database "
723 : : "connection not available - will retry "
724 : : "later");
725 : : }
726 : : }
727 : :
728 : 1 : return data;
729 : :
730 : : fail:
731 : 0 : eap_sim_db_close_socket(data);
732 : 0 : os_free(data->fname);
733 : 0 : os_free(data);
734 : 1 : return NULL;
735 : : }
736 : :
737 : :
738 : 5 : static void eap_sim_db_free_pseudonym(struct eap_sim_pseudonym *p)
739 : : {
740 : 5 : os_free(p->permanent);
741 : 5 : os_free(p->pseudonym);
742 : 5 : os_free(p);
743 : 5 : }
744 : :
745 : :
746 : 5 : static void eap_sim_db_free_reauth(struct eap_sim_reauth *r)
747 : : {
748 : 5 : os_free(r->permanent);
749 : 5 : os_free(r->reauth_id);
750 : 5 : os_free(r);
751 : 5 : }
752 : :
753 : :
754 : : /**
755 : : * eap_sim_db_deinit - Deinitialize EAP-SIM DB/authentication gw interface
756 : : * @priv: Private data pointer from eap_sim_db_init()
757 : : */
758 : 1 : void eap_sim_db_deinit(void *priv)
759 : : {
760 : 1 : struct eap_sim_db_data *data = priv;
761 : : struct eap_sim_pseudonym *p, *prev;
762 : : struct eap_sim_reauth *r, *prevr;
763 : : struct eap_sim_db_pending *pending, *prev_pending;
764 : :
765 : : #ifdef CONFIG_SQLITE
766 [ - + ]: 1 : if (data->sqlite_db) {
767 : 0 : sqlite3_close(data->sqlite_db);
768 : 0 : data->sqlite_db = NULL;
769 : : }
770 : : #endif /* CONFIG_SQLITE */
771 : :
772 : 1 : eap_sim_db_close_socket(data);
773 : 1 : os_free(data->fname);
774 : :
775 : 1 : p = data->pseudonyms;
776 [ + + ]: 6 : while (p) {
777 : 5 : prev = p;
778 : 5 : p = p->next;
779 : 5 : eap_sim_db_free_pseudonym(prev);
780 : : }
781 : :
782 : 1 : r = data->reauths;
783 [ + + ]: 6 : while (r) {
784 : 5 : prevr = r;
785 : 5 : r = r->next;
786 : 5 : eap_sim_db_free_reauth(prevr);
787 : : }
788 : :
789 : 1 : pending = data->pending;
790 [ - + ]: 1 : while (pending) {
791 : 0 : prev_pending = pending;
792 : 0 : pending = pending->next;
793 : 0 : os_free(prev_pending);
794 : : }
795 : :
796 : 1 : os_free(data);
797 : 1 : }
798 : :
799 : :
800 : 10 : static int eap_sim_db_send(struct eap_sim_db_data *data, const char *msg,
801 : : size_t len)
802 : : {
803 : 10 : int _errno = 0;
804 : :
805 [ - + ]: 10 : if (send(data->sock, msg, len, 0) < 0) {
806 : 0 : _errno = errno;
807 : 0 : wpa_printf(MSG_INFO, "send[EAP-SIM DB UNIX]: %s",
808 : 0 : strerror(errno));
809 : : }
810 : :
811 [ + - ][ + - ]: 10 : if (_errno == ENOTCONN || _errno == EDESTADDRREQ || _errno == EINVAL ||
[ + - ][ - + ]
812 : : _errno == ECONNREFUSED) {
813 : : /* Try to reconnect */
814 : 0 : eap_sim_db_close_socket(data);
815 [ # # ]: 0 : if (eap_sim_db_open_socket(data) < 0)
816 : 0 : return -1;
817 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Reconnected to the "
818 : : "external server");
819 [ # # ]: 0 : if (send(data->sock, msg, len, 0) < 0) {
820 : 0 : wpa_printf(MSG_INFO, "send[EAP-SIM DB UNIX]: %s",
821 : 0 : strerror(errno));
822 : 0 : return -1;
823 : : }
824 : : }
825 : :
826 : 10 : return 0;
827 : : }
828 : :
829 : :
830 : 9 : static void eap_sim_db_expire_pending(struct eap_sim_db_data *data)
831 : : {
832 : : /* TODO: add limit for maximum length for pending list; remove latest
833 : : * (i.e., last) entry from the list if the limit is reached; could also
834 : : * use timeout to expire pending entries */
835 : 9 : }
836 : :
837 : :
838 : : /**
839 : : * eap_sim_db_get_gsm_triplets - Get GSM triplets
840 : : * @data: Private data pointer from eap_sim_db_init()
841 : : * @username: Permanent username (prefix | IMSI)
842 : : * @max_chal: Maximum number of triplets
843 : : * @_rand: Buffer for RAND values
844 : : * @kc: Buffer for Kc values
845 : : * @sres: Buffer for SRES values
846 : : * @cb_session_ctx: Session callback context for get_complete_cb()
847 : : * Returns: Number of triplets received (has to be less than or equal to
848 : : * max_chal), -1 (EAP_SIM_DB_FAILURE) on error (e.g., user not found), or
849 : : * -2 (EAP_SIM_DB_PENDING) if results are not yet available. In this case, the
850 : : * callback function registered with eap_sim_db_init() will be called once the
851 : : * results become available.
852 : : *
853 : : * When using an external server for GSM triplets, this function can always
854 : : * start a request and return EAP_SIM_DB_PENDING immediately if authentication
855 : : * triplets are not available. Once the triplets are received, callback
856 : : * function registered with eap_sim_db_init() is called to notify EAP state
857 : : * machine to reprocess the message. This eap_sim_db_get_gsm_triplets()
858 : : * function will then be called again and the newly received triplets will then
859 : : * be given to the caller.
860 : : */
861 : 8 : int eap_sim_db_get_gsm_triplets(struct eap_sim_db_data *data,
862 : : const char *username, int max_chal,
863 : : u8 *_rand, u8 *kc, u8 *sres,
864 : : void *cb_session_ctx)
865 : : {
866 : : struct eap_sim_db_pending *entry;
867 : : int len, ret;
868 : : char msg[40];
869 : : const char *imsi;
870 : : size_t imsi_len;
871 : :
872 [ + - ][ + - ]: 8 : if (username == NULL || username[0] != EAP_SIM_PERMANENT_PREFIX ||
[ + - ]
873 [ - + ]: 8 : username[1] == '\0' || os_strlen(username) > sizeof(entry->imsi)) {
874 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: unexpected username '%s'",
875 : : username);
876 : 0 : return EAP_SIM_DB_FAILURE;
877 : : }
878 : 8 : imsi = username + 1;
879 : 8 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Get GSM triplets for IMSI '%s'",
880 : : imsi);
881 : :
882 : 8 : entry = eap_sim_db_get_pending(data, imsi, 0);
883 [ + + ]: 8 : if (entry) {
884 : : int num_chal;
885 [ - + ]: 4 : if (entry->state == FAILURE) {
886 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
887 : : "failure");
888 : 0 : os_free(entry);
889 : 0 : return EAP_SIM_DB_FAILURE;
890 : : }
891 : :
892 [ - + ]: 4 : if (entry->state == PENDING) {
893 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
894 : : "still pending");
895 : 0 : eap_sim_db_add_pending(data, entry);
896 : 0 : return EAP_SIM_DB_PENDING;
897 : : }
898 : :
899 : 4 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending entry -> "
900 : : "%d challenges", entry->u.sim.num_chal);
901 : 4 : num_chal = entry->u.sim.num_chal;
902 [ - + ]: 4 : if (num_chal > max_chal)
903 : 0 : num_chal = max_chal;
904 : 4 : os_memcpy(_rand, entry->u.sim.rand, num_chal * GSM_RAND_LEN);
905 : 4 : os_memcpy(sres, entry->u.sim.sres,
906 : : num_chal * EAP_SIM_SRES_LEN);
907 : 4 : os_memcpy(kc, entry->u.sim.kc, num_chal * EAP_SIM_KC_LEN);
908 : 4 : os_free(entry);
909 : 4 : return num_chal;
910 : : }
911 : :
912 [ - + ]: 4 : if (data->sock < 0) {
913 [ # # ]: 0 : if (eap_sim_db_open_socket(data) < 0)
914 : 0 : return EAP_SIM_DB_FAILURE;
915 : : }
916 : :
917 : 4 : imsi_len = os_strlen(imsi);
918 : 4 : len = os_snprintf(msg, sizeof(msg), "SIM-REQ-AUTH ");
919 [ + - ][ - + ]: 4 : if (len < 0 || len + imsi_len >= sizeof(msg))
920 : 0 : return EAP_SIM_DB_FAILURE;
921 : 4 : os_memcpy(msg + len, imsi, imsi_len);
922 : 4 : len += imsi_len;
923 : 4 : ret = os_snprintf(msg + len, sizeof(msg) - len, " %d", max_chal);
924 [ + - ][ - + ]: 4 : if (ret < 0 || (size_t) ret >= sizeof(msg) - len)
925 : 0 : return EAP_SIM_DB_FAILURE;
926 : 4 : len += ret;
927 : :
928 : 4 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: requesting SIM authentication "
929 : : "data for IMSI '%s'", imsi);
930 [ - + ]: 4 : if (eap_sim_db_send(data, msg, len) < 0)
931 : 0 : return EAP_SIM_DB_FAILURE;
932 : :
933 : 4 : entry = os_zalloc(sizeof(*entry));
934 [ - + ]: 4 : if (entry == NULL)
935 : 0 : return EAP_SIM_DB_FAILURE;
936 : :
937 : 4 : os_strlcpy(entry->imsi, imsi, sizeof(entry->imsi));
938 : 4 : entry->cb_session_ctx = cb_session_ctx;
939 : 4 : entry->state = PENDING;
940 : 4 : eap_sim_db_add_pending(data, entry);
941 : 4 : eap_sim_db_expire_pending(data);
942 : :
943 : 8 : return EAP_SIM_DB_PENDING;
944 : : }
945 : :
946 : :
947 : 21 : static char * eap_sim_db_get_next(struct eap_sim_db_data *data, char prefix)
948 : : {
949 : : char *id, *pos, *end;
950 : : u8 buf[10];
951 : :
952 [ - + ]: 21 : if (random_get_bytes(buf, sizeof(buf)))
953 : 0 : return NULL;
954 : 21 : id = os_malloc(sizeof(buf) * 2 + 2);
955 [ - + ]: 21 : if (id == NULL)
956 : 0 : return NULL;
957 : :
958 : 21 : pos = id;
959 : 21 : end = id + sizeof(buf) * 2 + 2;
960 : 21 : *pos++ = prefix;
961 : 21 : pos += wpa_snprintf_hex(pos, end - pos, buf, sizeof(buf));
962 : :
963 : 21 : return id;
964 : : }
965 : :
966 : :
967 : : /**
968 : : * eap_sim_db_get_next_pseudonym - EAP-SIM DB: Get next pseudonym
969 : : * @data: Private data pointer from eap_sim_db_init()
970 : : * @method: EAP method (SIM/AKA/AKA')
971 : : * Returns: Next pseudonym (allocated string) or %NULL on failure
972 : : *
973 : : * This function is used to generate a pseudonym for EAP-SIM. The returned
974 : : * pseudonym is not added to database at this point; it will need to be added
975 : : * with eap_sim_db_add_pseudonym() once the authentication has been completed
976 : : * successfully. Caller is responsible for freeing the returned buffer.
977 : : */
978 : 9 : char * eap_sim_db_get_next_pseudonym(struct eap_sim_db_data *data,
979 : : enum eap_sim_db_method method)
980 : : {
981 : 9 : char prefix = EAP_SIM_REAUTH_ID_PREFIX;
982 : :
983 [ + + + - ]: 9 : switch (method) {
984 : : case EAP_SIM_DB_SIM:
985 : 4 : prefix = EAP_SIM_PSEUDONYM_PREFIX;
986 : 4 : break;
987 : : case EAP_SIM_DB_AKA:
988 : 3 : prefix = EAP_AKA_PSEUDONYM_PREFIX;
989 : 3 : break;
990 : : case EAP_SIM_DB_AKA_PRIME:
991 : 2 : prefix = EAP_AKA_PRIME_PSEUDONYM_PREFIX;
992 : 2 : break;
993 : : }
994 : :
995 : 9 : return eap_sim_db_get_next(data, prefix);
996 : : }
997 : :
998 : :
999 : : /**
1000 : : * eap_sim_db_get_next_reauth_id - EAP-SIM DB: Get next reauth_id
1001 : : * @data: Private data pointer from eap_sim_db_init()
1002 : : * @method: EAP method (SIM/AKA/AKA')
1003 : : * Returns: Next reauth_id (allocated string) or %NULL on failure
1004 : : *
1005 : : * This function is used to generate a fast re-authentication identity for
1006 : : * EAP-SIM. The returned reauth_id is not added to database at this point; it
1007 : : * will need to be added with eap_sim_db_add_reauth() once the authentication
1008 : : * has been completed successfully. Caller is responsible for freeing the
1009 : : * returned buffer.
1010 : : */
1011 : 12 : char * eap_sim_db_get_next_reauth_id(struct eap_sim_db_data *data,
1012 : : enum eap_sim_db_method method)
1013 : : {
1014 : 12 : char prefix = EAP_SIM_REAUTH_ID_PREFIX;
1015 : :
1016 [ + + + - ]: 12 : switch (method) {
1017 : : case EAP_SIM_DB_SIM:
1018 : 5 : prefix = EAP_SIM_REAUTH_ID_PREFIX;
1019 : 5 : break;
1020 : : case EAP_SIM_DB_AKA:
1021 : 4 : prefix = EAP_AKA_REAUTH_ID_PREFIX;
1022 : 4 : break;
1023 : : case EAP_SIM_DB_AKA_PRIME:
1024 : 3 : prefix = EAP_AKA_PRIME_REAUTH_ID_PREFIX;
1025 : 3 : break;
1026 : : }
1027 : :
1028 : 12 : return eap_sim_db_get_next(data, prefix);
1029 : : }
1030 : :
1031 : :
1032 : : /**
1033 : : * eap_sim_db_add_pseudonym - EAP-SIM DB: Add new pseudonym
1034 : : * @data: Private data pointer from eap_sim_db_init()
1035 : : * @permanent: Permanent username
1036 : : * @pseudonym: Pseudonym for this user. This needs to be an allocated buffer,
1037 : : * e.g., return value from eap_sim_db_get_next_pseudonym(). Caller must not
1038 : : * free it.
1039 : : * Returns: 0 on success, -1 on failure
1040 : : *
1041 : : * This function adds a new pseudonym for EAP-SIM user. EAP-SIM DB is
1042 : : * responsible of freeing pseudonym buffer once it is not needed anymore.
1043 : : */
1044 : 8 : int eap_sim_db_add_pseudonym(struct eap_sim_db_data *data,
1045 : : const char *permanent, char *pseudonym)
1046 : : {
1047 : : struct eap_sim_pseudonym *p;
1048 : 8 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Add pseudonym '%s' for permanent "
1049 : : "username '%s'", pseudonym, permanent);
1050 : :
1051 : : /* TODO: could store last two pseudonyms */
1052 : : #ifdef CONFIG_SQLITE
1053 [ - + ]: 8 : if (data->sqlite_db)
1054 : 0 : return db_add_pseudonym(data, permanent, pseudonym);
1055 : : #endif /* CONFIG_SQLITE */
1056 [ + + ]: 23 : for (p = data->pseudonyms; p; p = p->next) {
1057 [ + + ]: 18 : if (os_strcmp(permanent, p->permanent) == 0)
1058 : 3 : break;
1059 : : }
1060 [ + + ]: 8 : if (p) {
1061 : 3 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Replacing previous "
1062 : : "pseudonym: %s", p->pseudonym);
1063 : 3 : os_free(p->pseudonym);
1064 : 3 : p->pseudonym = pseudonym;
1065 : 3 : return 0;
1066 : : }
1067 : :
1068 : 5 : p = os_zalloc(sizeof(*p));
1069 [ - + ]: 5 : if (p == NULL) {
1070 : 0 : os_free(pseudonym);
1071 : 0 : return -1;
1072 : : }
1073 : :
1074 : 5 : p->next = data->pseudonyms;
1075 : 5 : p->permanent = os_strdup(permanent);
1076 [ - + ]: 5 : if (p->permanent == NULL) {
1077 : 0 : os_free(p);
1078 : 0 : os_free(pseudonym);
1079 : 0 : return -1;
1080 : : }
1081 : 5 : p->pseudonym = pseudonym;
1082 : 5 : data->pseudonyms = p;
1083 : :
1084 : 5 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Added new pseudonym entry");
1085 : 8 : return 0;
1086 : : }
1087 : :
1088 : :
1089 : : static struct eap_sim_reauth *
1090 : 11 : eap_sim_db_add_reauth_data(struct eap_sim_db_data *data,
1091 : : const char *permanent,
1092 : : char *reauth_id, u16 counter)
1093 : : {
1094 : : struct eap_sim_reauth *r;
1095 : :
1096 [ + + ]: 31 : for (r = data->reauths; r; r = r->next) {
1097 [ + + ]: 26 : if (os_strcmp(r->permanent, permanent) == 0)
1098 : 6 : break;
1099 : : }
1100 : :
1101 [ + + ]: 11 : if (r) {
1102 : 6 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Replacing previous "
1103 : : "reauth_id: %s", r->reauth_id);
1104 : 6 : os_free(r->reauth_id);
1105 : 6 : r->reauth_id = reauth_id;
1106 : : } else {
1107 : 5 : r = os_zalloc(sizeof(*r));
1108 [ - + ]: 5 : if (r == NULL) {
1109 : 0 : os_free(reauth_id);
1110 : 0 : return NULL;
1111 : : }
1112 : :
1113 : 5 : r->next = data->reauths;
1114 : 5 : r->permanent = os_strdup(permanent);
1115 [ - + ]: 5 : if (r->permanent == NULL) {
1116 : 0 : os_free(r);
1117 : 0 : os_free(reauth_id);
1118 : 0 : return NULL;
1119 : : }
1120 : 5 : r->reauth_id = reauth_id;
1121 : 5 : data->reauths = r;
1122 : 5 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Added new reauth entry");
1123 : : }
1124 : :
1125 : 11 : r->counter = counter;
1126 : :
1127 : 11 : return r;
1128 : : }
1129 : :
1130 : :
1131 : : /**
1132 : : * eap_sim_db_add_reauth - EAP-SIM DB: Add new re-authentication entry
1133 : : * @priv: Private data pointer from eap_sim_db_init()
1134 : : * @permanent: Permanent username
1135 : : * @identity_len: Length of identity
1136 : : * @reauth_id: reauth_id for this user. This needs to be an allocated buffer,
1137 : : * e.g., return value from eap_sim_db_get_next_reauth_id(). Caller must not
1138 : : * free it.
1139 : : * @counter: AT_COUNTER value for fast re-authentication
1140 : : * @mk: 16-byte MK from the previous full authentication or %NULL
1141 : : * Returns: 0 on success, -1 on failure
1142 : : *
1143 : : * This function adds a new re-authentication entry for an EAP-SIM user.
1144 : : * EAP-SIM DB is responsible of freeing reauth_id buffer once it is not needed
1145 : : * anymore.
1146 : : */
1147 : 8 : int eap_sim_db_add_reauth(struct eap_sim_db_data *data, const char *permanent,
1148 : : char *reauth_id, u16 counter, const u8 *mk)
1149 : : {
1150 : : struct eap_sim_reauth *r;
1151 : :
1152 : 8 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Add reauth_id '%s' for permanent "
1153 : : "identity '%s'", reauth_id, permanent);
1154 : :
1155 : : #ifdef CONFIG_SQLITE
1156 [ - + ]: 8 : if (data->sqlite_db)
1157 : 0 : return db_add_reauth(data, permanent, reauth_id, counter, mk,
1158 : : NULL, NULL, NULL);
1159 : : #endif /* CONFIG_SQLITE */
1160 : 8 : r = eap_sim_db_add_reauth_data(data, permanent, reauth_id, counter);
1161 [ - + ]: 8 : if (r == NULL)
1162 : 0 : return -1;
1163 : :
1164 : 8 : os_memcpy(r->mk, mk, EAP_SIM_MK_LEN);
1165 : :
1166 : 8 : return 0;
1167 : : }
1168 : :
1169 : :
1170 : : #ifdef EAP_SERVER_AKA_PRIME
1171 : : /**
1172 : : * eap_sim_db_add_reauth_prime - EAP-AKA' DB: Add new re-authentication entry
1173 : : * @data: Private data pointer from eap_sim_db_init()
1174 : : * @permanent: Permanent username
1175 : : * @reauth_id: reauth_id for this user. This needs to be an allocated buffer,
1176 : : * e.g., return value from eap_sim_db_get_next_reauth_id(). Caller must not
1177 : : * free it.
1178 : : * @counter: AT_COUNTER value for fast re-authentication
1179 : : * @k_encr: K_encr from the previous full authentication
1180 : : * @k_aut: K_aut from the previous full authentication
1181 : : * @k_re: 32-byte K_re from the previous full authentication
1182 : : * Returns: 0 on success, -1 on failure
1183 : : *
1184 : : * This function adds a new re-authentication entry for an EAP-AKA' user.
1185 : : * EAP-SIM DB is responsible of freeing reauth_id buffer once it is not needed
1186 : : * anymore.
1187 : : */
1188 : 3 : int eap_sim_db_add_reauth_prime(struct eap_sim_db_data *data,
1189 : : const char *permanent, char *reauth_id,
1190 : : u16 counter, const u8 *k_encr,
1191 : : const u8 *k_aut, const u8 *k_re)
1192 : : {
1193 : : struct eap_sim_reauth *r;
1194 : :
1195 : 3 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Add reauth_id '%s' for permanent "
1196 : : "identity '%s'", reauth_id, permanent);
1197 : :
1198 : : #ifdef CONFIG_SQLITE
1199 [ - + ]: 3 : if (data->sqlite_db)
1200 : 0 : return db_add_reauth(data, permanent, reauth_id, counter, NULL,
1201 : : k_encr, k_aut, k_re);
1202 : : #endif /* CONFIG_SQLITE */
1203 : 3 : r = eap_sim_db_add_reauth_data(data, permanent, reauth_id, counter);
1204 [ - + ]: 3 : if (r == NULL)
1205 : 0 : return -1;
1206 : :
1207 : 3 : os_memcpy(r->k_encr, k_encr, EAP_SIM_K_ENCR_LEN);
1208 : 3 : os_memcpy(r->k_aut, k_aut, EAP_AKA_PRIME_K_AUT_LEN);
1209 : 3 : os_memcpy(r->k_re, k_re, EAP_AKA_PRIME_K_RE_LEN);
1210 : :
1211 : 3 : return 0;
1212 : : }
1213 : : #endif /* EAP_SERVER_AKA_PRIME */
1214 : :
1215 : :
1216 : : /**
1217 : : * eap_sim_db_get_permanent - EAP-SIM DB: Get permanent identity
1218 : : * @data: Private data pointer from eap_sim_db_init()
1219 : : * @pseudonym: Pseudonym username
1220 : : * Returns: Pointer to permanent username or %NULL if not found
1221 : : */
1222 : : const char *
1223 : 0 : eap_sim_db_get_permanent(struct eap_sim_db_data *data, const char *pseudonym)
1224 : : {
1225 : : struct eap_sim_pseudonym *p;
1226 : :
1227 : : #ifdef CONFIG_SQLITE
1228 [ # # ]: 0 : if (data->sqlite_db)
1229 : 0 : return db_get_pseudonym(data, pseudonym);
1230 : : #endif /* CONFIG_SQLITE */
1231 : :
1232 : 0 : p = data->pseudonyms;
1233 [ # # ]: 0 : while (p) {
1234 [ # # ]: 0 : if (os_strcmp(p->pseudonym, pseudonym) == 0)
1235 : 0 : return p->permanent;
1236 : 0 : p = p->next;
1237 : : }
1238 : :
1239 : 0 : return NULL;
1240 : : }
1241 : :
1242 : :
1243 : : /**
1244 : : * eap_sim_db_get_reauth_entry - EAP-SIM DB: Get re-authentication entry
1245 : : * @data: Private data pointer from eap_sim_db_init()
1246 : : * @reauth_id: Fast re-authentication username
1247 : : * Returns: Pointer to the re-auth entry, or %NULL if not found
1248 : : */
1249 : : struct eap_sim_reauth *
1250 : 3 : eap_sim_db_get_reauth_entry(struct eap_sim_db_data *data,
1251 : : const char *reauth_id)
1252 : : {
1253 : : struct eap_sim_reauth *r;
1254 : :
1255 : : #ifdef CONFIG_SQLITE
1256 [ - + ]: 3 : if (data->sqlite_db)
1257 : 0 : return db_get_reauth(data, reauth_id);
1258 : : #endif /* CONFIG_SQLITE */
1259 : :
1260 : 3 : r = data->reauths;
1261 [ + - ]: 8 : while (r) {
1262 [ + + ]: 8 : if (os_strcmp(r->reauth_id, reauth_id) == 0)
1263 : 3 : break;
1264 : 5 : r = r->next;
1265 : : }
1266 : :
1267 : 3 : return r;
1268 : : }
1269 : :
1270 : :
1271 : : /**
1272 : : * eap_sim_db_remove_reauth - EAP-SIM DB: Remove re-authentication entry
1273 : : * @data: Private data pointer from eap_sim_db_init()
1274 : : * @reauth: Pointer to re-authentication entry from
1275 : : * eap_sim_db_get_reauth_entry()
1276 : : */
1277 : 0 : void eap_sim_db_remove_reauth(struct eap_sim_db_data *data,
1278 : : struct eap_sim_reauth *reauth)
1279 : : {
1280 : 0 : struct eap_sim_reauth *r, *prev = NULL;
1281 : : #ifdef CONFIG_SQLITE
1282 [ # # ]: 0 : if (data->sqlite_db) {
1283 : 0 : db_remove_reauth(data, reauth);
1284 : 0 : return;
1285 : : }
1286 : : #endif /* CONFIG_SQLITE */
1287 : 0 : r = data->reauths;
1288 [ # # ]: 0 : while (r) {
1289 [ # # ]: 0 : if (r == reauth) {
1290 [ # # ]: 0 : if (prev)
1291 : 0 : prev->next = r->next;
1292 : : else
1293 : 0 : data->reauths = r->next;
1294 : 0 : eap_sim_db_free_reauth(r);
1295 : 0 : return;
1296 : : }
1297 : 0 : prev = r;
1298 : 0 : r = r->next;
1299 : : }
1300 : : }
1301 : :
1302 : :
1303 : : /**
1304 : : * eap_sim_db_get_aka_auth - Get AKA authentication values
1305 : : * @data: Private data pointer from eap_sim_db_init()
1306 : : * @username: Permanent username (prefix | IMSI)
1307 : : * @_rand: Buffer for RAND value
1308 : : * @autn: Buffer for AUTN value
1309 : : * @ik: Buffer for IK value
1310 : : * @ck: Buffer for CK value
1311 : : * @res: Buffer for RES value
1312 : : * @res_len: Buffer for RES length
1313 : : * @cb_session_ctx: Session callback context for get_complete_cb()
1314 : : * Returns: 0 on success, -1 (EAP_SIM_DB_FAILURE) on error (e.g., user not
1315 : : * found), or -2 (EAP_SIM_DB_PENDING) if results are not yet available. In this
1316 : : * case, the callback function registered with eap_sim_db_init() will be
1317 : : * called once the results become available.
1318 : : *
1319 : : * When using an external server for AKA authentication, this function can
1320 : : * always start a request and return EAP_SIM_DB_PENDING immediately if
1321 : : * authentication triplets are not available. Once the authentication data are
1322 : : * received, callback function registered with eap_sim_db_init() is called to
1323 : : * notify EAP state machine to reprocess the message. This
1324 : : * eap_sim_db_get_aka_auth() function will then be called again and the newly
1325 : : * received triplets will then be given to the caller.
1326 : : */
1327 : 10 : int eap_sim_db_get_aka_auth(struct eap_sim_db_data *data, const char *username,
1328 : : u8 *_rand, u8 *autn, u8 *ik, u8 *ck,
1329 : : u8 *res, size_t *res_len, void *cb_session_ctx)
1330 : : {
1331 : : struct eap_sim_db_pending *entry;
1332 : : int len;
1333 : : char msg[40];
1334 : : const char *imsi;
1335 : : size_t imsi_len;
1336 : :
1337 [ + - ][ + + ]: 10 : if (username == NULL ||
1338 [ + - ]: 4 : (username[0] != EAP_AKA_PERMANENT_PREFIX &&
1339 [ + - ]: 10 : username[0] != EAP_AKA_PRIME_PERMANENT_PREFIX) ||
1340 [ - + ]: 10 : username[1] == '\0' || os_strlen(username) > sizeof(entry->imsi)) {
1341 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: unexpected username '%s'",
1342 : : username);
1343 : 0 : return EAP_SIM_DB_FAILURE;
1344 : : }
1345 : 10 : imsi = username + 1;
1346 : 10 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Get AKA auth for IMSI '%s'",
1347 : : imsi);
1348 : :
1349 : 10 : entry = eap_sim_db_get_pending(data, imsi, 1);
1350 [ + + ]: 10 : if (entry) {
1351 [ - + ]: 5 : if (entry->state == FAILURE) {
1352 : 0 : os_free(entry);
1353 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Failure");
1354 : 0 : return EAP_SIM_DB_FAILURE;
1355 : : }
1356 : :
1357 [ - + ]: 5 : if (entry->state == PENDING) {
1358 : 0 : eap_sim_db_add_pending(data, entry);
1359 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Pending");
1360 : 0 : return EAP_SIM_DB_PENDING;
1361 : : }
1362 : :
1363 : 5 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Returning successfully "
1364 : : "received authentication data");
1365 : 5 : os_memcpy(_rand, entry->u.aka.rand, EAP_AKA_RAND_LEN);
1366 : 5 : os_memcpy(autn, entry->u.aka.autn, EAP_AKA_AUTN_LEN);
1367 : 5 : os_memcpy(ik, entry->u.aka.ik, EAP_AKA_IK_LEN);
1368 : 5 : os_memcpy(ck, entry->u.aka.ck, EAP_AKA_CK_LEN);
1369 : 5 : os_memcpy(res, entry->u.aka.res, EAP_AKA_RES_MAX_LEN);
1370 : 5 : *res_len = entry->u.aka.res_len;
1371 : 5 : os_free(entry);
1372 : 5 : return 0;
1373 : : }
1374 : :
1375 [ - + ]: 5 : if (data->sock < 0) {
1376 [ # # ]: 0 : if (eap_sim_db_open_socket(data) < 0)
1377 : 0 : return EAP_SIM_DB_FAILURE;
1378 : : }
1379 : :
1380 : 5 : imsi_len = os_strlen(imsi);
1381 : 5 : len = os_snprintf(msg, sizeof(msg), "AKA-REQ-AUTH ");
1382 [ + - ][ - + ]: 5 : if (len < 0 || len + imsi_len >= sizeof(msg))
1383 : 0 : return EAP_SIM_DB_FAILURE;
1384 : 5 : os_memcpy(msg + len, imsi, imsi_len);
1385 : 5 : len += imsi_len;
1386 : :
1387 : 5 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: requesting AKA authentication "
1388 : : "data for IMSI '%s'", imsi);
1389 [ - + ]: 5 : if (eap_sim_db_send(data, msg, len) < 0)
1390 : 0 : return EAP_SIM_DB_FAILURE;
1391 : :
1392 : 5 : entry = os_zalloc(sizeof(*entry));
1393 [ - + ]: 5 : if (entry == NULL)
1394 : 0 : return EAP_SIM_DB_FAILURE;
1395 : :
1396 : 5 : entry->aka = 1;
1397 : 5 : os_strlcpy(entry->imsi, imsi, sizeof(entry->imsi));
1398 : 5 : entry->cb_session_ctx = cb_session_ctx;
1399 : 5 : entry->state = PENDING;
1400 : 5 : eap_sim_db_add_pending(data, entry);
1401 : 5 : eap_sim_db_expire_pending(data);
1402 : :
1403 : 10 : return EAP_SIM_DB_PENDING;
1404 : : }
1405 : :
1406 : :
1407 : : /**
1408 : : * eap_sim_db_resynchronize - Resynchronize AKA AUTN
1409 : : * @data: Private data pointer from eap_sim_db_init()
1410 : : * @username: Permanent username
1411 : : * @auts: AUTS value from the peer
1412 : : * @_rand: RAND value used in the rejected message
1413 : : * Returns: 0 on success, -1 on failure
1414 : : *
1415 : : * This function is called when the peer reports synchronization failure in the
1416 : : * AUTN value by sending AUTS. The AUTS and RAND values should be sent to
1417 : : * HLR/AuC to allow it to resynchronize with the peer. After this,
1418 : : * eap_sim_db_get_aka_auth() will be called again to to fetch updated
1419 : : * RAND/AUTN values for the next challenge.
1420 : : */
1421 : 1 : int eap_sim_db_resynchronize(struct eap_sim_db_data *data,
1422 : : const char *username,
1423 : : const u8 *auts, const u8 *_rand)
1424 : : {
1425 : : const char *imsi;
1426 : : size_t imsi_len;
1427 : :
1428 [ + - ][ - + ]: 1 : if (username == NULL ||
1429 [ # # ]: 0 : (username[0] != EAP_AKA_PERMANENT_PREFIX &&
1430 [ + - ]: 1 : username[0] != EAP_AKA_PRIME_PERMANENT_PREFIX) ||
1431 [ - + ]: 1 : username[1] == '\0' || os_strlen(username) > 20) {
1432 : 0 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: unexpected username '%s'",
1433 : : username);
1434 : 0 : return -1;
1435 : : }
1436 : 1 : imsi = username + 1;
1437 : 1 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: Get AKA auth for IMSI '%s'",
1438 : : imsi);
1439 : :
1440 [ + - ]: 1 : if (data->sock >= 0) {
1441 : : char msg[100];
1442 : : int len, ret;
1443 : :
1444 : 1 : imsi_len = os_strlen(imsi);
1445 : 1 : len = os_snprintf(msg, sizeof(msg), "AKA-AUTS ");
1446 [ + - ][ - + ]: 1 : if (len < 0 || len + imsi_len >= sizeof(msg))
1447 : 0 : return -1;
1448 : 1 : os_memcpy(msg + len, imsi, imsi_len);
1449 : 1 : len += imsi_len;
1450 : :
1451 : 1 : ret = os_snprintf(msg + len, sizeof(msg) - len, " ");
1452 [ + - ][ - + ]: 1 : if (ret < 0 || (size_t) ret >= sizeof(msg) - len)
1453 : 0 : return -1;
1454 : 1 : len += ret;
1455 : 1 : len += wpa_snprintf_hex(msg + len, sizeof(msg) - len,
1456 : : auts, EAP_AKA_AUTS_LEN);
1457 : 1 : ret = os_snprintf(msg + len, sizeof(msg) - len, " ");
1458 [ - + ][ + - ]: 1 : if (ret < 0 || (size_t) ret >= sizeof(msg) - len)
1459 : 0 : return -1;
1460 : 1 : len += ret;
1461 : 1 : len += wpa_snprintf_hex(msg + len, sizeof(msg) - len,
1462 : : _rand, EAP_AKA_RAND_LEN);
1463 : 1 : wpa_printf(MSG_DEBUG, "EAP-SIM DB: reporting AKA AUTS for "
1464 : : "IMSI '%s'", imsi);
1465 [ - + ]: 1 : if (eap_sim_db_send(data, msg, len) < 0)
1466 : 0 : return -1;
1467 : : }
1468 : :
1469 : 1 : return 0;
1470 : : }
1471 : :
1472 : :
1473 : : /**
1474 : : * sim_get_username - Extract username from SIM identity
1475 : : * @identity: Identity
1476 : : * @identity_len: Identity length
1477 : : * Returns: Allocated buffer with the username part of the identity
1478 : : *
1479 : : * Caller is responsible for freeing the returned buffer with os_free().
1480 : : */
1481 : 23 : char * sim_get_username(const u8 *identity, size_t identity_len)
1482 : : {
1483 : : size_t pos;
1484 : :
1485 [ - + ]: 23 : if (identity == NULL)
1486 : 0 : return NULL;
1487 : :
1488 [ + + ]: 406 : for (pos = 0; pos < identity_len; pos++) {
1489 [ + + ][ + - ]: 395 : if (identity[pos] == '@' || identity[pos] == '\0')
1490 : : break;
1491 : : }
1492 : :
1493 : 23 : return dup_binstr(identity, pos);
1494 : : }
|
