[qemu.git] / hw / ccid-card-emulated.c

/*
 * CCID Card Device. Emulated card.
 *
 * Copyright (c) 2011 Red Hat.
 * Written by Alon Levy.
 *
 * This code is licensed under the GNU LGPL, version 2 or later.
 */

/*
 * It can be used to provide access to the local hardware in a non exclusive
 * way, or it can use certificates. It requires the usb-ccid bus.
 *
 * Usage 1: standard, mirror hardware reader+card:
 * qemu .. -usb -device usb-ccid -device ccid-card-emulated
 *
 * Usage 2: use certificates, no hardware required
 * one time: create the certificates:
 *  for i in 1 2 3; do
 *      certutil -d /etc/pki/nssdb -x -t "CT,CT,CT" -S -s "CN=user$i" -n user$i
 *  done
 * qemu .. -usb -device usb-ccid \
 *  -device ccid-card-emulated,cert1=user1,cert2=user2,cert3=user3
 *
 * If you use a non default db for the certificates you can specify it using
 * the db parameter.
 */

#include <eventt.h>
#include <vevent.h>
#include <vreader.h>
#include <vcard_emul.h>

#include "qemu/thread.h"
#include "char/char.h"
#include "monitor/monitor.h"
#include "hw/ccid.h"

#define DPRINTF(card, lvl, fmt, ...) \
do {\
    if (lvl <= card->debug) {\
        printf("ccid-card-emul: %s: " fmt , __func__, ## __VA_ARGS__);\
    } \
} while (0)

#define EMULATED_DEV_NAME "ccid-card-emulated"

#define BACKEND_NSS_EMULATED_NAME "nss-emulated"
#define BACKEND_CERTIFICATES_NAME "certificates"

enum {
    BACKEND_NSS_EMULATED = 1,
    BACKEND_CERTIFICATES
};

#define DEFAULT_BACKEND BACKEND_NSS_EMULATED

typedef struct EmulatedState EmulatedState;

enum {
    EMUL_READER_INSERT = 0,
    EMUL_READER_REMOVE,
    EMUL_CARD_INSERT,
    EMUL_CARD_REMOVE,
    EMUL_GUEST_APDU,
    EMUL_RESPONSE_APDU,
    EMUL_ERROR,
};

static const char *emul_event_to_string(uint32_t emul_event)
{
    switch (emul_event) {
    case EMUL_READER_INSERT:
        return "EMUL_READER_INSERT";
    case EMUL_READER_REMOVE:
        return "EMUL_READER_REMOVE";
    case EMUL_CARD_INSERT:
        return "EMUL_CARD_INSERT";
    case EMUL_CARD_REMOVE:
        return "EMUL_CARD_REMOVE";
    case EMUL_GUEST_APDU:
        return "EMUL_GUEST_APDU";
    case EMUL_RESPONSE_APDU:
        return "EMUL_RESPONSE_APDU";
    case EMUL_ERROR:
        return "EMUL_ERROR";
    }
    return "UNKNOWN";
}

typedef struct EmulEvent {
    QSIMPLEQ_ENTRY(EmulEvent) entry;
    union {
        struct {
            uint32_t type;
        } gen;
        struct {
            uint32_t type;
            uint64_t code;
        } error;
        struct {
            uint32_t type;
            uint32_t len;
            uint8_t data[];
        } data;
    } p;
} EmulEvent;

#define MAX_ATR_SIZE 40
struct EmulatedState {
    CCIDCardState base;
    uint8_t  debug;
    char    *backend_str;
    uint32_t backend;
    char    *cert1;
    char    *cert2;
    char    *cert3;
    char    *db;
    uint8_t  atr[MAX_ATR_SIZE];
    uint8_t  atr_length;
    QSIMPLEQ_HEAD(event_list, EmulEvent) event_list;
    QemuMutex event_list_mutex;
    QemuThread event_thread_id;
    VReader *reader;
    QSIMPLEQ_HEAD(guest_apdu_list, EmulEvent) guest_apdu_list;
    QemuMutex vreader_mutex; /* and guest_apdu_list mutex */
    QemuMutex handle_apdu_mutex;
    QemuCond handle_apdu_cond;
    int      pipe[2];
    int      quit_apdu_thread;
    QemuThread apdu_thread_id;
};

static void emulated_apdu_from_guest(CCIDCardState *base,
    const uint8_t *apdu, uint32_t len)
{
    EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
    EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent) + len);

    assert(event);
    event->p.data.type = EMUL_GUEST_APDU;
    event->p.data.len = len;
    memcpy(event->p.data.data, apdu, len);
    qemu_mutex_lock(&card->vreader_mutex);
    QSIMPLEQ_INSERT_TAIL(&card->guest_apdu_list, event, entry);
    qemu_mutex_unlock(&card->vreader_mutex);
    qemu_mutex_lock(&card->handle_apdu_mutex);
    qemu_cond_signal(&card->handle_apdu_cond);
    qemu_mutex_unlock(&card->handle_apdu_mutex);
}

