1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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, ...) \
39do {\
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
53enum {
54 BACKEND_NSS_EMULATED = 1,
55 BACKEND_CERTIFICATES
56};
57
58#define DEFAULT_BACKEND BACKEND_NSS_EMULATED
59
60typedef struct EmulatedState EmulatedState;
61
62enum {
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
72static 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
93typedef 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
112struct 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;
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
136static 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
154static 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
162static 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
170static 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
179static 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
189static 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
201static void emulated_push_reader_insert(EmulatedState *card)
202{
203 emulated_push_type(card, EMUL_READER_INSERT);
204}
205
206static void emulated_push_reader_remove(EmulatedState *card)
207{
208 emulated_push_type(card, EMUL_READER_REMOVE);
209}
210
211static 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
217static void emulated_push_card_remove(EmulatedState *card)
218{
219 emulated_push_type(card, EMUL_CARD_REMOVE);
220}
221
222static 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
229static 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;
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
277static 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
294
295
296
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
309
310
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
338
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:
350 vevent_delete(event);
351 return NULL;
352 break;
353 default:
354 break;
355 }
356 vevent_delete(event);
357 }
358 return NULL;
359}
360
361static 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
403static 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
413static 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
423static 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
443static 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
459typedef struct EnumTable {
460 const char *name;
461 uint32_t value;
462} EnumTable;
463
464static const EnumTable backend_enum_table[] = {
465 {BACKEND_NSS_EMULATED_NAME, BACKEND_NSS_EMULATED},
466 {BACKEND_CERTIFICATES_NAME, BACKEND_CERTIFICATES},
467 {NULL, 0},
468};
469
470static 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
488static 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
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
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
555out2:
556 clean_event_notifier(card);
557out1:
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
564static 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);
570 qemu_thread_join(&card->event_thread_id);
571
572 card->quit_apdu_thread = 1;
573 qemu_cond_signal(&card->handle_apdu_cond);
574 qemu_thread_join(&card->apdu_thread_id);
575
576 clean_event_notifier(card);
577
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
584static 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
594static 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
608static 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
615static void ccid_card_emulated_register_types(void)
616{
617 type_register_static(&emulated_card_info);
618}
619
620type_init(ccid_card_emulated_register_types)
621