1 /* 2 * CCID Card Device. Emulated card. 3 * 4 * Copyright (c) 2011 Red Hat. 5 * Written by Alon Levy. 6 * 7 * This code is licensed under the GNU LGPL, version 2 or later. 8 */ 9 10 /* 11 * It can be used to provide access to the local hardware in a non exclusive 12 * way, or it can use certificates. It requires the usb-ccid bus. 13 * 14 * Usage 1: standard, mirror hardware reader+card: 15 * qemu .. -usb -device usb-ccid -device ccid-card-emulated 16 * 17 * Usage 2: use certificates, no hardware required 18 * one time: create the certificates: 19 * for i in 1 2 3; do 20 * certutil -d /etc/pki/nssdb -x -t "CT,CT,CT" -S -s "CN=user$i" -n user$i 21 * done 22 * qemu .. -usb -device usb-ccid \ 23 * -device ccid-card-emulated,cert1=user1,cert2=user2,cert3=user3 24 * 25 * If you use a non default db for the certificates you can specify it using 26 * the db parameter. 27 */ 28 29 #include "qemu/osdep.h" 30 #include <libcacard.h> 31 32 #include "qemu/thread.h" 33 #include "qemu/main-loop.h" 34 #include "qemu/module.h" 35 #include "ccid.h" 36 #include "qapi/error.h" 37 38 #define DPRINTF(card, lvl, fmt, ...) \ 39 do {\ 40 if (lvl <= card->debug) {\ 41 printf("ccid-card-emul: %s: " fmt , __func__, ## __VA_ARGS__);\ 42 } \ 43 } while (0) 44 45 46 #define TYPE_EMULATED_CCID "ccid-card-emulated" 47 #define EMULATED_CCID_CARD(obj) \ 48 OBJECT_CHECK(EmulatedState, (obj), TYPE_EMULATED_CCID) 49 50 #define BACKEND_NSS_EMULATED_NAME "nss-emulated" 51 #define BACKEND_CERTIFICATES_NAME "certificates" 52 53 enum { 54 BACKEND_NSS_EMULATED = 1, 55 BACKEND_CERTIFICATES 56 }; 57 58 #define DEFAULT_BACKEND BACKEND_NSS_EMULATED 59 60 typedef struct EmulatedState EmulatedState; 61 62 enum { 63 EMUL_READER_INSERT = 0, 64 EMUL_READER_REMOVE, 65 EMUL_CARD_INSERT, 66 EMUL_CARD_REMOVE, 67 EMUL_GUEST_APDU, 68 EMUL_RESPONSE_APDU, 69 EMUL_ERROR, 70 }; 71 72 static const char *emul_event_to_string(uint32_t emul_event) 73 { 74 switch (emul_event) { 75 case EMUL_READER_INSERT: 76 return "EMUL_READER_INSERT"; 77 case EMUL_READER_REMOVE: 78 return "EMUL_READER_REMOVE"; 79 case EMUL_CARD_INSERT: 80 return "EMUL_CARD_INSERT"; 81 case EMUL_CARD_REMOVE: 82 return "EMUL_CARD_REMOVE"; 83 case EMUL_GUEST_APDU: 84 return "EMUL_GUEST_APDU"; 85 case EMUL_RESPONSE_APDU: 86 return "EMUL_RESPONSE_APDU"; 87 case EMUL_ERROR: 88 return "EMUL_ERROR"; 89 } 90 return "UNKNOWN"; 91 } 92 93 typedef struct EmulEvent { 94 QSIMPLEQ_ENTRY(EmulEvent) entry; 95 union { 96 struct { 97 uint32_t type; 98 } gen; 99 struct { 100 uint32_t type; 101 uint64_t code; 102 } error; 103 struct { 104 uint32_t type; 105 uint32_t len; 106 uint8_t data[]; 107 } data; 108 } p; 109 } EmulEvent; 110 111 #define MAX_ATR_SIZE 40 112 struct EmulatedState { 113 CCIDCardState base; 114 uint8_t debug; 115 char *backend_str; 116 uint32_t backend; 117 char *cert1; 118 char *cert2; 119 char *cert3; 120 char *db; 121 uint8_t atr[MAX_ATR_SIZE]; 122 uint8_t atr_length; 123 QSIMPLEQ_HEAD(, EmulEvent) event_list; 124 QemuMutex event_list_mutex; 125 QemuThread event_thread_id; 126 VReader *reader; 127 QSIMPLEQ_HEAD(, EmulEvent) guest_apdu_list; 128 QemuMutex vreader_mutex; /* and guest_apdu_list mutex */ 129 QemuMutex handle_apdu_mutex; 130 QemuCond handle_apdu_cond; 131 EventNotifier notifier; 132 int quit_apdu_thread; 133 QemuThread apdu_thread_id; 134 }; 135 136 static void emulated_apdu_from_guest(CCIDCardState *base, 137 const uint8_t *apdu, uint32_t len) 138 { 139 EmulatedState *card = EMULATED_CCID_CARD(base); 140 EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent) + len); 141 142 assert(event); 143 event->p.data.type = EMUL_GUEST_APDU; 144 event->p.data.len = len; 145 memcpy(event->p.data.data, apdu, len); 146 qemu_mutex_lock(&card->vreader_mutex); 147 QSIMPLEQ_INSERT_TAIL(&card->guest_apdu_list, event, entry); 148 qemu_mutex_unlock(&card->vreader_mutex); 149 qemu_mutex_lock(&card->handle_apdu_mutex); 150 qemu_cond_signal(&card->handle_apdu_cond); 151 qemu_mutex_unlock(&card->handle_apdu_mutex); 152 } 153 154 static const uint8_t *emulated_get_atr(CCIDCardState *base, uint32_t *len) 155 { 156 EmulatedState *card = EMULATED_CCID_CARD(base); 157 158 *len = card->atr_length; 159 return card->atr; 160 } 161 162 static void emulated_push_event(EmulatedState *card, EmulEvent *event) 163 { 164 qemu_mutex_lock(&card->event_list_mutex); 165 QSIMPLEQ_INSERT_TAIL(&(card->event_list), event, entry); 166 qemu_mutex_unlock(&card->event_list_mutex); 167 event_notifier_set(&card->notifier); 168 } 169 170 static void emulated_push_type(EmulatedState *card, uint32_t type) 171 { 172 EmulEvent *event = g_new(EmulEvent, 1); 173 174 assert(event); 175 event->p.gen.type = type; 176 emulated_push_event(card, event); 177 } 178 179 static void emulated_push_error(EmulatedState *card, uint64_t code) 180 { 181 EmulEvent *event = g_new(EmulEvent, 1); 182 183 assert(event); 184 event->p.error.type = EMUL_ERROR; 185 event->p.error.code = code; 186 emulated_push_event(card, event); 187 } 188 189 static void emulated_push_data_type(EmulatedState *card, uint32_t type, 190 const uint8_t *data, uint32_t len) 191 { 192 EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent) + len); 193 194 assert(event); 195 event->p.data.type = type; 196 event->p.data.len = len; 197 memcpy(event->p.data.data, data, len); 198 emulated_push_event(card, event); 199 } 200 201 static void emulated_push_reader_insert(EmulatedState *card) 202 { 203 emulated_push_type(card, EMUL_READER_INSERT); 204 } 205 206 static void emulated_push_reader_remove(EmulatedState *card) 207 { 208 emulated_push_type(card, EMUL_READER_REMOVE); 209 } 210 211 static void emulated_push_card_insert(EmulatedState *card, 212 const uint8_t *atr, uint32_t len) 213 { 214 emulated_push_data_type(card, EMUL_CARD_INSERT, atr, len); 215 } 216 217 static void emulated_push_card_remove(EmulatedState *card) 218 { 219 emulated_push_type(card, EMUL_CARD_REMOVE); 220 } 221 222 static void emulated_push_response_apdu(EmulatedState *card, 223 const uint8_t *apdu, uint32_t len) 224 { 225 emulated_push_data_type(card, EMUL_RESPONSE_APDU, apdu, len); 226 } 227 228 #define APDU_BUF_SIZE 270 229 static void *handle_apdu_thread(void* arg) 230 { 231 EmulatedState *card = arg; 232 uint8_t recv_data[APDU_BUF_SIZE]; 233 int recv_len; 234 VReaderStatus reader_status; 235 EmulEvent *event; 236 237 while (1) { 238 qemu_mutex_lock(&card->handle_apdu_mutex); 239 qemu_cond_wait(&card->handle_apdu_cond, &card->handle_apdu_mutex); 240 qemu_mutex_unlock(&card->handle_apdu_mutex); 241 if (card->quit_apdu_thread) { 242 card->quit_apdu_thread = 0; /* debugging */ 243 break; 244 } 245 qemu_mutex_lock(&card->vreader_mutex); 246 while (!QSIMPLEQ_EMPTY(&card->guest_apdu_list)) { 247 event = QSIMPLEQ_FIRST(&card->guest_apdu_list); 248 assert((unsigned long)event > 1000); 249 QSIMPLEQ_REMOVE_HEAD(&card->guest_apdu_list, entry); 250 if (event->p.data.type != EMUL_GUEST_APDU) { 251 DPRINTF(card, 1, "unexpected message in handle_apdu_thread\n"); 252 g_free(event); 253 continue; 254 } 255 if (card->reader == NULL) { 256 DPRINTF(card, 1, "reader is NULL\n"); 257 g_free(event); 258 continue; 259 } 260 recv_len = sizeof(recv_data); 261 reader_status = vreader_xfr_bytes(card->reader, 262 event->p.data.data, event->p.data.len, 263 recv_data, &recv_len); 264 DPRINTF(card, 2, "got back apdu of length %d\n", recv_len); 265 if (reader_status == VREADER_OK) { 266 emulated_push_response_apdu(card, recv_data, recv_len); 267 } else { 268 emulated_push_error(card, reader_status); 269 } 270 g_free(event); 271 } 272 qemu_mutex_unlock(&card->vreader_mutex); 273 } 274 return NULL; 275 } 276 277 static void *event_thread(void *arg) 278 { 279 int atr_len = MAX_ATR_SIZE; 280 uint8_t atr[MAX_ATR_SIZE]; 281 VEvent *event = NULL; 282 EmulatedState *card = arg; 283 284 while (1) { 285 const char *reader_name; 286 287 event = vevent_wait_next_vevent(); 288 if (event == NULL || event->type == VEVENT_LAST) { 289 break; 290 } 291 if (event->type != VEVENT_READER_INSERT) { 292 if (card->reader == NULL && event->reader != NULL) { 293 /* Happens after device_add followed by card remove or insert. 294 * XXX: create synthetic add_reader events if vcard_emul_init 295 * already called, which happens if device_del and device_add 296 * are called */ 297 card->reader = vreader_reference(event->reader); 298 } else { 299 if (event->reader != card->reader) { 300 fprintf(stderr, 301 "ERROR: wrong reader: quiting event_thread\n"); 302 break; 303 } 304 } 305 } 306 switch (event->type) { 307 case VEVENT_READER_INSERT: 308 /* TODO: take a specific reader. i.e. track which reader 309 * we are seeing here, check it is the one we want (the first, 310 * or by a particular name), and ignore if we don't want it. 311 */ 312 reader_name = vreader_get_name(event->reader); 313 if (card->reader != NULL) { 314 DPRINTF(card, 2, "READER INSERT - replacing %s with %s\n", 315 vreader_get_name(card->reader), reader_name); 316 qemu_mutex_lock(&card->vreader_mutex); 317 vreader_free(card->reader); 318 qemu_mutex_unlock(&card->vreader_mutex); 319 emulated_push_reader_remove(card); 320 } 321 qemu_mutex_lock(&card->vreader_mutex); 322 DPRINTF(card, 2, "READER INSERT %s\n", reader_name); 323 card->reader = vreader_reference(event->reader); 324 qemu_mutex_unlock(&card->vreader_mutex); 325 emulated_push_reader_insert(card); 326 break; 327 case VEVENT_READER_REMOVE: 328 DPRINTF(card, 2, " READER REMOVE: %s\n", 329 vreader_get_name(event->reader)); 330 qemu_mutex_lock(&card->vreader_mutex); 331 vreader_free(card->reader); 332 card->reader = NULL; 333 qemu_mutex_unlock(&card->vreader_mutex); 334 emulated_push_reader_remove(card); 335 break; 336 case VEVENT_CARD_INSERT: 337 /* get the ATR (intended as a response to a power on from the 338 * reader */ 339 atr_len = MAX_ATR_SIZE; 340 vreader_power_on(event->reader, atr, &atr_len); 341 card->atr_length = (uint8_t)atr_len; 342 DPRINTF(card, 2, " CARD INSERT\n"); 343 emulated_push_card_insert(card, atr, atr_len); 344 break; 345 case VEVENT_CARD_REMOVE: 346 DPRINTF(card, 2, " CARD REMOVE\n"); 347 emulated_push_card_remove(card); 348 break; 349 case VEVENT_LAST: /* quit */ 350 vevent_delete(event); 351 return NULL; 352 break; 353 default: 354 break; 355 } 356 vevent_delete(event); 357 } 358 return NULL; 359 } 360 361 static void card_event_handler(EventNotifier *notifier) 362 { 363 EmulatedState *card = container_of(notifier, EmulatedState, notifier); 364 EmulEvent *event, *next; 365 366 event_notifier_test_and_clear(&card->notifier); 367 qemu_mutex_lock(&card->event_list_mutex); 368 QSIMPLEQ_FOREACH_SAFE(event, &card->event_list, entry, next) { 369 DPRINTF(card, 2, "event %s\n", emul_event_to_string(event->p.gen.type)); 370 switch (event->p.gen.type) { 371 case EMUL_RESPONSE_APDU: 372 ccid_card_send_apdu_to_guest(&card->base, event->p.data.data, 373 event->p.data.len); 374 break; 375 case EMUL_READER_INSERT: 376 ccid_card_ccid_attach(&card->base); 377 break; 378 case EMUL_READER_REMOVE: 379 ccid_card_ccid_detach(&card->base); 380 break; 381 case EMUL_CARD_INSERT: 382 assert(event->p.data.len <= MAX_ATR_SIZE); 383 card->atr_length = event->p.data.len; 384 memcpy(card->atr, event->p.data.data, card->atr_length); 385 ccid_card_card_inserted(&card->base); 386 break; 387 case EMUL_CARD_REMOVE: 388 ccid_card_card_removed(&card->base); 389 break; 390 case EMUL_ERROR: 391 ccid_card_card_error(&card->base, event->p.error.code); 392 break; 393 default: 394 DPRINTF(card, 2, "unexpected event\n"); 395 break; 396 } 397 g_free(event); 398 } 399 QSIMPLEQ_INIT(&card->event_list); 400 qemu_mutex_unlock(&card->event_list_mutex); 401 } 402 403 static int init_event_notifier(EmulatedState *card, Error **errp) 404 { 405 if (event_notifier_init(&card->notifier, false) < 0) { 406 error_setg(errp, "ccid-card-emul: event notifier creation failed"); 407 return -1; 408 } 409 event_notifier_set_handler(&card->notifier, card_event_handler); 410 return 0; 411 } 412 413 static void clean_event_notifier(EmulatedState *card) 414 { 415 event_notifier_set_handler(&card->notifier, NULL); 416 event_notifier_cleanup(&card->notifier); 417 } 418 419 #define CERTIFICATES_DEFAULT_DB "/etc/pki/nssdb" 420 #define CERTIFICATES_ARGS_TEMPLATE\ 421 "db=\"%s\" use_hw=no soft=(,Virtual Reader,CAC,,%s,%s,%s)" 422 423 static int wrap_vcard_emul_init(VCardEmulOptions *options) 424 { 425 static int called; 426 static int options_was_null; 427 428 if (called) { 429 if ((options == NULL) != options_was_null) { 430 printf("%s: warning: running emulated with certificates" 431 " and emulated side by side is not supported\n", 432 __func__); 433 return VCARD_EMUL_FAIL; 434 } 435 vcard_emul_replay_insertion_events(); 436 return VCARD_EMUL_OK; 437 } 438 options_was_null = (options == NULL); 439 called = 1; 440 return vcard_emul_init(options); 441 } 442 443 static int emulated_initialize_vcard_from_certificates(EmulatedState *card) 444 { 445 char emul_args[200]; 446 VCardEmulOptions *options = NULL; 447 448 snprintf(emul_args, sizeof(emul_args) - 1, CERTIFICATES_ARGS_TEMPLATE, 449 card->db ? card->db : CERTIFICATES_DEFAULT_DB, 450 card->cert1, card->cert2, card->cert3); 451 options = vcard_emul_options(emul_args); 452 if (options == NULL) { 453 printf("%s: warning: not using certificates due to" 454 " initialization error\n", __func__); 455 } 456 return wrap_vcard_emul_init(options); 457 } 458 459 typedef struct EnumTable { 460 const char *name; 461 uint32_t value; 462 } EnumTable; 463 464 static const EnumTable backend_enum_table[] = { 465 {BACKEND_NSS_EMULATED_NAME, BACKEND_NSS_EMULATED}, 466 {BACKEND_CERTIFICATES_NAME, BACKEND_CERTIFICATES}, 467 {NULL, 0}, 468 }; 469 470 static uint32_t parse_enumeration(char *str, 471 const EnumTable *table, uint32_t not_found_value) 472 { 473 uint32_t ret = not_found_value; 474 475 if (str == NULL) 476 return 0; 477 478 while (table->name != NULL) { 479 if (strcmp(table->name, str) == 0) { 480 ret = table->value; 481 break; 482 } 483 table++; 484 } 485 return ret; 486 } 487 488 static void emulated_realize(CCIDCardState *base, Error **errp) 489 { 490 EmulatedState *card = EMULATED_CCID_CARD(base); 491 VCardEmulError ret; 492 const EnumTable *ptable; 493 494 QSIMPLEQ_INIT(&card->event_list); 495 QSIMPLEQ_INIT(&card->guest_apdu_list); 496 qemu_mutex_init(&card->event_list_mutex); 497 qemu_mutex_init(&card->vreader_mutex); 498 qemu_mutex_init(&card->handle_apdu_mutex); 499 qemu_cond_init(&card->handle_apdu_cond); 500 card->reader = NULL; 501 card->quit_apdu_thread = 0; 502 if (init_event_notifier(card, errp) < 0) { 503 goto out1; 504 } 505 506 card->backend = 0; 507 if (card->backend_str) { 508 card->backend = parse_enumeration(card->backend_str, 509 backend_enum_table, 0); 510 } 511 512 if (card->backend == 0) { 513 error_setg(errp, "backend must be one of:"); 514 for (ptable = backend_enum_table; ptable->name != NULL; ++ptable) { 515 error_append_hint(errp, "%s\n", ptable->name); 516 } 517 goto out2; 518 } 519 520 /* TODO: a passthru backened that works on local machine. third card type?*/ 521 if (card->backend == BACKEND_CERTIFICATES) { 522 if (card->cert1 != NULL && card->cert2 != NULL && card->cert3 != NULL) { 523 ret = emulated_initialize_vcard_from_certificates(card); 524 } else { 525 error_setg(errp, "%s: you must provide all three certs for" 526 " certificates backend", TYPE_EMULATED_CCID); 527 goto out2; 528 } 529 } else { 530 if (card->backend != BACKEND_NSS_EMULATED) { 531 error_setg(errp, "%s: bad backend specified. The options are:%s" 532 " (default), %s.", TYPE_EMULATED_CCID, 533 BACKEND_NSS_EMULATED_NAME, BACKEND_CERTIFICATES_NAME); 534 goto out2; 535 } 536 if (card->cert1 != NULL || card->cert2 != NULL || card->cert3 != NULL) { 537 error_setg(errp, "%s: unexpected cert parameters to nss emulated " 538 "backend", TYPE_EMULATED_CCID); 539 goto out2; 540 } 541 /* default to mirroring the local hardware readers */ 542 ret = wrap_vcard_emul_init(NULL); 543 } 544 if (ret != VCARD_EMUL_OK) { 545 error_setg(errp, "%s: failed to initialize vcard", TYPE_EMULATED_CCID); 546 goto out2; 547 } 548 qemu_thread_create(&card->event_thread_id, "ccid/event", event_thread, 549 card, QEMU_THREAD_JOINABLE); 550 qemu_thread_create(&card->apdu_thread_id, "ccid/apdu", handle_apdu_thread, 551 card, QEMU_THREAD_JOINABLE); 552 553 return; 554 555 out2: 556 clean_event_notifier(card); 557 out1: 558 qemu_cond_destroy(&card->handle_apdu_cond); 559 qemu_mutex_destroy(&card->handle_apdu_mutex); 560 qemu_mutex_destroy(&card->vreader_mutex); 561 qemu_mutex_destroy(&card->event_list_mutex); 562 } 563 564 static void emulated_unrealize(CCIDCardState *base, Error **errp) 565 { 566 EmulatedState *card = EMULATED_CCID_CARD(base); 567 VEvent *vevent = vevent_new(VEVENT_LAST, NULL, NULL); 568 569 vevent_queue_vevent(vevent); /* stop vevent thread */ 570 qemu_thread_join(&card->event_thread_id); 571 572 card->quit_apdu_thread = 1; /* stop handle_apdu thread */ 573 qemu_cond_signal(&card->handle_apdu_cond); 574 qemu_thread_join(&card->apdu_thread_id); 575 576 clean_event_notifier(card); 577 /* threads exited, can destroy all condvars/mutexes */ 578 qemu_cond_destroy(&card->handle_apdu_cond); 579 qemu_mutex_destroy(&card->handle_apdu_mutex); 580 qemu_mutex_destroy(&card->vreader_mutex); 581 qemu_mutex_destroy(&card->event_list_mutex); 582 } 583 584 static Property emulated_card_properties[] = { 585 DEFINE_PROP_STRING("backend", EmulatedState, backend_str), 586 DEFINE_PROP_STRING("cert1", EmulatedState, cert1), 587 DEFINE_PROP_STRING("cert2", EmulatedState, cert2), 588 DEFINE_PROP_STRING("cert3", EmulatedState, cert3), 589 DEFINE_PROP_STRING("db", EmulatedState, db), 590 DEFINE_PROP_UINT8("debug", EmulatedState, debug, 0), 591 DEFINE_PROP_END_OF_LIST(), 592 }; 593 594 static void emulated_class_initfn(ObjectClass *klass, void *data) 595 { 596 DeviceClass *dc = DEVICE_CLASS(klass); 597 CCIDCardClass *cc = CCID_CARD_CLASS(klass); 598 599 cc->realize = emulated_realize; 600 cc->unrealize = emulated_unrealize; 601 cc->get_atr = emulated_get_atr; 602 cc->apdu_from_guest = emulated_apdu_from_guest; 603 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 604 dc->desc = "emulated smartcard"; 605 dc->props = emulated_card_properties; 606 } 607 608 static const TypeInfo emulated_card_info = { 609 .name = TYPE_EMULATED_CCID, 610 .parent = TYPE_CCID_CARD, 611 .instance_size = sizeof(EmulatedState), 612 .class_init = emulated_class_initfn, 613 }; 614 615 static void ccid_card_emulated_register_types(void) 616 { 617 type_register_static(&emulated_card_info); 618 } 619 620 type_init(ccid_card_emulated_register_types) 621