static const uint8_t *emulated_get_atr(CCIDCardState *base, uint32_t *len)
{
    EmulatedState *card = DO_UPCAST(EmulatedState, base, base);

    *len = card->atr_length;
    return card->atr;
}

static void emulated_push_event(EmulatedState *card, EmulEvent *event)
{
    qemu_mutex_lock(&card->event_list_mutex);
    QSIMPLEQ_INSERT_TAIL(&(card->event_list), event, entry);
    qemu_mutex_unlock(&card->event_list_mutex);
    if (write(card->pipe[1], card, 1) != 1) {
        DPRINTF(card, 1, "write to pipe failed\n");
    }
}

static void emulated_push_type(EmulatedState *card, uint32_t type)
{
    EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent));

    assert(event);
    event->p.gen.type = type;
    emulated_push_event(card, event);
}

static void emulated_push_error(EmulatedState *card, uint64_t code)
{
    EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent));

    assert(event);
    event->p.error.type = EMUL_ERROR;
    event->p.error.code = code;
    emulated_push_event(card, event);
}

static void emulated_push_data_type(EmulatedState *card, uint32_t type,
    const uint8_t *data, uint32_t len)
{
    EmulEvent *event = (EmulEvent *)g_malloc(sizeof(EmulEvent) + len);

    assert(event);
    event->p.data.type = type;
    event->p.data.len = len;
    memcpy(event->p.data.data, data, len);
    emulated_push_event(card, event);
}

static void emulated_push_reader_insert(EmulatedState *card)
{
    emulated_push_type(card, EMUL_READER_INSERT);
}

static void emulated_push_reader_remove(EmulatedState *card)
{
    emulated_push_type(card, EMUL_READER_REMOVE);
}

static void emulated_push_card_insert(EmulatedState *card,
    const uint8_t *atr, uint32_t len)
{
    emulated_push_data_type(card, EMUL_CARD_INSERT, atr, len);
}

static void emulated_push_card_remove(EmulatedState *card)
{
    emulated_push_type(card, EMUL_CARD_REMOVE);
}

static void emulated_push_response_apdu(EmulatedState *card,
    const uint8_t *apdu, uint32_t len)
{
    emulated_push_data_type(card, EMUL_RESPONSE_APDU, apdu, len);
}

#define APDU_BUF_SIZE 270
static void *handle_apdu_thread(void* arg)
{
    EmulatedState *card = arg;
    uint8_t recv_data[APDU_BUF_SIZE];
    int recv_len;
    VReaderStatus reader_status;
    EmulEvent *event;

    while (1) {
        qemu_mutex_lock(&card->handle_apdu_mutex);
        qemu_cond_wait(&card->handle_apdu_cond, &card->handle_apdu_mutex);
        qemu_mutex_unlock(&card->handle_apdu_mutex);
        if (card->quit_apdu_thread) {
            card->quit_apdu_thread = 0; /* debugging */
            break;
        }
        qemu_mutex_lock(&card->vreader_mutex);
        while (!QSIMPLEQ_EMPTY(&card->guest_apdu_list)) {
            event = QSIMPLEQ_FIRST(&card->guest_apdu_list);
            assert((unsigned long)event > 1000);
            QSIMPLEQ_REMOVE_HEAD(&card->guest_apdu_list, entry);
            if (event->p.data.type != EMUL_GUEST_APDU) {
                DPRINTF(card, 1, "unexpected message in handle_apdu_thread\n");
                g_free(event);
                continue;
            }
            if (card->reader == NULL) {
                DPRINTF(card, 1, "reader is NULL\n");
                g_free(event);
                continue;
            }
            recv_len = sizeof(recv_data);
            reader_status = vreader_xfr_bytes(card->reader,
                    event->p.data.data, event->p.data.len,
                    recv_data, &recv_len);
            DPRINTF(card, 2, "got back apdu of length %d\n", recv_len);
            if (reader_status == VREADER_OK) {
                emulated_push_response_apdu(card, recv_data, recv_len);
            } else {
                emulated_push_error(card, reader_status);
            }
            g_free(event);
        }
        qemu_mutex_unlock(&card->vreader_mutex);
    }
    return NULL;
}

