2 * CCID Card Device. Emulated card.
4 * Copyright (c) 2011 Red Hat.
5 * Written by Alon Levy.
7 * This code is licensed under the GNU LGPL, version 2 or later.
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.
14 * Usage 1: standard, mirror hardware reader+card:
15 * qemu .. -usb -device usb-ccid -device ccid-card-emulated
17 * Usage 2: use certificates, no hardware required
18 * one time: create the certificates:
20 * certutil -d /etc/pki/nssdb -x -t "CT,CT,CT" -S -s "CN=user$i" -n user$i
22 * qemu .. -usb -device usb-ccid \
23 * -device ccid-card-emulated,cert1=user1,cert2=user2,cert3=user3
25 * If you use a non default db for the certificates you can specify it using
29 #include "qemu/osdep.h"
33 #include <vcard_emul.h>
35 #include "qemu/thread.h"
36 #include "qemu/main-loop.h"
38 #include "qapi/error.h"
40 #define DPRINTF(card, lvl, fmt, ...) \
42 if (lvl <= card->debug) {\
43 printf("ccid-card-emul: %s: " fmt , __func__, ## __VA_ARGS__);\
48 #define TYPE_EMULATED_CCID "ccid-card-emulated"
49 #define EMULATED_CCID_CARD(obj) \
50 OBJECT_CHECK(EmulatedState, (obj), TYPE_EMULATED_CCID)
52 #define BACKEND_NSS_EMULATED_NAME "nss-emulated"
53 #define BACKEND_CERTIFICATES_NAME "certificates"
56 BACKEND_NSS_EMULATED
= 1,
60 #define DEFAULT_BACKEND BACKEND_NSS_EMULATED
62 typedef struct EmulatedState EmulatedState
;
65 EMUL_READER_INSERT
= 0,
74 static const char *emul_event_to_string(uint32_t emul_event
)
77 case EMUL_READER_INSERT
:
78 return "EMUL_READER_INSERT";
79 case EMUL_READER_REMOVE
:
80 return "EMUL_READER_REMOVE";
81 case EMUL_CARD_INSERT
:
82 return "EMUL_CARD_INSERT";
83 case EMUL_CARD_REMOVE
:
84 return "EMUL_CARD_REMOVE";
86 return "EMUL_GUEST_APDU";
87 case EMUL_RESPONSE_APDU
:
88 return "EMUL_RESPONSE_APDU";
95 typedef struct EmulEvent
{
96 QSIMPLEQ_ENTRY(EmulEvent
) entry
;
113 #define MAX_ATR_SIZE 40
114 struct EmulatedState
{
123 uint8_t atr
[MAX_ATR_SIZE
];
125 QSIMPLEQ_HEAD(event_list
, EmulEvent
) event_list
;
126 QemuMutex event_list_mutex
;
127 QemuThread event_thread_id
;
129 QSIMPLEQ_HEAD(guest_apdu_list
, EmulEvent
) guest_apdu_list
;
130 QemuMutex vreader_mutex
; /* and guest_apdu_list mutex */
131 QemuMutex handle_apdu_mutex
;
132 QemuCond handle_apdu_cond
;
133 EventNotifier notifier
;
134 int quit_apdu_thread
;
135 QemuThread apdu_thread_id
;
138 static void emulated_apdu_from_guest(CCIDCardState
*base
,
139 const uint8_t *apdu
, uint32_t len
)
141 EmulatedState
*card
= EMULATED_CCID_CARD(base
);
142 EmulEvent
*event
= (EmulEvent
*)g_malloc(sizeof(EmulEvent
) + len
);
145 event
->p
.data
.type
= EMUL_GUEST_APDU
;
146 event
->p
.data
.len
= len
;
147 memcpy(event
->p
.data
.data
, apdu
, len
);
148 qemu_mutex_lock(&card
->vreader_mutex
);
149 QSIMPLEQ_INSERT_TAIL(&card
->guest_apdu_list
, event
, entry
);
150 qemu_mutex_unlock(&card
->vreader_mutex
);
151 qemu_mutex_lock(&card
->handle_apdu_mutex
);
152 qemu_cond_signal(&card
->handle_apdu_cond
);
153 qemu_mutex_unlock(&card
->handle_apdu_mutex
);
156 static const uint8_t *emulated_get_atr(CCIDCardState
*base
, uint32_t *len
)
158 EmulatedState
*card
= EMULATED_CCID_CARD(base
);
160 *len
= card
->atr_length
;
164 static void emulated_push_event(EmulatedState
*card
, EmulEvent
*event
)
166 qemu_mutex_lock(&card
->event_list_mutex
);
167 QSIMPLEQ_INSERT_TAIL(&(card
->event_list
), event
, entry
);
168 qemu_mutex_unlock(&card
->event_list_mutex
);
169 event_notifier_set(&card
->notifier
);
172 static void emulated_push_type(EmulatedState
*card
, uint32_t type
)
174 EmulEvent
*event
= g_new(EmulEvent
, 1);
177 event
->p
.gen
.type
= type
;
178 emulated_push_event(card
, event
);
181 static void emulated_push_error(EmulatedState
*card
, uint64_t code
)
183 EmulEvent
*event
= g_new(EmulEvent
, 1);
186 event
->p
.error
.type
= EMUL_ERROR
;
187 event
->p
.error
.code
= code
;
188 emulated_push_event(card
, event
);
191 static void emulated_push_data_type(EmulatedState
*card
, uint32_t type
,
192 const uint8_t *data
, uint32_t len
)
194 EmulEvent
*event
= (EmulEvent
*)g_malloc(sizeof(EmulEvent
) + len
);
197 event
->p
.data
.type
= type
;
198 event
->p
.data
.len
= len
;
199 memcpy(event
->p
.data
.data
, data
, len
);
200 emulated_push_event(card
, event
);
203 static void emulated_push_reader_insert(EmulatedState
*card
)
205 emulated_push_type(card
, EMUL_READER_INSERT
);
208 static void emulated_push_reader_remove(EmulatedState
*card
)
210 emulated_push_type(card
, EMUL_READER_REMOVE
);
213 static void emulated_push_card_insert(EmulatedState
*card
,
214 const uint8_t *atr
, uint32_t len
)
216 emulated_push_data_type(card
, EMUL_CARD_INSERT
, atr
, len
);
219 static void emulated_push_card_remove(EmulatedState
*card
)
221 emulated_push_type(card
, EMUL_CARD_REMOVE
);
224 static void emulated_push_response_apdu(EmulatedState
*card
,
225 const uint8_t *apdu
, uint32_t len
)
227 emulated_push_data_type(card
, EMUL_RESPONSE_APDU
, apdu
, len
);
230 #define APDU_BUF_SIZE 270
231 static void *handle_apdu_thread(void* arg
)
233 EmulatedState
*card
= arg
;
234 uint8_t recv_data
[APDU_BUF_SIZE
];
236 VReaderStatus reader_status
;
240 qemu_mutex_lock(&card
->handle_apdu_mutex
);
241 qemu_cond_wait(&card
->handle_apdu_cond
, &card
->handle_apdu_mutex
);
242 qemu_mutex_unlock(&card
->handle_apdu_mutex
);
243 if (card
->quit_apdu_thread
) {
244 card
->quit_apdu_thread
= 0; /* debugging */
247 qemu_mutex_lock(&card
->vreader_mutex
);
248 while (!QSIMPLEQ_EMPTY(&card
->guest_apdu_list
)) {
249 event
= QSIMPLEQ_FIRST(&card
->guest_apdu_list
);
250 assert((unsigned long)event
> 1000);
251 QSIMPLEQ_REMOVE_HEAD(&card
->guest_apdu_list
, entry
);
252 if (event
->p
.data
.type
!= EMUL_GUEST_APDU
) {
253 DPRINTF(card
, 1, "unexpected message in handle_apdu_thread\n");
257 if (card
->reader
== NULL
) {
258 DPRINTF(card
, 1, "reader is NULL\n");
262 recv_len
= sizeof(recv_data
);
263 reader_status
= vreader_xfr_bytes(card
->reader
,
264 event
->p
.data
.data
, event
->p
.data
.len
,
265 recv_data
, &recv_len
);
266 DPRINTF(card
, 2, "got back apdu of length %d\n", recv_len
);
267 if (reader_status
== VREADER_OK
) {
268 emulated_push_response_apdu(card
, recv_data
, recv_len
);
270 emulated_push_error(card
, reader_status
);
274 qemu_mutex_unlock(&card
->vreader_mutex
);
279 static void *event_thread(void *arg
)
281 int atr_len
= MAX_ATR_SIZE
;
282 uint8_t atr
[MAX_ATR_SIZE
];
283 VEvent
*event
= NULL
;
284 EmulatedState
*card
= arg
;
287 const char *reader_name
;
289 event
= vevent_wait_next_vevent();
290 if (event
== NULL
|| event
->type
== VEVENT_LAST
) {
293 if (event
->type
!= VEVENT_READER_INSERT
) {
294 if (card
->reader
== NULL
&& event
->reader
!= NULL
) {
295 /* Happens after device_add followed by card remove or insert.
296 * XXX: create synthetic add_reader events if vcard_emul_init
297 * already called, which happens if device_del and device_add
299 card
->reader
= vreader_reference(event
->reader
);
301 if (event
->reader
!= card
->reader
) {
303 "ERROR: wrong reader: quiting event_thread\n");
308 switch (event
->type
) {
309 case VEVENT_READER_INSERT
:
310 /* TODO: take a specific reader. i.e. track which reader
311 * we are seeing here, check it is the one we want (the first,
312 * or by a particular name), and ignore if we don't want it.
314 reader_name
= vreader_get_name(event
->reader
);
315 if (card
->reader
!= NULL
) {
316 DPRINTF(card
, 2, "READER INSERT - replacing %s with %s\n",
317 vreader_get_name(card
->reader
), reader_name
);
318 qemu_mutex_lock(&card
->vreader_mutex
);
319 vreader_free(card
->reader
);
320 qemu_mutex_unlock(&card
->vreader_mutex
);
321 emulated_push_reader_remove(card
);
323 qemu_mutex_lock(&card
->vreader_mutex
);
324 DPRINTF(card
, 2, "READER INSERT %s\n", reader_name
);
325 card
->reader
= vreader_reference(event
->reader
);
326 qemu_mutex_unlock(&card
->vreader_mutex
);
327 emulated_push_reader_insert(card
);
329 case VEVENT_READER_REMOVE
:
330 DPRINTF(card
, 2, " READER REMOVE: %s\n",
331 vreader_get_name(event
->reader
));
332 qemu_mutex_lock(&card
->vreader_mutex
);
333 vreader_free(card
->reader
);
335 qemu_mutex_unlock(&card
->vreader_mutex
);
336 emulated_push_reader_remove(card
);
338 case VEVENT_CARD_INSERT
:
339 /* get the ATR (intended as a response to a power on from the
341 atr_len
= MAX_ATR_SIZE
;
342 vreader_power_on(event
->reader
, atr
, &atr_len
);
343 card
->atr_length
= (uint8_t)atr_len
;
344 DPRINTF(card
, 2, " CARD INSERT\n");
345 emulated_push_card_insert(card
, atr
, atr_len
);
347 case VEVENT_CARD_REMOVE
:
348 DPRINTF(card
, 2, " CARD REMOVE\n");
349 emulated_push_card_remove(card
);
351 case VEVENT_LAST
: /* quit */
352 vevent_delete(event
);
358 vevent_delete(event
);
363 static void card_event_handler(EventNotifier
*notifier
)
365 EmulatedState
*card
= container_of(notifier
, EmulatedState
, notifier
);
366 EmulEvent
*event
, *next
;
368 event_notifier_test_and_clear(&card
->notifier
);
369 qemu_mutex_lock(&card
->event_list_mutex
);
370 QSIMPLEQ_FOREACH_SAFE(event
, &card
->event_list
, entry
, next
) {
371 DPRINTF(card
, 2, "event %s\n", emul_event_to_string(event
->p
.gen
.type
));
372 switch (event
->p
.gen
.type
) {
373 case EMUL_RESPONSE_APDU
:
374 ccid_card_send_apdu_to_guest(&card
->base
, event
->p
.data
.data
,
377 case EMUL_READER_INSERT
:
378 ccid_card_ccid_attach(&card
->base
);
380 case EMUL_READER_REMOVE
:
381 ccid_card_ccid_detach(&card
->base
);
383 case EMUL_CARD_INSERT
:
384 assert(event
->p
.data
.len
<= MAX_ATR_SIZE
);
385 card
->atr_length
= event
->p
.data
.len
;
386 memcpy(card
->atr
, event
->p
.data
.data
, card
->atr_length
);
387 ccid_card_card_inserted(&card
->base
);
389 case EMUL_CARD_REMOVE
:
390 ccid_card_card_removed(&card
->base
);
393 ccid_card_card_error(&card
->base
, event
->p
.error
.code
);
396 DPRINTF(card
, 2, "unexpected event\n");
401 QSIMPLEQ_INIT(&card
->event_list
);
402 qemu_mutex_unlock(&card
->event_list_mutex
);
405 static int init_event_notifier(EmulatedState
*card
, Error
**errp
)
407 if (event_notifier_init(&card
->notifier
, false) < 0) {
408 error_setg(errp
, "ccid-card-emul: event notifier creation failed");
411 event_notifier_set_handler(&card
->notifier
, card_event_handler
);
415 #define CERTIFICATES_DEFAULT_DB "/etc/pki/nssdb"
416 #define CERTIFICATES_ARGS_TEMPLATE\
417 "db=\"%s\" use_hw=no soft=(,Virtual Reader,CAC,,%s,%s,%s)"
419 static int wrap_vcard_emul_init(VCardEmulOptions
*options
)
422 static int options_was_null
;
425 if ((options
== NULL
) != options_was_null
) {
426 printf("%s: warning: running emulated with certificates"
427 " and emulated side by side is not supported\n",
429 return VCARD_EMUL_FAIL
;
431 vcard_emul_replay_insertion_events();
432 return VCARD_EMUL_OK
;
434 options_was_null
= (options
== NULL
);
436 return vcard_emul_init(options
);
439 static int emulated_initialize_vcard_from_certificates(EmulatedState
*card
)
442 VCardEmulOptions
*options
= NULL
;
444 snprintf(emul_args
, sizeof(emul_args
) - 1, CERTIFICATES_ARGS_TEMPLATE
,
445 card
->db
? card
->db
: CERTIFICATES_DEFAULT_DB
,
446 card
->cert1
, card
->cert2
, card
->cert3
);
447 options
= vcard_emul_options(emul_args
);
448 if (options
== NULL
) {
449 printf("%s: warning: not using certificates due to"
450 " initialization error\n", __func__
);
452 return wrap_vcard_emul_init(options
);
455 typedef struct EnumTable
{
460 static const EnumTable backend_enum_table
[] = {
461 {BACKEND_NSS_EMULATED_NAME
, BACKEND_NSS_EMULATED
},
462 {BACKEND_CERTIFICATES_NAME
, BACKEND_CERTIFICATES
},
466 static uint32_t parse_enumeration(char *str
,
467 const EnumTable
*table
, uint32_t not_found_value
)
469 uint32_t ret
= not_found_value
;
474 while (table
->name
!= NULL
) {
475 if (strcmp(table
->name
, str
) == 0) {
484 static void emulated_realize(CCIDCardState
*base
, Error
**errp
)
486 EmulatedState
*card
= EMULATED_CCID_CARD(base
);
488 const EnumTable
*ptable
;
490 QSIMPLEQ_INIT(&card
->event_list
);
491 QSIMPLEQ_INIT(&card
->guest_apdu_list
);
492 qemu_mutex_init(&card
->event_list_mutex
);
493 qemu_mutex_init(&card
->vreader_mutex
);
494 qemu_mutex_init(&card
->handle_apdu_mutex
);
495 qemu_cond_init(&card
->handle_apdu_cond
);
497 card
->quit_apdu_thread
= 0;
498 if (init_event_notifier(card
, errp
) < 0) {
503 if (card
->backend_str
) {
504 card
->backend
= parse_enumeration(card
->backend_str
,
505 backend_enum_table
, 0);
508 if (card
->backend
== 0) {
509 error_setg(errp
, "backend must be one of:");
510 for (ptable
= backend_enum_table
; ptable
->name
!= NULL
; ++ptable
) {
511 error_append_hint(errp
, "%s\n", ptable
->name
);
516 /* TODO: a passthru backened that works on local machine. third card type?*/
517 if (card
->backend
== BACKEND_CERTIFICATES
) {
518 if (card
->cert1
!= NULL
&& card
->cert2
!= NULL
&& card
->cert3
!= NULL
) {
519 ret
= emulated_initialize_vcard_from_certificates(card
);
521 error_setg(errp
, "%s: you must provide all three certs for"
522 " certificates backend", TYPE_EMULATED_CCID
);
526 if (card
->backend
!= BACKEND_NSS_EMULATED
) {
527 error_setg(errp
, "%s: bad backend specified. The options are:%s"
528 " (default), %s.", TYPE_EMULATED_CCID
,
529 BACKEND_NSS_EMULATED_NAME
, BACKEND_CERTIFICATES_NAME
);
532 if (card
->cert1
!= NULL
|| card
->cert2
!= NULL
|| card
->cert3
!= NULL
) {
533 error_setg(errp
, "%s: unexpected cert parameters to nss emulated "
534 "backend", TYPE_EMULATED_CCID
);
537 /* default to mirroring the local hardware readers */
538 ret
= wrap_vcard_emul_init(NULL
);
540 if (ret
!= VCARD_EMUL_OK
) {
541 error_setg(errp
, "%s: failed to initialize vcard", TYPE_EMULATED_CCID
);
544 qemu_thread_create(&card
->event_thread_id
, "ccid/event", event_thread
,
545 card
, QEMU_THREAD_JOINABLE
);
546 qemu_thread_create(&card
->apdu_thread_id
, "ccid/apdu", handle_apdu_thread
,
547 card
, QEMU_THREAD_JOINABLE
);
550 static void emulated_unrealize(CCIDCardState
*base
, Error
**errp
)
552 EmulatedState
*card
= EMULATED_CCID_CARD(base
);
553 VEvent
*vevent
= vevent_new(VEVENT_LAST
, NULL
, NULL
);
555 vevent_queue_vevent(vevent
); /* stop vevent thread */
556 qemu_thread_join(&card
->event_thread_id
);
558 card
->quit_apdu_thread
= 1; /* stop handle_apdu thread */
559 qemu_cond_signal(&card
->handle_apdu_cond
);
560 qemu_thread_join(&card
->apdu_thread_id
);
562 /* threads exited, can destroy all condvars/mutexes */
563 qemu_cond_destroy(&card
->handle_apdu_cond
);
564 qemu_mutex_destroy(&card
->handle_apdu_mutex
);
565 qemu_mutex_destroy(&card
->vreader_mutex
);
566 qemu_mutex_destroy(&card
->event_list_mutex
);
569 static Property emulated_card_properties
[] = {
570 DEFINE_PROP_STRING("backend", EmulatedState
, backend_str
),
571 DEFINE_PROP_STRING("cert1", EmulatedState
, cert1
),
572 DEFINE_PROP_STRING("cert2", EmulatedState
, cert2
),
573 DEFINE_PROP_STRING("cert3", EmulatedState
, cert3
),
574 DEFINE_PROP_STRING("db", EmulatedState
, db
),
575 DEFINE_PROP_UINT8("debug", EmulatedState
, debug
, 0),
576 DEFINE_PROP_END_OF_LIST(),
579 static void emulated_class_initfn(ObjectClass
*klass
, void *data
)
581 DeviceClass
*dc
= DEVICE_CLASS(klass
);
582 CCIDCardClass
*cc
= CCID_CARD_CLASS(klass
);
584 cc
->realize
= emulated_realize
;
585 cc
->unrealize
= emulated_unrealize
;
586 cc
->get_atr
= emulated_get_atr
;
587 cc
->apdu_from_guest
= emulated_apdu_from_guest
;
588 set_bit(DEVICE_CATEGORY_INPUT
, dc
->categories
);
589 dc
->desc
= "emulated smartcard";
590 dc
->props
= emulated_card_properties
;
593 static const TypeInfo emulated_card_info
= {
594 .name
= TYPE_EMULATED_CCID
,
595 .parent
= TYPE_CCID_CARD
,
596 .instance_size
= sizeof(EmulatedState
),
597 .class_init
= emulated_class_initfn
,
600 static void ccid_card_emulated_register_types(void)
602 type_register_static(&emulated_card_info
);
605 type_init(ccid_card_emulated_register_types
)