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