static void *event_thread(void *arg)
{
    int atr_len = MAX_ATR_SIZE;
    uint8_t atr[MAX_ATR_SIZE];
    VEvent *event = NULL;
    EmulatedState *card = arg;

    while (1) {
        const char *reader_name;

        event = vevent_wait_next_vevent();
        if (event == NULL || event->type == VEVENT_LAST) {
            break;
        }
        if (event->type != VEVENT_READER_INSERT) {
            if (card->reader == NULL && event->reader != NULL) {
                /* Happens after device_add followed by card remove or insert.
                 * XXX: create synthetic add_reader events if vcard_emul_init
                 * already called, which happens if device_del and device_add
                 * are called */
                card->reader = vreader_reference(event->reader);
            } else {
                if (event->reader != card->reader) {
                    fprintf(stderr,
                        "ERROR: wrong reader: quiting event_thread\n");
                    break;
                }
            }
        }
        switch (event->type) {
        case VEVENT_READER_INSERT:
            /* TODO: take a specific reader. i.e. track which reader
             * we are seeing here, check it is the one we want (the first,
             * or by a particular name), and ignore if we don't want it.
             */
            reader_name = vreader_get_name(event->reader);
            if (card->reader != NULL) {
                DPRINTF(card, 2, "READER INSERT - replacing %s with %s\n",
                    vreader_get_name(card->reader), reader_name);
                qemu_mutex_lock(&card->vreader_mutex);
                vreader_free(card->reader);
                qemu_mutex_unlock(&card->vreader_mutex);
                emulated_push_reader_remove(card);
            }
            qemu_mutex_lock(&card->vreader_mutex);
            DPRINTF(card, 2, "READER INSERT %s\n", reader_name);
            card->reader = vreader_reference(event->reader);
            qemu_mutex_unlock(&card->vreader_mutex);
            emulated_push_reader_insert(card);
            break;
        case VEVENT_READER_REMOVE:
            DPRINTF(card, 2, " READER REMOVE: %s\n",
                    vreader_get_name(event->reader));
            qemu_mutex_lock(&card->vreader_mutex);
            vreader_free(card->reader);
            card->reader = NULL;
            qemu_mutex_unlock(&card->vreader_mutex);
            emulated_push_reader_remove(card);
            break;
        case VEVENT_CARD_INSERT:
            /* get the ATR (intended as a response to a power on from the
             * reader */
            atr_len = MAX_ATR_SIZE;
            vreader_power_on(event->reader, atr, &atr_len);
            card->atr_length = (uint8_t)atr_len;
            DPRINTF(card, 2, " CARD INSERT\n");
            emulated_push_card_insert(card, atr, atr_len);
            break;
        case VEVENT_CARD_REMOVE:
            DPRINTF(card, 2, " CARD REMOVE\n");
            emulated_push_card_remove(card);
            break;
        case VEVENT_LAST: /* quit */
            vevent_delete(event);
            return NULL;
            break;
        default:
            break;
        }
        vevent_delete(event);
    }
    return NULL;
}

static void pipe_read(void *opaque)
{
    EmulatedState *card = opaque;
    EmulEvent *event, *next;
    char dummy;
    int len;

    do {
        len = read(card->pipe[0], &dummy, sizeof(dummy));
    } while (len == sizeof(dummy));
    qemu_mutex_lock(&card->event_list_mutex);
    QSIMPLEQ_FOREACH_SAFE(event, &card->event_list, entry, next) {
        DPRINTF(card, 2, "event %s\n", emul_event_to_string(event->p.gen.type));
        switch (event->p.gen.type) {
        case EMUL_RESPONSE_APDU:
            ccid_card_send_apdu_to_guest(&card->base, event->p.data.data,
                event->p.data.len);
            break;
        case EMUL_READER_INSERT:
            ccid_card_ccid_attach(&card->base);
            break;
        case EMUL_READER_REMOVE:
            ccid_card_ccid_detach(&card->base);
            break;
        case EMUL_CARD_INSERT:
            assert(event->p.data.len <= MAX_ATR_SIZE);
            card->atr_length = event->p.data.len;
            memcpy(card->atr, event->p.data.data, card->atr_length);
            ccid_card_card_inserted(&card->base);
            break;
        case EMUL_CARD_REMOVE:
            ccid_card_card_removed(&card->base);
            break;
        case EMUL_ERROR:
            ccid_card_card_error(&card->base, event->p.error.code);
            break;
        default:
            DPRINTF(card, 2, "unexpected event\n");
            break;
        }
        g_free(event);
    }
    QSIMPLEQ_INIT(&card->event_list);
    qemu_mutex_unlock(&card->event_list_mutex);
}

static int init_pipe_signaling(EmulatedState *card)
{
    if (pipe(card->pipe) < 0) {
        DPRINTF(card, 2, "pipe creation failed\n");
        return -1;
    }
    fcntl(card->pipe[0], F_SETFL, O_NONBLOCK);
    fcntl(card->pipe[1], F_SETFL, O_NONBLOCK);
    fcntl(card->pipe[0], F_SETOWN, getpid());
    qemu_set_fd_handler(card->pipe[0], pipe_read, NULL, card);
    return 0;
}

#define CERTIFICATES_DEFAULT_DB "/etc/pki/nssdb"
#define CERTIFICATES_ARGS_TEMPLATE\
    "db=\"%s\" use_hw=no soft=(,Virtual Reader,CAC,,%s,%s,%s)"

