?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nl80211: Fix a typo
[hostap-gosc2009.git] / src / utils / pcsc_funcs.c
blobbf9f04a719b1d17f4ea95141871bb56edc8d1dd5
1 /*
2 * WPA Supplicant / PC/SC smartcard interface for USIM, GSM SIM
3 * Copyright (c) 2004-2007, 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 * This file implements wrapper functions for accessing GSM SIM and 3GPP USIM
15 * cards through PC/SC smartcard library. These functions are used to implement
16 * authentication routines for EAP-SIM and EAP-AKA.
17 */
18
19 #include "includes.h"
20 #include <winscard.h>
21
22 #include "common.h"
23 #include "pcsc_funcs.h"
24
25
26 /* See ETSI GSM 11.11 and ETSI TS 102 221 for details.
27 * SIM commands:
28 * Command APDU: CLA INS P1 P2 P3 Data
29 * CLA (class of instruction): A0 for GSM, 00 for USIM
30 * INS (instruction)
31 * P1 P2 P3 (parameters, P3 = length of Data)
32 * Response APDU: Data SW1 SW2
33 * SW1 SW2 (Status words)
34 * Commands (INS P1 P2 P3):
35 * SELECT: A4 00 00 02 <file_id, 2 bytes>
36 * GET RESPONSE: C0 00 00 <len>
37 * RUN GSM ALG: 88 00 00 00 <RAND len = 10>
38 * RUN UMTS ALG: 88 00 81 <len=0x22> data: 0x10 | RAND | 0x10 | AUTN
39 * P1 = ID of alg in card
40 * P2 = ID of secret key
41 * READ BINARY: B0 <offset high> <offset low> <len>
42 * READ RECORD: B2 <record number> <mode> <len>
43 * P2 (mode) = '02' (next record), '03' (previous record),
44 * '04' (absolute mode)
45 * VERIFY CHV: 20 00 <CHV number> 08
46 * CHANGE CHV: 24 00 <CHV number> 10
47 * DISABLE CHV: 26 00 01 08
48 * ENABLE CHV: 28 00 01 08
49 * UNBLOCK CHV: 2C 00 <00=CHV1, 02=CHV2> 10
50 * SLEEP: FA 00 00 00
51 */
52
53 /* GSM SIM commands */
54 #define SIM_CMD_SELECT 0xa0, 0xa4, 0x00, 0x00, 0x02
55 #define SIM_CMD_RUN_GSM_ALG 0xa0, 0x88, 0x00, 0x00, 0x10
56 #define SIM_CMD_GET_RESPONSE 0xa0, 0xc0, 0x00, 0x00
57 #define SIM_CMD_READ_BIN 0xa0, 0xb0, 0x00, 0x00
58 #define SIM_CMD_READ_RECORD 0xa0, 0xb2, 0x00, 0x00
59 #define SIM_CMD_VERIFY_CHV1 0xa0, 0x20, 0x00, 0x01, 0x08
60
61 /* USIM commands */
62 #define USIM_CLA 0x00
63 #define USIM_CMD_RUN_UMTS_ALG 0x00, 0x88, 0x00, 0x81, 0x22
64 #define USIM_CMD_GET_RESPONSE 0x00, 0xc0, 0x00, 0x00
65
66 #define SIM_RECORD_MODE_ABSOLUTE 0x04
67
68 #define USIM_FSP_TEMPL_TAG 0x62
69
70 #define USIM_TLV_FILE_DESC 0x82
71 #define USIM_TLV_FILE_ID 0x83
72 #define USIM_TLV_DF_NAME 0x84
73 #define USIM_TLV_PROPR_INFO 0xA5
74 #define USIM_TLV_LIFE_CYCLE_STATUS 0x8A
75 #define USIM_TLV_FILE_SIZE 0x80
76 #define USIM_TLV_TOTAL_FILE_SIZE 0x81
77 #define USIM_TLV_PIN_STATUS_TEMPLATE 0xC6
78 #define USIM_TLV_SHORT_FILE_ID 0x88
79
80 #define USIM_PS_DO_TAG 0x90
81
82 #define AKA_RAND_LEN 16
83 #define AKA_AUTN_LEN 16
84 #define AKA_AUTS_LEN 14
85 #define RES_MAX_LEN 16
86 #define IK_LEN 16
87 #define CK_LEN 16
88
89
90 typedef enum { SCARD_GSM_SIM, SCARD_USIM } sim_types;
91
92 struct scard_data {
93 SCARDCONTEXT ctx;
94 SCARDHANDLE card;
95 DWORD protocol;
96 sim_types sim_type;
97 int pin1_required;
98 };
99
100 #ifdef __MINGW32_VERSION
101 /* MinGW does not yet support WinScard, so load the needed functions
102 * dynamically from winscard.dll for now. */
103
104 static HINSTANCE dll = NULL; /* winscard.dll */
105
106 static const SCARD_IO_REQUEST *dll_g_rgSCardT0Pci, *dll_g_rgSCardT1Pci;
107 #undef SCARD_PCI_T0
108 #define SCARD_PCI_T0 (dll_g_rgSCardT0Pci)
109 #undef SCARD_PCI_T1
110 #define SCARD_PCI_T1 (dll_g_rgSCardT1Pci)
111
112
113 static WINSCARDAPI LONG WINAPI
114 (*dll_SCardEstablishContext)(IN DWORD dwScope,
115 IN LPCVOID pvReserved1,
116 IN LPCVOID pvReserved2,
117 OUT LPSCARDCONTEXT phContext);
118 #define SCardEstablishContext dll_SCardEstablishContext
119
120 static long (*dll_SCardReleaseContext)(long hContext);
121 #define SCardReleaseContext dll_SCardReleaseContext
122
123 static WINSCARDAPI LONG WINAPI
124 (*dll_SCardListReadersA)(IN SCARDCONTEXT hContext,
125 IN LPCSTR mszGroups,
126 OUT LPSTR mszReaders,
127 IN OUT LPDWORD pcchReaders);
128 #undef SCardListReaders
129 #define SCardListReaders dll_SCardListReadersA
130
131 static WINSCARDAPI LONG WINAPI
132 (*dll_SCardConnectA)(IN SCARDCONTEXT hContext,
133 IN LPCSTR szReader,
134 IN DWORD dwShareMode,
135 IN DWORD dwPreferredProtocols,
136 OUT LPSCARDHANDLE phCard,
137 OUT LPDWORD pdwActiveProtocol);
138 #undef SCardConnect
139 #define SCardConnect dll_SCardConnectA
140
141 static WINSCARDAPI LONG WINAPI
142 (*dll_SCardDisconnect)(IN SCARDHANDLE hCard,
143 IN DWORD dwDisposition);
144 #define SCardDisconnect dll_SCardDisconnect
145
146 static WINSCARDAPI LONG WINAPI
147 (*dll_SCardTransmit)(IN SCARDHANDLE hCard,
148 IN LPCSCARD_IO_REQUEST pioSendPci,
149 IN LPCBYTE pbSendBuffer,
150 IN DWORD cbSendLength,
151 IN OUT LPSCARD_IO_REQUEST pioRecvPci,
152 OUT LPBYTE pbRecvBuffer,
153 IN OUT LPDWORD pcbRecvLength);
154 #define SCardTransmit dll_SCardTransmit
155
156 static WINSCARDAPI LONG WINAPI
157 (*dll_SCardBeginTransaction)(IN SCARDHANDLE hCard);
158 #define SCardBeginTransaction dll_SCardBeginTransaction
159
160 static WINSCARDAPI LONG WINAPI
161 (*dll_SCardEndTransaction)(IN SCARDHANDLE hCard, IN DWORD dwDisposition);
162 #define SCardEndTransaction dll_SCardEndTransaction
163
164
165 static int mingw_load_symbols(void)
166 {
167 char *sym;
168
169 if (dll)
170 return 0;
171
172 dll = LoadLibrary("winscard");
173 if (dll == NULL) {
174 wpa_printf(MSG_DEBUG, "WinSCard: Could not load winscard.dll "
175 "library");
176 return -1;
177 }
178
179 #define LOADSYM(s) \
180 sym = #s; \
181 dll_ ## s = (void *) GetProcAddress(dll, sym); \
182 if (dll_ ## s == NULL) \
183 goto fail;
184
185 LOADSYM(SCardEstablishContext);
186 LOADSYM(SCardReleaseContext);
187 LOADSYM(SCardListReadersA);
188 LOADSYM(SCardConnectA);
189 LOADSYM(SCardDisconnect);
190 LOADSYM(SCardTransmit);
191 LOADSYM(SCardBeginTransaction);
192 LOADSYM(SCardEndTransaction);
193 LOADSYM(g_rgSCardT0Pci);
194 LOADSYM(g_rgSCardT1Pci);
195
196 #undef LOADSYM
197
198 return 0;
199
200 fail:
201 wpa_printf(MSG_DEBUG, "WinSCard: Could not get address for %s from "
202 "winscard.dll", sym);
203 FreeLibrary(dll);
204 dll = NULL;
205 return -1;
206 }
207
208
209 static void mingw_unload_symbols(void)
210 {
211 if (dll == NULL)
212 return;
213
214 FreeLibrary(dll);
215 dll = NULL;
216 }
217
218 #else /* __MINGW32_VERSION */
219
220 #define mingw_load_symbols() 0
221 #define mingw_unload_symbols() do { } while (0)
222
223 #endif /* __MINGW32_VERSION */
224
225
226 static int _scard_select_file(struct scard_data *scard, unsigned short file_id,
227 unsigned char *buf, size_t *buf_len,
228 sim_types sim_type, unsigned char *aid,
229 size_t aidlen);
230 static int scard_select_file(struct scard_data *scard, unsigned short file_id,
231 unsigned char *buf, size_t *buf_len);
232 static int scard_verify_pin(struct scard_data *scard, const char *pin);
233 static int scard_get_record_len(struct scard_data *scard,
234 unsigned char recnum, unsigned char mode);
235 static int scard_read_record(struct scard_data *scard,
236 unsigned char *data, size_t len,
237 unsigned char recnum, unsigned char mode);
238
239
240 static int scard_parse_fsp_templ(unsigned char *buf, size_t buf_len,
241 int *ps_do, int *file_len)
242 {
243 unsigned char *pos, *end;
244
245 if (ps_do)
246 *ps_do = -1;
247 if (file_len)
248 *file_len = -1;
249
250 pos = buf;
251 end = pos + buf_len;
252 if (*pos != USIM_FSP_TEMPL_TAG) {
253 wpa_printf(MSG_DEBUG, "SCARD: file header did not "
254 "start with FSP template tag");
255 return -1;
256 }
257 pos++;
258 if (pos >= end)
259 return -1;
260 if ((pos + pos[0]) < end)
261 end = pos + 1 + pos[0];
262 pos++;
263 wpa_hexdump(MSG_DEBUG, "SCARD: file header FSP template",
264 pos, end - pos);
265
266 while (pos + 1 < end) {
267 wpa_printf(MSG_MSGDUMP, "SCARD: file header TLV "
268 "0x%02x len=%d", pos[0], pos[1]);
269 if (pos + 2 + pos[1] > end)
270 break;
271
272 if (pos[0] == USIM_TLV_FILE_SIZE &&
273 (pos[1] == 1 || pos[1] == 2) && file_len) {
274 if (pos[1] == 1)
275 *file_len = (int) pos[2];
276 else
277 *file_len = ((int) pos[2] << 8) |
278 (int) pos[3];
279 wpa_printf(MSG_DEBUG, "SCARD: file_size=%d",
280 *file_len);
281 }
282
283 if (pos[0] == USIM_TLV_PIN_STATUS_TEMPLATE &&
284 pos[1] >= 2 && pos[2] == USIM_PS_DO_TAG &&
285 pos[3] >= 1 && ps_do) {
286 wpa_printf(MSG_DEBUG, "SCARD: PS_DO=0x%02x",
287 pos[4]);
288 *ps_do = (int) pos[4];
289 }
290
291 pos += 2 + pos[1];
292
293 if (pos == end)
294 return 0;
295 }
296 return -1;
297 }
298
299
300 static int scard_pin_needed(struct scard_data *scard,
301 unsigned char *hdr, size_t hlen)
302 {
303 if (scard->sim_type == SCARD_GSM_SIM) {
304 if (hlen > SCARD_CHV1_OFFSET &&
305 !(hdr[SCARD_CHV1_OFFSET] & SCARD_CHV1_FLAG))
306 return 1;
307 return 0;
308 }
309
310 if (scard->sim_type == SCARD_USIM) {
311 int ps_do;
312 if (scard_parse_fsp_templ(hdr, hlen, &ps_do, NULL))
313 return -1;
314 /* TODO: there could be more than one PS_DO entry because of
315 * multiple PINs in key reference.. */
316 if (ps_do > 0 && (ps_do & 0x80))
317 return 1;
318 return 0;
319 }
320
321 return -1;
322 }
323
324
325 static int scard_get_aid(struct scard_data *scard, unsigned char *aid,
326 size_t maxlen)
327 {
328 int rlen, rec;
329 struct efdir {
330 unsigned char appl_template_tag; /* 0x61 */
331 unsigned char appl_template_len;
332 unsigned char appl_id_tag; /* 0x4f */
333 unsigned char aid_len;
334 unsigned char rid[5];
335 unsigned char appl_code[2]; /* 0x1002 for 3G USIM */
336 } *efdir;
337 unsigned char buf[100];
338 size_t blen;
339
340 efdir = (struct efdir *) buf;
341 blen = sizeof(buf);
342 if (scard_select_file(scard, SCARD_FILE_EF_DIR, buf, &blen)) {
343 wpa_printf(MSG_DEBUG, "SCARD: Failed to read EF_DIR");
344 return -1;
345 }
346 wpa_hexdump(MSG_DEBUG, "SCARD: EF_DIR select", buf, blen);
347
348 for (rec = 1; rec < 10; rec++) {
349 rlen = scard_get_record_len(scard, rec,
350 SIM_RECORD_MODE_ABSOLUTE);
351 if (rlen < 0) {
352 wpa_printf(MSG_DEBUG, "SCARD: Failed to get EF_DIR "
353 "record length");
354 return -1;
355 }
356 blen = sizeof(buf);
357 if (rlen > (int) blen) {
358 wpa_printf(MSG_DEBUG, "SCARD: Too long EF_DIR record");
359 return -1;
360 }
361 if (scard_read_record(scard, buf, rlen, rec,
362 SIM_RECORD_MODE_ABSOLUTE) < 0) {
363 wpa_printf(MSG_DEBUG, "SCARD: Failed to read "
364 "EF_DIR record %d", rec);
365 return -1;
366 }
367 wpa_hexdump(MSG_DEBUG, "SCARD: EF_DIR record", buf, rlen);
368
369 if (efdir->appl_template_tag != 0x61) {
370 wpa_printf(MSG_DEBUG, "SCARD: Unexpected application "
371 "template tag 0x%x",
372 efdir->appl_template_tag);
373 continue;
374 }
375
376 if (efdir->appl_template_len > rlen - 2) {
377 wpa_printf(MSG_DEBUG, "SCARD: Too long application "
378 "template (len=%d rlen=%d)",
379 efdir->appl_template_len, rlen);
380 continue;
381 }
382
383 if (efdir->appl_id_tag != 0x4f) {
384 wpa_printf(MSG_DEBUG, "SCARD: Unexpected application "
385 "identifier tag 0x%x", efdir->appl_id_tag);
386 continue;
387 }
388
389 if (efdir->aid_len < 1 || efdir->aid_len > 16) {
390 wpa_printf(MSG_DEBUG, "SCARD: Invalid AID length %d",
391 efdir->aid_len);
392 continue;
393 }
394
395 wpa_hexdump(MSG_DEBUG, "SCARD: AID from EF_DIR record",
396 efdir->rid, efdir->aid_len);
397
398 if (efdir->appl_code[0] == 0x10 &&
399 efdir->appl_code[1] == 0x02) {
400 wpa_printf(MSG_DEBUG, "SCARD: 3G USIM app found from "
401 "EF_DIR record %d", rec);
402 break;
403 }
404 }
405
406 if (rec >= 10) {
407 wpa_printf(MSG_DEBUG, "SCARD: 3G USIM app not found "
408 "from EF_DIR records");
409 return -1;
410 }
411
412 if (efdir->aid_len > maxlen) {
413 wpa_printf(MSG_DEBUG, "SCARD: Too long AID");
414 return -1;
415 }
416
417 os_memcpy(aid, efdir->rid, efdir->aid_len);
418
419 return efdir->aid_len;
420 }
421
422
423 /**
424 * scard_init - Initialize SIM/USIM connection using PC/SC
425 * @sim_type: Allowed SIM types (SIM, USIM, or both)
426 * Returns: Pointer to private data structure, or %NULL on failure
427 *
428 * This function is used to initialize SIM/USIM connection. PC/SC is used to
429 * open connection to the SIM/USIM card and the card is verified to support the
430 * selected sim_type. In addition, local flag is set if a PIN is needed to
431 * access some of the card functions. Once the connection is not needed
432 * anymore, scard_deinit() can be used to close it.
433 */
434 struct scard_data * scard_init(scard_sim_type sim_type)
435 {
436 long ret;
437 unsigned long len;
438 struct scard_data *scard;
439 #ifdef CONFIG_NATIVE_WINDOWS
440 TCHAR *readers = NULL;
441 #else /* CONFIG_NATIVE_WINDOWS */
442 char *readers = NULL;
443 #endif /* CONFIG_NATIVE_WINDOWS */
444 unsigned char buf[100];
445 size_t blen;
446 int transaction = 0;
447 int pin_needed;
448
449 wpa_printf(MSG_DEBUG, "SCARD: initializing smart card interface");
450 if (mingw_load_symbols())
451 return NULL;
452 scard = os_zalloc(sizeof(*scard));
453 if (scard == NULL)
454 return NULL;
455
456 ret = SCardEstablishContext(SCARD_SCOPE_SYSTEM, NULL, NULL,
457 &scard->ctx);
458 if (ret != SCARD_S_SUCCESS) {
459 wpa_printf(MSG_DEBUG, "SCARD: Could not establish smart card "
460 "context (err=%ld)", ret);
461 goto failed;
462 }
463
464 ret = SCardListReaders(scard->ctx, NULL, NULL, &len);
465 if (ret != SCARD_S_SUCCESS) {
466 wpa_printf(MSG_DEBUG, "SCARD: SCardListReaders failed "
467 "(err=%ld)", ret);
468 goto failed;
469 }
470
471 #ifdef UNICODE
472 len *= 2;
473 #endif /* UNICODE */
474 readers = os_malloc(len);
475 if (readers == NULL) {
476 wpa_printf(MSG_INFO, "SCARD: malloc failed\n");
477 goto failed;
478 }
479
480 ret = SCardListReaders(scard->ctx, NULL, readers, &len);
481 if (ret != SCARD_S_SUCCESS) {
482 wpa_printf(MSG_DEBUG, "SCARD: SCardListReaders failed(2) "
483 "(err=%ld)", ret);
484 goto failed;
485 }
486 if (len < 3) {
487 wpa_printf(MSG_WARNING, "SCARD: No smart card readers "
488 "available.");
489 goto failed;
490 }
491 /* readers is a list of available reader. Last entry is terminated with
492 * double NUL.
493 * TODO: add support for selecting the reader; now just use the first
494 * one.. */
495 #ifdef UNICODE
496 wpa_printf(MSG_DEBUG, "SCARD: Selected reader='%S'", readers);
497 #else /* UNICODE */
498 wpa_printf(MSG_DEBUG, "SCARD: Selected reader='%s'", readers);
499 #endif /* UNICODE */
500
501 ret = SCardConnect(scard->ctx, readers, SCARD_SHARE_SHARED,
502 SCARD_PROTOCOL_T0, &scard->card, &scard->protocol);
503 if (ret != SCARD_S_SUCCESS) {
504 if (ret == (long) SCARD_E_NO_SMARTCARD)
505 wpa_printf(MSG_INFO, "No smart card inserted.");
506 else
507 wpa_printf(MSG_WARNING, "SCardConnect err=%lx", ret);
508 goto failed;
509 }
510
511 os_free(readers);
512 readers = NULL;
513
514 wpa_printf(MSG_DEBUG, "SCARD: card=0x%x active_protocol=%lu (%s)",
515 (unsigned int) scard->card, scard->protocol,
516 scard->protocol == SCARD_PROTOCOL_T0 ? "T0" : "T1");
517
518 ret = SCardBeginTransaction(scard->card);
519 if (ret != SCARD_S_SUCCESS) {
520 wpa_printf(MSG_DEBUG, "SCARD: Could not begin transaction: "
521 "0x%x", (unsigned int) ret);
522 goto failed;
523 }
524 transaction = 1;
525
526 blen = sizeof(buf);
527
528 scard->sim_type = SCARD_GSM_SIM;
529 if (sim_type == SCARD_USIM_ONLY || sim_type == SCARD_TRY_BOTH) {
530 wpa_printf(MSG_DEBUG, "SCARD: verifying USIM support");
531 if (_scard_select_file(scard, SCARD_FILE_MF, buf, &blen,
532 SCARD_USIM, NULL, 0)) {
533 wpa_printf(MSG_DEBUG, "SCARD: USIM is not supported");
534 if (sim_type == SCARD_USIM_ONLY)
535 goto failed;
536 wpa_printf(MSG_DEBUG, "SCARD: Trying to use GSM SIM");
537 scard->sim_type = SCARD_GSM_SIM;
538 } else {
539 wpa_printf(MSG_DEBUG, "SCARD: USIM is supported");
540 scard->sim_type = SCARD_USIM;
541 }
542 }
543
544 if (scard->sim_type == SCARD_GSM_SIM) {
545 blen = sizeof(buf);
546 if (scard_select_file(scard, SCARD_FILE_MF, buf, &blen)) {
547 wpa_printf(MSG_DEBUG, "SCARD: Failed to read MF");
548 goto failed;
549 }
550
551 blen = sizeof(buf);
552 if (scard_select_file(scard, SCARD_FILE_GSM_DF, buf, &blen)) {
553 wpa_printf(MSG_DEBUG, "SCARD: Failed to read GSM DF");
554 goto failed;
555 }
556 } else {
557 unsigned char aid[32];
558 int aid_len;
559
560 aid_len = scard_get_aid(scard, aid, sizeof(aid));
561 if (aid_len < 0) {
562 wpa_printf(MSG_DEBUG, "SCARD: Failed to find AID for "
563 "3G USIM app - try to use standard 3G RID");
564 os_memcpy(aid, "\xa0\x00\x00\x00\x87", 5);
565 aid_len = 5;
566 }
567 wpa_hexdump(MSG_DEBUG, "SCARD: 3G USIM AID", aid, aid_len);
568
569 /* Select based on AID = 3G RID from EF_DIR. This is usually
570 * starting with A0 00 00 00 87. */
571 blen = sizeof(buf);
572 if (_scard_select_file(scard, 0, buf, &blen, scard->sim_type,
573 aid, aid_len)) {
574 wpa_printf(MSG_INFO, "SCARD: Failed to read 3G USIM "
575 "app");
576 wpa_hexdump(MSG_INFO, "SCARD: 3G USIM AID",
577 aid, aid_len);
578 goto failed;
579 }
580 }
581
582 /* Verify whether CHV1 (PIN1) is needed to access the card. */
583 pin_needed = scard_pin_needed(scard, buf, blen);
584 if (pin_needed < 0) {
585 wpa_printf(MSG_DEBUG, "SCARD: Failed to determine whether PIN "
586 "is needed");
587 goto failed;
588 }
589 if (pin_needed) {
590 scard->pin1_required = 1;
591 wpa_printf(MSG_DEBUG, "PIN1 needed for SIM access");
592 }
593
594 ret = SCardEndTransaction(scard->card, SCARD_LEAVE_CARD);
595 if (ret != SCARD_S_SUCCESS) {
596 wpa_printf(MSG_DEBUG, "SCARD: Could not end transaction: "
597 "0x%x", (unsigned int) ret);
598 }
599
600 return scard;
601
602 failed:
603 if (transaction)
604 SCardEndTransaction(scard->card, SCARD_LEAVE_CARD);
605 os_free(readers);
606 scard_deinit(scard);
607 return NULL;
608 }
609
610
611 /**
612 * scard_set_pin - Set PIN (CHV1/PIN1) code for accessing SIM/USIM commands
613 * @scard: Pointer to private data from scard_init()
614 * @pin: PIN code as an ASCII string (e.g., "1234")
615 * Returns: 0 on success, -1 on failure
616 */
617 int scard_set_pin(struct scard_data *scard, const char *pin)
618 {
619 if (scard == NULL)
620 return -1;
621
622 /* Verify whether CHV1 (PIN1) is needed to access the card. */
623 if (scard->pin1_required) {
624 if (pin == NULL) {
625 wpa_printf(MSG_DEBUG, "No PIN configured for SIM "
626 "access");
627 return -1;
628 }
629 if (scard_verify_pin(scard, pin)) {
630 wpa_printf(MSG_INFO, "PIN verification failed for "
631 "SIM access");
632 return -1;
633 }
634 }
635
636 return 0;
637 }
638
639
640 /**
641 * scard_deinit - Deinitialize SIM/USIM connection
642 * @scard: Pointer to private data from scard_init()
643 *
644 * This function closes the SIM/USIM connect opened with scard_init().
645 */
646 void scard_deinit(struct scard_data *scard)
647 {
648 long ret;
649
650 if (scard == NULL)
651 return;
652
653 wpa_printf(MSG_DEBUG, "SCARD: deinitializing smart card interface");
654 if (scard->card) {
655 ret = SCardDisconnect(scard->card, SCARD_UNPOWER_CARD);
656 if (ret != SCARD_S_SUCCESS) {
657 wpa_printf(MSG_DEBUG, "SCARD: Failed to disconnect "
658 "smart card (err=%ld)", ret);
659 }
660 }
661
662 if (scard->ctx) {
663 ret = SCardReleaseContext(scard->ctx);
664 if (ret != SCARD_S_SUCCESS) {
665 wpa_printf(MSG_DEBUG, "Failed to release smart card "
666 "context (err=%ld)", ret);
667 }
668 }
669 os_free(scard);
670 mingw_unload_symbols();
671 }
672
673
674 static long scard_transmit(struct scard_data *scard,
675 unsigned char *_send, size_t send_len,
676 unsigned char *_recv, size_t *recv_len)
677 {
678 long ret;
679 unsigned long rlen;
680
681 wpa_hexdump_key(MSG_DEBUG, "SCARD: scard_transmit: send",
682 _send, send_len);
683 rlen = *recv_len;
684 ret = SCardTransmit(scard->card,
685 scard->protocol == SCARD_PROTOCOL_T1 ?
686 SCARD_PCI_T1 : SCARD_PCI_T0,
687 _send, (unsigned long) send_len,
688 NULL, _recv, &rlen);
689 *recv_len = rlen;
690 if (ret == SCARD_S_SUCCESS) {
691 wpa_hexdump(MSG_DEBUG, "SCARD: scard_transmit: recv",
692 _recv, rlen);
693 } else {
694 wpa_printf(MSG_WARNING, "SCARD: SCardTransmit failed "
695 "(err=0x%lx)", ret);
696 }
697 return ret;
698 }
699
700
701 static int _scard_select_file(struct scard_data *scard, unsigned short file_id,
702 unsigned char *buf, size_t *buf_len,
703 sim_types sim_type, unsigned char *aid,
704 size_t aidlen)
705 {
706 long ret;
707 unsigned char resp[3];
708 unsigned char cmd[50] = { SIM_CMD_SELECT };
709 int cmdlen;
710 unsigned char get_resp[5] = { SIM_CMD_GET_RESPONSE };
711 size_t len, rlen;
712
713 if (sim_type == SCARD_USIM) {
714 cmd[0] = USIM_CLA;
715 cmd[3] = 0x04;
716 get_resp[0] = USIM_CLA;
717 }
718
719 wpa_printf(MSG_DEBUG, "SCARD: select file %04x", file_id);
720 if (aid) {
721 wpa_hexdump(MSG_DEBUG, "SCARD: select file by AID",
722 aid, aidlen);
723 if (5 + aidlen > sizeof(cmd))
724 return -1;
725 cmd[2] = 0x04; /* Select by AID */
726 cmd[4] = aidlen; /* len */
727 os_memcpy(cmd + 5, aid, aidlen);
728 cmdlen = 5 + aidlen;
729 } else {
730 cmd[5] = file_id >> 8;
731 cmd[6] = file_id & 0xff;
732 cmdlen = 7;
733 }
734 len = sizeof(resp);
735 ret = scard_transmit(scard, cmd, cmdlen, resp, &len);
736 if (ret != SCARD_S_SUCCESS) {
737 wpa_printf(MSG_WARNING, "SCARD: SCardTransmit failed "
738 "(err=0x%lx)", ret);
739 return -1;
740 }
741
742 if (len != 2) {
743 wpa_printf(MSG_WARNING, "SCARD: unexpected resp len "
744 "%d (expected 2)", (int) len);
745 return -1;
746 }
747
748 if (resp[0] == 0x98 && resp[1] == 0x04) {
749 /* Security status not satisfied (PIN_WLAN) */
750 wpa_printf(MSG_WARNING, "SCARD: Security status not satisfied "
751 "(PIN_WLAN)");
752 return -1;
753 }
754
755 if (resp[0] == 0x6e) {
756 wpa_printf(MSG_DEBUG, "SCARD: used CLA not supported");
757 return -1;
758 }
759
760 if (resp[0] != 0x6c && resp[0] != 0x9f && resp[0] != 0x61) {
761 wpa_printf(MSG_WARNING, "SCARD: unexpected response 0x%02x "
762 "(expected 0x61, 0x6c, or 0x9f)", resp[0]);
763 return -1;
764 }
765 /* Normal ending of command; resp[1] bytes available */
766 get_resp[4] = resp[1];
767 wpa_printf(MSG_DEBUG, "SCARD: trying to get response (%d bytes)",
768 resp[1]);
769
770 rlen = *buf_len;
771 ret = scard_transmit(scard, get_resp, sizeof(get_resp), buf, &rlen);
772 if (ret == SCARD_S_SUCCESS) {
773 *buf_len = resp[1] < rlen ? resp[1] : rlen;
774 return 0;
775 }
776
777 wpa_printf(MSG_WARNING, "SCARD: SCardTransmit err=0x%lx\n", ret);
778 return -1;
779 }
780
781
782 static int scard_select_file(struct scard_data *scard, unsigned short file_id,
783 unsigned char *buf, size_t *buf_len)
784 {
785 return _scard_select_file(scard, file_id, buf, buf_len,
786 scard->sim_type, NULL, 0);
787 }
788
789
790 static int scard_get_record_len(struct scard_data *scard, unsigned char recnum,
791 unsigned char mode)
792 {
793 unsigned char buf[255];
794 unsigned char cmd[5] = { SIM_CMD_READ_RECORD /* , len */ };
795 size_t blen;
796 long ret;
797
798 if (scard->sim_type == SCARD_USIM)
799 cmd[0] = USIM_CLA;
800 cmd[2] = recnum;
801 cmd[3] = mode;
802 cmd[4] = sizeof(buf);
803
804 blen = sizeof(buf);
805 ret = scard_transmit(scard, cmd, sizeof(cmd), buf, &blen);
806 if (ret != SCARD_S_SUCCESS) {
807 wpa_printf(MSG_DEBUG, "SCARD: failed to determine file "
808 "length for record %d", recnum);
809 return -1;
810 }
811
812 wpa_hexdump(MSG_DEBUG, "SCARD: file length determination response",
813 buf, blen);
814
815 if (blen < 2 || buf[0] != 0x6c) {
816 wpa_printf(MSG_DEBUG, "SCARD: unexpected response to file "
817 "length determination");
818 return -1;
819 }
820
821 return buf[1];
822 }
823
824
825 static int scard_read_record(struct scard_data *scard,
826 unsigned char *data, size_t len,
827 unsigned char recnum, unsigned char mode)
828 {
829 unsigned char cmd[5] = { SIM_CMD_READ_RECORD /* , len */ };
830 size_t blen = len + 3;
831 unsigned char *buf;
832 long ret;
833
834 if (scard->sim_type == SCARD_USIM)
835 cmd[0] = USIM_CLA;
836 cmd[2] = recnum;
837 cmd[3] = mode;
838 cmd[4] = len;
839
840 buf = os_malloc(blen);
841 if (buf == NULL)
842 return -1;
843
844 ret = scard_transmit(scard, cmd, sizeof(cmd), buf, &blen);
845 if (ret != SCARD_S_SUCCESS) {
846 os_free(buf);
847 return -2;
848 }
849 if (blen != len + 2) {
850 wpa_printf(MSG_DEBUG, "SCARD: record read returned unexpected "
851 "length %ld (expected %ld)",
852 (long) blen, (long) len + 2);
853 os_free(buf);
854 return -3;
855 }
856
857 if (buf[len] != 0x90 || buf[len + 1] != 0x00) {
858 wpa_printf(MSG_DEBUG, "SCARD: record read returned unexpected "
859 "status %02x %02x (expected 90 00)",
860 buf[len], buf[len + 1]);
861 os_free(buf);
862 return -4;
863 }
864
865 os_memcpy(data, buf, len);
866 os_free(buf);
867
868 return 0;
869 }
870
871
872 static int scard_read_file(struct scard_data *scard,
873 unsigned char *data, size_t len)
874 {
875 unsigned char cmd[5] = { SIM_CMD_READ_BIN /* , len */ };
876 size_t blen = len + 3;
877 unsigned char *buf;
878 long ret;
879
880 cmd[4] = len;
881
882 buf = os_malloc(blen);
883 if (buf == NULL)
884 return -1;
885
886 if (scard->sim_type == SCARD_USIM)
887 cmd[0] = USIM_CLA;
888 ret = scard_transmit(scard, cmd, sizeof(cmd), buf, &blen);
889 if (ret != SCARD_S_SUCCESS) {
890 os_free(buf);
891 return -2;
892 }
893 if (blen != len + 2) {
894 wpa_printf(MSG_DEBUG, "SCARD: file read returned unexpected "
895 "length %ld (expected %ld)",
896 (long) blen, (long) len + 2);
897 os_free(buf);
898 return -3;
899 }
900
901 if (buf[len] != 0x90 || buf[len + 1] != 0x00) {
902 wpa_printf(MSG_DEBUG, "SCARD: file read returned unexpected "
903 "status %02x %02x (expected 90 00)",
904 buf[len], buf[len + 1]);
905 os_free(buf);
906 return -4;
907 }
908
909 os_memcpy(data, buf, len);
910 os_free(buf);
911
912 return 0;
913 }
914
915
916 static int scard_verify_pin(struct scard_data *scard, const char *pin)
917 {
918 long ret;
919 unsigned char resp[3];
920 unsigned char cmd[5 + 8] = { SIM_CMD_VERIFY_CHV1 };
921 size_t len;
922
923 wpa_printf(MSG_DEBUG, "SCARD: verifying PIN");
924
925 if (pin == NULL || os_strlen(pin) > 8)
926 return -1;
927
928 if (scard->sim_type == SCARD_USIM)
929 cmd[0] = USIM_CLA;
930 os_memcpy(cmd + 5, pin, os_strlen(pin));
931 os_memset(cmd + 5 + os_strlen(pin), 0xff, 8 - os_strlen(pin));
932
933 len = sizeof(resp);
934 ret = scard_transmit(scard, cmd, sizeof(cmd), resp, &len);
935 if (ret != SCARD_S_SUCCESS)
936 return -2;
937
938 if (len != 2 || resp[0] != 0x90 || resp[1] != 0x00) {
939 wpa_printf(MSG_WARNING, "SCARD: PIN verification failed");
940 return -1;
941 }
942
943 wpa_printf(MSG_DEBUG, "SCARD: PIN verified successfully");
944 return 0;
945 }
946
947
948 /**
949 * scard_get_imsi - Read IMSI from SIM/USIM card
950 * @scard: Pointer to private data from scard_init()
951 * @imsi: Buffer for IMSI
952 * @len: Length of imsi buffer; set to IMSI length on success
953 * Returns: 0 on success, -1 if IMSI file cannot be selected, -2 if IMSI file
954 * selection returns invalid result code, -3 if parsing FSP template file fails
955 * (USIM only), -4 if IMSI does not fit in the provided imsi buffer (len is set
956 * to needed length), -5 if reading IMSI file fails.
957 *
958 * This function can be used to read IMSI from the SIM/USIM card. If the IMSI
959 * file is PIN protected, scard_set_pin() must have been used to set the
960 * correct PIN code before calling scard_get_imsi().
961 */
962 int scard_get_imsi(struct scard_data *scard, char *imsi, size_t *len)
963 {
964 unsigned char buf[100];
965 size_t blen, imsilen, i;
966 char *pos;
967
968 wpa_printf(MSG_DEBUG, "SCARD: reading IMSI from (GSM) EF-IMSI");
969 blen = sizeof(buf);
970 if (scard_select_file(scard, SCARD_FILE_GSM_EF_IMSI, buf, &blen))
971 return -1;
972 if (blen < 4) {
973 wpa_printf(MSG_WARNING, "SCARD: too short (GSM) EF-IMSI "
974 "header (len=%ld)", (long) blen);
975 return -2;
976 }
977
978 if (scard->sim_type == SCARD_GSM_SIM) {
979 blen = (buf[2] << 8) | buf[3];
980 } else {
981 int file_size;
982 if (scard_parse_fsp_templ(buf, blen, NULL, &file_size))
983 return -3;
984 blen = file_size;
985 }
986 if (blen < 2 || blen > sizeof(buf)) {
987 wpa_printf(MSG_DEBUG, "SCARD: invalid IMSI file length=%ld",
988 (long) blen);
989 return -3;
990 }
991
992 imsilen = (blen - 2) * 2 + 1;
993 wpa_printf(MSG_DEBUG, "SCARD: IMSI file length=%ld imsilen=%ld",
994 (long) blen, (long) imsilen);
995 if (blen < 2 || imsilen > *len) {
996 *len = imsilen;
997 return -4;
998 }
999
1000 if (scard_read_file(scard, buf, blen))
1001 return -5;
1002
1003 pos = imsi;
1004 *pos++ = '0' + (buf[1] >> 4 & 0x0f);
1005 for (i = 2; i < blen; i++) {
1006 unsigned char digit;
1007
1008 digit = buf[i] & 0x0f;
1009 if (digit < 10)
1010 *pos++ = '0' + digit;
1011 else
1012 imsilen--;
1013
1014 digit = buf[i] >> 4 & 0x0f;
1015 if (digit < 10)
1016 *pos++ = '0' + digit;
1017 else
1018 imsilen--;
1019 }
1020 *len = imsilen;
1021
1022 return 0;
1023 }
1024
1025
1026 /**
1027 * scard_gsm_auth - Run GSM authentication command on SIM card
1028 * @scard: Pointer to private data from scard_init()
1029 * @_rand: 16-byte RAND value from HLR/AuC
1030 * @sres: 4-byte buffer for SRES
1031 * @kc: 8-byte buffer for Kc
1032 * Returns: 0 on success, -1 if SIM/USIM connection has not been initialized,
1033 * -2 if authentication command execution fails, -3 if unknown response code
1034 * for authentication command is received, -4 if reading of response fails,
1035 * -5 if if response data is of unexpected length
1036 *
1037 * This function performs GSM authentication using SIM/USIM card and the
1038 * provided RAND value from HLR/AuC. If authentication command can be completed
1039 * successfully, SRES and Kc values will be written into sres and kc buffers.
1040 */
1041 int scard_gsm_auth(struct scard_data *scard, const unsigned char *_rand,
1042 unsigned char *sres, unsigned char *kc)
1043 {
1044 unsigned char cmd[5 + 1 + 16] = { SIM_CMD_RUN_GSM_ALG };
1045 int cmdlen;
1046 unsigned char get_resp[5] = { SIM_CMD_GET_RESPONSE };
1047 unsigned char resp[3], buf[12 + 3 + 2];
1048 size_t len;
1049 long ret;
1050
1051 if (scard == NULL)
1052 return -1;
1053
1054 wpa_hexdump(MSG_DEBUG, "SCARD: GSM auth - RAND", _rand, 16);
1055 if (scard->sim_type == SCARD_GSM_SIM) {
1056 cmdlen = 5 + 16;
1057 os_memcpy(cmd + 5, _rand, 16);
1058 } else {
1059 cmdlen = 5 + 1 + 16;
1060 cmd[0] = USIM_CLA;
1061 cmd[3] = 0x80;
1062 cmd[4] = 17;
1063 cmd[5] = 16;
1064 os_memcpy(cmd + 6, _rand, 16);
1065 }
1066 len = sizeof(resp);
1067 ret = scard_transmit(scard, cmd, cmdlen, resp, &len);
1068 if (ret != SCARD_S_SUCCESS)
1069 return -2;
1070
1071 if ((scard->sim_type == SCARD_GSM_SIM &&
1072 (len != 2 || resp[0] != 0x9f || resp[1] != 0x0c)) ||
1073 (scard->sim_type == SCARD_USIM &&
1074 (len != 2 || resp[0] != 0x61 || resp[1] != 0x0e))) {
1075 wpa_printf(MSG_WARNING, "SCARD: unexpected response for GSM "
1076 "auth request (len=%ld resp=%02x %02x)",
1077 (long) len, resp[0], resp[1]);
1078 return -3;
1079 }
1080 get_resp[4] = resp[1];
1081
1082 len = sizeof(buf);
1083 ret = scard_transmit(scard, get_resp, sizeof(get_resp), buf, &len);
1084 if (ret != SCARD_S_SUCCESS)
1085 return -4;
1086
1087 if (scard->sim_type == SCARD_GSM_SIM) {
1088 if (len != 4 + 8 + 2) {
1089 wpa_printf(MSG_WARNING, "SCARD: unexpected data "
1090 "length for GSM auth (len=%ld, expected 14)",
1091 (long) len);
1092 return -5;
1093 }
1094 os_memcpy(sres, buf, 4);
1095 os_memcpy(kc, buf + 4, 8);
1096 } else {
1097 if (len != 1 + 4 + 1 + 8 + 2) {
1098 wpa_printf(MSG_WARNING, "SCARD: unexpected data "
1099 "length for USIM auth (len=%ld, "
1100 "expected 16)", (long) len);
1101 return -5;
1102 }
1103 if (buf[0] != 4 || buf[5] != 8) {
1104 wpa_printf(MSG_WARNING, "SCARD: unexpected SREC/Kc "
1105 "length (%d %d, expected 4 8)",
1106 buf[0], buf[5]);
1107 }
1108 os_memcpy(sres, buf + 1, 4);
1109 os_memcpy(kc, buf + 6, 8);
1110 }
1111
1112 wpa_hexdump(MSG_DEBUG, "SCARD: GSM auth - SRES", sres, 4);
1113 wpa_hexdump(MSG_DEBUG, "SCARD: GSM auth - Kc", kc, 8);
1114
1115 return 0;
1116 }
1117
1118
1119 /**
1120 * scard_umts_auth - Run UMTS authentication command on USIM card
1121 * @scard: Pointer to private data from scard_init()
1122 * @_rand: 16-byte RAND value from HLR/AuC
1123 * @autn: 16-byte AUTN value from HLR/AuC
1124 * @res: 16-byte buffer for RES
1125 * @res_len: Variable that will be set to RES length
1126 * @ik: 16-byte buffer for IK
1127 * @ck: 16-byte buffer for CK
1128 * @auts: 14-byte buffer for AUTS
1129 * Returns: 0 on success, -1 on failure, or -2 if USIM reports synchronization
1130 * failure
1131 *
1132 * This function performs AKA authentication using USIM card and the provided
1133 * RAND and AUTN values from HLR/AuC. If authentication command can be
1134 * completed successfully, RES, IK, and CK values will be written into provided
1135 * buffers and res_len is set to length of received RES value. If USIM reports
1136 * synchronization failure, the received AUTS value will be written into auts
1137 * buffer. In this case, RES, IK, and CK are not valid.
1138 */
1139 int scard_umts_auth(struct scard_data *scard, const unsigned char *_rand,
1140 const unsigned char *autn,
1141 unsigned char *res, size_t *res_len,
1142 unsigned char *ik, unsigned char *ck, unsigned char *auts)
1143 {
1144 unsigned char cmd[5 + 1 + AKA_RAND_LEN + 1 + AKA_AUTN_LEN] =
1145 { USIM_CMD_RUN_UMTS_ALG };
1146 unsigned char get_resp[5] = { USIM_CMD_GET_RESPONSE };
1147 unsigned char resp[3], buf[64], *pos, *end;
1148 size_t len;
1149 long ret;
1150
1151 if (scard == NULL)
1152 return -1;
1153
1154 if (scard->sim_type == SCARD_GSM_SIM) {
1155 wpa_printf(MSG_ERROR, "SCARD: Non-USIM card - cannot do UMTS "
1156 "auth");
1157 return -1;
1158 }
1159
1160 wpa_hexdump(MSG_DEBUG, "SCARD: UMTS auth - RAND", _rand, AKA_RAND_LEN);
1161 wpa_hexdump(MSG_DEBUG, "SCARD: UMTS auth - AUTN", autn, AKA_AUTN_LEN);
1162 cmd[5] = AKA_RAND_LEN;
1163 os_memcpy(cmd + 6, _rand, AKA_RAND_LEN);
1164 cmd[6 + AKA_RAND_LEN] = AKA_AUTN_LEN;
1165 os_memcpy(cmd + 6 + AKA_RAND_LEN + 1, autn, AKA_AUTN_LEN);
1166
1167 len = sizeof(resp);
1168 ret = scard_transmit(scard, cmd, sizeof(cmd), resp, &len);
1169 if (ret != SCARD_S_SUCCESS)
1170 return -1;
1171
1172 if (len <= sizeof(resp))
1173 wpa_hexdump(MSG_DEBUG, "SCARD: UMTS alg response", resp, len);
1174
1175 if (len == 2 && resp[0] == 0x98 && resp[1] == 0x62) {
1176 wpa_printf(MSG_WARNING, "SCARD: UMTS auth failed - "
1177 "MAC != XMAC");
1178 return -1;
1179 } else if (len != 2 || resp[0] != 0x61) {
1180 wpa_printf(MSG_WARNING, "SCARD: unexpected response for UMTS "
1181 "auth request (len=%ld resp=%02x %02x)",
1182 (long) len, resp[0], resp[1]);
1183 return -1;
1184 }
1185 get_resp[4] = resp[1];
1186
1187 len = sizeof(buf);
1188 ret = scard_transmit(scard, get_resp, sizeof(get_resp), buf, &len);
1189 if (ret != SCARD_S_SUCCESS || len > sizeof(buf))
1190 return -1;
1191
1192 wpa_hexdump(MSG_DEBUG, "SCARD: UMTS get response result", buf, len);
1193 if (len >= 2 + AKA_AUTS_LEN && buf[0] == 0xdc &&
1194 buf[1] == AKA_AUTS_LEN) {
1195 wpa_printf(MSG_DEBUG, "SCARD: UMTS Synchronization-Failure");
1196 os_memcpy(auts, buf + 2, AKA_AUTS_LEN);
1197 wpa_hexdump(MSG_DEBUG, "SCARD: AUTS", auts, AKA_AUTS_LEN);
1198 return -2;
1199 } else if (len >= 6 + IK_LEN + CK_LEN && buf[0] == 0xdb) {
1200 pos = buf + 1;
1201 end = buf + len;
1202
1203 /* RES */
1204 if (pos[0] > RES_MAX_LEN || pos + pos[0] > end) {
1205 wpa_printf(MSG_DEBUG, "SCARD: Invalid RES");
1206 return -1;
1207 }
1208 *res_len = *pos++;
1209 os_memcpy(res, pos, *res_len);
1210 pos += *res_len;
1211 wpa_hexdump(MSG_DEBUG, "SCARD: RES", res, *res_len);
1212
1213 /* CK */
1214 if (pos[0] != CK_LEN || pos + CK_LEN > end) {
1215 wpa_printf(MSG_DEBUG, "SCARD: Invalid CK");
1216 return -1;
1217 }
1218 pos++;
1219 os_memcpy(ck, pos, CK_LEN);
1220 pos += CK_LEN;
1221 wpa_hexdump(MSG_DEBUG, "SCARD: CK", ck, CK_LEN);
1222
1223 /* IK */
1224 if (pos[0] != IK_LEN || pos + IK_LEN > end) {
1225 wpa_printf(MSG_DEBUG, "SCARD: Invalid IK");
1226 return -1;
1227 }
1228 pos++;
1229 os_memcpy(ik, pos, IK_LEN);
1230 pos += IK_LEN;
1231 wpa_hexdump(MSG_DEBUG, "SCARD: IK", ik, IK_LEN);
1232
1233 return 0;
1234 }
1235
1236 wpa_printf(MSG_DEBUG, "SCARD: Unrecognized response");
1237 return -1;
1238 }