static int wrap_vcard_emul_init(VCardEmulOptions *options)
{
    static int called;
    static int options_was_null;

    if (called) {
        if ((options == NULL) != options_was_null) {
            printf("%s: warning: running emulated with certificates"
                   " and emulated side by side is not supported\n",
                   __func__);
            return VCARD_EMUL_FAIL;
        }
        vcard_emul_replay_insertion_events();
        return VCARD_EMUL_OK;
    }
    options_was_null = (options == NULL);
    called = 1;
    return vcard_emul_init(options);
}

static int emulated_initialize_vcard_from_certificates(EmulatedState *card)
{
    char emul_args[200];
    VCardEmulOptions *options = NULL;

    snprintf(emul_args, sizeof(emul_args) - 1, CERTIFICATES_ARGS_TEMPLATE,
        card->db ? card->db : CERTIFICATES_DEFAULT_DB,
        card->cert1, card->cert2, card->cert3);
    options = vcard_emul_options(emul_args);
    if (options == NULL) {
        printf("%s: warning: not using certificates due to"
               " initialization error\n", __func__);
    }
    return wrap_vcard_emul_init(options);
}

typedef struct EnumTable {
    const char *name;
    uint32_t value;
} EnumTable;

EnumTable backend_enum_table[] = {
    {BACKEND_NSS_EMULATED_NAME, BACKEND_NSS_EMULATED},
    {BACKEND_CERTIFICATES_NAME, BACKEND_CERTIFICATES},
    {NULL, 0},
};

static uint32_t parse_enumeration(char *str,
    EnumTable *table, uint32_t not_found_value)
{
    uint32_t ret = not_found_value;

    while (table->name != NULL) {
        if (strcmp(table->name, str) == 0) {
            ret = table->value;
            break;
        }
        table++;
    }
    return ret;
}

static int emulated_initfn(CCIDCardState *base)
{
    EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
    VCardEmulError ret;
    EnumTable *ptable;

    QSIMPLEQ_INIT(&card->event_list);
    QSIMPLEQ_INIT(&card->guest_apdu_list);
    qemu_mutex_init(&card->event_list_mutex);
    qemu_mutex_init(&card->vreader_mutex);
    qemu_mutex_init(&card->handle_apdu_mutex);
    qemu_cond_init(&card->handle_apdu_cond);
    card->reader = NULL;
    card->quit_apdu_thread = 0;
    if (init_pipe_signaling(card) < 0) {
        return -1;
    }
    card->backend = parse_enumeration(card->backend_str, backend_enum_table, 0);
    if (card->backend == 0) {
        printf("unknown backend, must be one of:\n");
        for (ptable = backend_enum_table; ptable->name != NULL; ++ptable) {
            printf("%s\n", ptable->name);
        }
        return -1;
    }

    /* TODO: a passthru backened that works on local machine. third card type?*/
    if (card->backend == BACKEND_CERTIFICATES) {
        if (card->cert1 != NULL && card->cert2 != NULL && card->cert3 != NULL) {
            ret = emulated_initialize_vcard_from_certificates(card);
        } else {
            printf("%s: you must provide all three certs for"
                   " certificates backend\n", EMULATED_DEV_NAME);
            return -1;
        }
    } else {
        if (card->backend != BACKEND_NSS_EMULATED) {
            printf("%s: bad backend specified. The options are:\n%s (default),"
                " %s.\n", EMULATED_DEV_NAME, BACKEND_NSS_EMULATED_NAME,
                BACKEND_CERTIFICATES_NAME);
            return -1;
        }
        if (card->cert1 != NULL || card->cert2 != NULL || card->cert3 != NULL) {
            printf("%s: unexpected cert parameters to nss emulated backend\n",
                   EMULATED_DEV_NAME);
            return -1;
        }
        /* default to mirroring the local hardware readers */
        ret = wrap_vcard_emul_init(NULL);
    }
    if (ret != VCARD_EMUL_OK) {
        printf("%s: failed to initialize vcard\n", EMULATED_DEV_NAME);
        return -1;
    }
    qemu_thread_create(&card->event_thread_id, event_thread, card,
                       QEMU_THREAD_JOINABLE);
    qemu_thread_create(&card->apdu_thread_id, handle_apdu_thread, card,
                       QEMU_THREAD_JOINABLE);
    return 0;
}

static int emulated_exitfn(CCIDCardState *base)
{
    EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
    VEvent *vevent = vevent_new(VEVENT_LAST, NULL, NULL);

    vevent_queue_vevent(vevent); /* stop vevent thread */
    qemu_thread_join(&card->event_thread_id);

    card->quit_apdu_thread = 1; /* stop handle_apdu thread */
    qemu_cond_signal(&card->handle_apdu_cond);
    qemu_thread_join(&card->apdu_thread_id);

    /* threads exited, can destroy all condvars/mutexes */
    qemu_cond_destroy(&card->handle_apdu_cond);
    qemu_mutex_destroy(&card->handle_apdu_mutex);
    qemu_mutex_destroy(&card->vreader_mutex);
    qemu_mutex_destroy(&card->event_list_mutex);
    return 0;
}

static Property emulated_card_properties[] = {
    DEFINE_PROP_STRING("backend", EmulatedState, backend_str),
    DEFINE_PROP_STRING("cert1", EmulatedState, cert1),
    DEFINE_PROP_STRING("cert2", EmulatedState, cert2),
    DEFINE_PROP_STRING("cert3", EmulatedState, cert3),
    DEFINE_PROP_STRING("db", EmulatedState, db),
    DEFINE_PROP_UINT8("debug", EmulatedState, debug, 0),
    DEFINE_PROP_END_OF_LIST(),
};

static void emulated_class_initfn(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);
    CCIDCardClass *cc = CCID_CARD_CLASS(klass);

    cc->initfn = emulated_initfn;
    cc->exitfn = emulated_exitfn;
    cc->get_atr = emulated_get_atr;
    cc->apdu_from_guest = emulated_apdu_from_guest;
    dc->desc = "emulated smartcard";
    dc->props = emulated_card_properties;
}

static const TypeInfo emulated_card_info = {
    .name          = EMULATED_DEV_NAME,
    .parent        = TYPE_CCID_CARD,
    .instance_size = sizeof(EmulatedState),
    .class_init    = emulated_class_initfn,
};

static void ccid_card_emulated_register_types(void)
{
    type_register_static(&emulated_card_info);
}

type_init(ccid_card_emulated_register_types)
Commit	Line	Data
585738a6 AL	1	/*
	2	* CCID Card Device. Emulated card.
	3	*
	4	* Copyright (c) 2011 Red Hat.
	5	* Written by Alon Levy.
	6	*
8e31bf38	7	* This code is licensed under the GNU LGPL, version 2 or later.
585738a6 AL	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 <eventt.h>
	30	#include <vevent.h>
	31	#include <vreader.h>
	32	#include <vcard_emul.h>
	33
1de7afc9	34	#include "qemu/thread.h"
927d4878	35	#include "char/char.h"
83c9089e	36	#include "monitor/monitor.h"
585738a6 AL	37	#include "hw/ccid.h"
	38
	39	#define DPRINTF(card, lvl, fmt, ...) \
	40	do {\
	41	if (lvl <= card->debug) {\
	42	printf("ccid-card-emul: %s: " fmt , __func__, ## __VA_ARGS__);\
	43	} \
	44	} while (0)
	45
	46	#define EMULATED_DEV_NAME "ccid-card-emulated"
	47
	48	#define BACKEND_NSS_EMULATED_NAME "nss-emulated"
	49	#define BACKEND_CERTIFICATES_NAME "certificates"
	50
	51	enum {
	52	BACKEND_NSS_EMULATED = 1,
	53	BACKEND_CERTIFICATES
	54	};
	55
	56	#define DEFAULT_BACKEND BACKEND_NSS_EMULATED
	57
	58	typedef struct EmulatedState EmulatedState;
	59
	60	enum {
	61	EMUL_READER_INSERT = 0,
	62	EMUL_READER_REMOVE,
	63	EMUL_CARD_INSERT,
	64	EMUL_CARD_REMOVE,
	65	EMUL_GUEST_APDU,
	66	EMUL_RESPONSE_APDU,
	67	EMUL_ERROR,
	68	};
	69
	70	static const char *emul_event_to_string(uint32_t emul_event)
	71	{
	72	switch (emul_event) {
	73	case EMUL_READER_INSERT:
	74	return "EMUL_READER_INSERT";
	75	case EMUL_READER_REMOVE:
	76	return "EMUL_READER_REMOVE";
	77	case EMUL_CARD_INSERT:
	78	return "EMUL_CARD_INSERT";
	79	case EMUL_CARD_REMOVE:
	80	return "EMUL_CARD_REMOVE";
	81	case EMUL_GUEST_APDU:
	82	return "EMUL_GUEST_APDU";
	83	case EMUL_RESPONSE_APDU:
	84	return "EMUL_RESPONSE_APDU";
	85	case EMUL_ERROR:
	86	return "EMUL_ERROR";
	87	}
	88	return "UNKNOWN";
	89	}
	90
	91	typedef struct EmulEvent {
	92	QSIMPLEQ_ENTRY(EmulEvent) entry;
	93	union {
	94	struct {
	95	uint32_t type;
	96	} gen;
	97	struct {
	98	uint32_t type;
	99	uint64_t code;
	100	} error;
101	struct {
102	uint32_t type;
103	uint32_t len;
104	uint8_t data[];
105	} data;
106	} p;
107	} EmulEvent;
108
109	#define MAX_ATR_SIZE 40
110	struct EmulatedState {
111	CCIDCardState base;
112	uint8_t debug;
113	char *backend_str;
114	uint32_t backend;
115	char *cert1;
116	char *cert2;
117	char *cert3;
118	char *db;
119	uint8_t atr[MAX_ATR_SIZE];
120	uint8_t atr_length;
121	QSIMPLEQ_HEAD(event_list, EmulEvent) event_list;
122	QemuMutex event_list_mutex;
da5361cc	123	QemuThread event_thread_id;
585738a6 AL	124	VReader *reader;
	125	QSIMPLEQ_HEAD(guest_apdu_list, EmulEvent) guest_apdu_list;
	126	QemuMutex vreader_mutex; /* and guest_apdu_list mutex */
	127	QemuMutex handle_apdu_mutex;
	128	QemuCond handle_apdu_cond;
	129	int pipe[2];
	130	int quit_apdu_thread;
da5361cc	131	QemuThread apdu_thread_id;
585738a6 AL	132	};
	133
	134	static void emulated_apdu_from_guest(CCIDCardState *base,
	135	const uint8_t *apdu, uint32_t len)
	136	{
	137	EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
7267c094	138	EmulEvent event = (EmulEvent )g_malloc(sizeof(EmulEvent) + len);
585738a6 AL	139
	140	assert(event);
	141	event->p.data.type = EMUL_GUEST_APDU;
	142	event->p.data.len = len;
	143	memcpy(event->p.data.data, apdu, len);
	144	qemu_mutex_lock(&card->vreader_mutex);
	145	QSIMPLEQ_INSERT_TAIL(&card->guest_apdu_list, event, entry);
	146	qemu_mutex_unlock(&card->vreader_mutex);
	147	qemu_mutex_lock(&card->handle_apdu_mutex);
	148	qemu_cond_signal(&card->handle_apdu_cond);
	149	qemu_mutex_unlock(&card->handle_apdu_mutex);
	150	}
	151
	152	static const uint8_t emulated_get_atr(CCIDCardState base, uint32_t *len)
	153	{
	154	EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
	155
	156	*len = card->atr_length;
	157	return card->atr;
	158	}
	159
	160	static void emulated_push_event(EmulatedState card, EmulEvent event)
	161	{
	162	qemu_mutex_lock(&card->event_list_mutex);
	163	QSIMPLEQ_INSERT_TAIL(&(card->event_list), event, entry);
	164	qemu_mutex_unlock(&card->event_list_mutex);
	165	if (write(card->pipe[1], card, 1) != 1) {
	166	DPRINTF(card, 1, "write to pipe failed\n");
	167	}
	168	}
	169
	170	static void emulated_push_type(EmulatedState *card, uint32_t type)
	171	{
7267c094	172	EmulEvent event = (EmulEvent )g_malloc(sizeof(EmulEvent));
585738a6 AL	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	{
7267c094	181	EmulEvent event = (EmulEvent )g_malloc(sizeof(EmulEvent));
585738a6 AL	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	{
7267c094	192	EmulEvent event = (EmulEvent )g_malloc(sizeof(EmulEvent) + len);
585738a6 AL	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");
7267c094	252	g_free(event);
585738a6 AL	253	continue;
	254	}
	255	if (card->reader == NULL) {
	256	DPRINTF(card, 1, "reader is NULL\n");
7267c094	257	g_free(event);
585738a6 AL	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	}
7267c094	270	g_free(event);
585738a6 AL	271	}
	272	qemu_mutex_unlock(&card->vreader_mutex);
	273	}
585738a6 AL	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 pipe_read(void *opaque)
362	{
363	EmulatedState *card = opaque;
364	EmulEvent event, next;
365	char dummy;
366	int len;
367
368	do {
369	len = read(card->pipe[0], &dummy, sizeof(dummy));
370	} while (len == sizeof(dummy));
371	qemu_mutex_lock(&card->event_list_mutex);
372	QSIMPLEQ_FOREACH_SAFE(event, &card->event_list, entry, next) {
373	DPRINTF(card, 2, "event %s\n", emul_event_to_string(event->p.gen.type));
374	switch (event->p.gen.type) {
375	case EMUL_RESPONSE_APDU:
376	ccid_card_send_apdu_to_guest(&card->base, event->p.data.data,
377	event->p.data.len);
378	break;
379	case EMUL_READER_INSERT:
380	ccid_card_ccid_attach(&card->base);
381	break;
382	case EMUL_READER_REMOVE:
383	ccid_card_ccid_detach(&card->base);
384	break;
385	case EMUL_CARD_INSERT:
386	assert(event->p.data.len <= MAX_ATR_SIZE);
387	card->atr_length = event->p.data.len;
388	memcpy(card->atr, event->p.data.data, card->atr_length);
389	ccid_card_card_inserted(&card->base);
390	break;
391	case EMUL_CARD_REMOVE:
392	ccid_card_card_removed(&card->base);
393	break;
394	case EMUL_ERROR:
395	ccid_card_card_error(&card->base, event->p.error.code);
396	break;
397	default:
398	DPRINTF(card, 2, "unexpected event\n");
399	break;
400	}
7267c094	401	g_free(event);
585738a6 AL	402	}
	403	QSIMPLEQ_INIT(&card->event_list);
	404	qemu_mutex_unlock(&card->event_list_mutex);
	405	}
	406
	407	static int init_pipe_signaling(EmulatedState *card)
	408	{
	409	if (pipe(card->pipe) < 0) {
	410	DPRINTF(card, 2, "pipe creation failed\n");
	411	return -1;
	412	}
	413	fcntl(card->pipe[0], F_SETFL, O_NONBLOCK);
	414	fcntl(card->pipe[1], F_SETFL, O_NONBLOCK);
	415	fcntl(card->pipe[0], F_SETOWN, getpid());
	416	qemu_set_fd_handler(card->pipe[0], pipe_read, NULL, card);
	417	return 0;
	418	}
	419
	420	#define CERTIFICATES_DEFAULT_DB "/etc/pki/nssdb"
	421	#define CERTIFICATES_ARGS_TEMPLATE\
	422	"db=\"%s\" use_hw=no soft=(,Virtual Reader,CAC,,%s,%s,%s)"
	423
	424	static int wrap_vcard_emul_init(VCardEmulOptions *options)
	425	{
	426	static int called;
	427	static int options_was_null;
	428
	429	if (called) {
	430	if ((options == NULL) != options_was_null) {
	431	printf("%s: warning: running emulated with certificates"
	432	" and emulated side by side is not supported\n",
	433	__func__);
	434	return VCARD_EMUL_FAIL;
	435	}
	436	vcard_emul_replay_insertion_events();
	437	return VCARD_EMUL_OK;
	438	}
	439	options_was_null = (options == NULL);
	440	called = 1;
	441	return vcard_emul_init(options);
	442	}
	443
	444	static int emulated_initialize_vcard_from_certificates(EmulatedState *card)
	445	{
	446	char emul_args[200];
	447	VCardEmulOptions *options = NULL;
	448
	449	snprintf(emul_args, sizeof(emul_args) - 1, CERTIFICATES_ARGS_TEMPLATE,
	450	card->db ? card->db : CERTIFICATES_DEFAULT_DB,
	451	card->cert1, card->cert2, card->cert3);
	452	options = vcard_emul_options(emul_args);
	453	if (options == NULL) {
	454	printf("%s: warning: not using certificates due to"
	455	" initialization error\n", __func__);
	456	}
	457	return wrap_vcard_emul_init(options);
	458	}
	459
	460	typedef struct EnumTable {
	461	const char *name;
	462	uint32_t value;
	463	} EnumTable;
	464
	465	EnumTable backend_enum_table[] = {
466	{BACKEND_NSS_EMULATED_NAME, BACKEND_NSS_EMULATED},
467	{BACKEND_CERTIFICATES_NAME, BACKEND_CERTIFICATES},
468	{NULL, 0},
469	};
470
471	static uint32_t parse_enumeration(char *str,
472	EnumTable *table, uint32_t not_found_value)
473	{
474	uint32_t ret = not_found_value;
475
476	while (table->name != NULL) {
477	if (strcmp(table->name, str) == 0) {
478	ret = table->value;
479	break;
480	}
481	table++;
482	}
483	return ret;
484	}
485
486	static int emulated_initfn(CCIDCardState *base)
487	{
488	EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
585738a6 AL	489	VCardEmulError ret;
	490	EnumTable *ptable;
	491
	492	QSIMPLEQ_INIT(&card->event_list);
	493	QSIMPLEQ_INIT(&card->guest_apdu_list);
	494	qemu_mutex_init(&card->event_list_mutex);
	495	qemu_mutex_init(&card->vreader_mutex);
	496	qemu_mutex_init(&card->handle_apdu_mutex);
	497	qemu_cond_init(&card->handle_apdu_cond);
	498	card->reader = NULL;
	499	card->quit_apdu_thread = 0;
	500	if (init_pipe_signaling(card) < 0) {
	501	return -1;
	502	}
	503	card->backend = parse_enumeration(card->backend_str, backend_enum_table, 0);
	504	if (card->backend == 0) {
	505	printf("unknown backend, must be one of:\n");
	506	for (ptable = backend_enum_table; ptable->name != NULL; ++ptable) {
	507	printf("%s\n", ptable->name);
	508	}
	509	return -1;
	510	}
	511
	512	/* TODO: a passthru backened that works on local machine. third card type?*/
	513	if (card->backend == BACKEND_CERTIFICATES) {
	514	if (card->cert1 != NULL && card->cert2 != NULL && card->cert3 != NULL) {
	515	ret = emulated_initialize_vcard_from_certificates(card);
	516	} else {
	517	printf("%s: you must provide all three certs for"
	518	" certificates backend\n", EMULATED_DEV_NAME);
	519	return -1;
	520	}
	521	} else {
	522	if (card->backend != BACKEND_NSS_EMULATED) {
	523	printf("%s: bad backend specified. The options are:\n%s (default),"
	524	" %s.\n", EMULATED_DEV_NAME, BACKEND_NSS_EMULATED_NAME,
	525	BACKEND_CERTIFICATES_NAME);
	526	return -1;
	527	}
	528	if (card->cert1 != NULL \|\| card->cert2 != NULL \|\| card->cert3 != NULL) {
	529	printf("%s: unexpected cert parameters to nss emulated backend\n",
	530	EMULATED_DEV_NAME);
	531	return -1;
	532	}
	533	/* default to mirroring the local hardware readers */
	534	ret = wrap_vcard_emul_init(NULL);
	535	}
	536	if (ret != VCARD_EMUL_OK) {
	537	printf("%s: failed to initialize vcard\n", EMULATED_DEV_NAME);
	538	return -1;
	539	}
da5361cc PB	540	qemu_thread_create(&card->event_thread_id, event_thread, card,
	541	QEMU_THREAD_JOINABLE);
	542	qemu_thread_create(&card->apdu_thread_id, handle_apdu_thread, card,
	543	QEMU_THREAD_JOINABLE);
585738a6 AL	544	return 0;
	545	}
	546
	547	static int emulated_exitfn(CCIDCardState *base)
	548	{
	549	EmulatedState *card = DO_UPCAST(EmulatedState, base, base);
	550	VEvent *vevent = vevent_new(VEVENT_LAST, NULL, NULL);
	551
	552	vevent_queue_vevent(vevent); /* stop vevent thread */
da5361cc PB	553	qemu_thread_join(&card->event_thread_id);
da5361cc PB	554
585738a6 AL	555	card->quit_apdu_thread = 1; /* stop handle_apdu thread */
585738a6 AL	556	qemu_cond_signal(&card->handle_apdu_cond);
da5361cc PB	557	qemu_thread_join(&card->apdu_thread_id);
	558
	559	/* threads exited, can destroy all condvars/mutexes */
585738a6	560	qemu_cond_destroy(&card->handle_apdu_cond);
585738a6 AL	561	qemu_mutex_destroy(&card->handle_apdu_mutex);
	562	qemu_mutex_destroy(&card->vreader_mutex);
	563	qemu_mutex_destroy(&card->event_list_mutex);
	564	return 0;
	565	}
	566
39bffca2 AL	567	static Property emulated_card_properties[] = {
	568	DEFINE_PROP_STRING("backend", EmulatedState, backend_str),
	569	DEFINE_PROP_STRING("cert1", EmulatedState, cert1),
	570	DEFINE_PROP_STRING("cert2", EmulatedState, cert2),
	571	DEFINE_PROP_STRING("cert3", EmulatedState, cert3),
	572	DEFINE_PROP_STRING("db", EmulatedState, db),
	573	DEFINE_PROP_UINT8("debug", EmulatedState, debug, 0),
	574	DEFINE_PROP_END_OF_LIST(),
	575	};
	576
ba7c0520 AL	577	static void emulated_class_initfn(ObjectClass klass, void data)
ba7c0520 AL	578	{
39bffca2	579	DeviceClass *dc = DEVICE_CLASS(klass);
ba7c0520 AL	580	CCIDCardClass *cc = CCID_CARD_CLASS(klass);
	581
	582	cc->initfn = emulated_initfn;
	583	cc->exitfn = emulated_exitfn;
	584	cc->get_atr = emulated_get_atr;
	585	cc->apdu_from_guest = emulated_apdu_from_guest;
39bffca2 AL	586	dc->desc = "emulated smartcard";
39bffca2 AL	587	dc->props = emulated_card_properties;
ba7c0520 AL	588	}
ba7c0520 AL	589
8c43a6f0	590	static const TypeInfo emulated_card_info = {
39bffca2 AL	591	.name = EMULATED_DEV_NAME,
	592	.parent = TYPE_CCID_CARD,
	593	.instance_size = sizeof(EmulatedState),
	594	.class_init = emulated_class_initfn,
585738a6 AL	595	};
585738a6 AL	596
83f7d43a	597	static void ccid_card_emulated_register_types(void)
585738a6	598	{
39bffca2	599	type_register_static(&emulated_card_info);
585738a6 AL	600	}
585738a6 AL	601
83f7d43a	602	type_init(ccid_card_emulated_register_types)