Archipelago » qemu

/*

 * This is the actual card emulator.

 *

 * These functions can be implemented in different ways on different platforms

 * using the underlying system primitives. For Linux it uses NSS, though direct

 * to PKCS #11, openssl+pkcs11, or even gnu crypto libraries+pkcs #11 could be

 * used. On Windows CAPI could be used.

 *

 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.

 * See the COPYING.LIB file in the top-level directory.

 */

/*

 * NSS headers

 */

/* avoid including prototypes.h that redefines uint32 */

#define NO_NSPR_10_SUPPORT

#include <nss.h>

#include <pk11pub.h>

#include <cert.h>

#include <key.h>

#include <secmod.h>

#include <prthread.h>

#include <secerr.h>

#include "qemu-common.h"

#include "vcard.h"

#include "card_7816t.h"

#include "vcard_emul.h"

#include "vreader.h"

#include "vevent.h"

typedef enum {

    VCardEmulUnknown = -1,

    VCardEmulFalse = 0,

    VCardEmulTrue = 1

} VCardEmulTriState;

struct VCardKeyStruct {

    CERTCertificate *cert;

    PK11SlotInfo *slot;

    SECKEYPrivateKey *key;

    VCardEmulTriState failedX509;

};

typedef struct VirtualReaderOptionsStruct VirtualReaderOptions;

struct VReaderEmulStruct {

    PK11SlotInfo *slot;

    VCardEmulType default_type;

    char *type_params;

    PRBool present;

    int     series;

    VCard *saved_vcard;

};

/*

 *  NSS Specific options

 */

struct VirtualReaderOptionsStruct {

    char *name;

    char *vname;

    VCardEmulType card_type;

    char *type_params;

    char **cert_name;

    int cert_count;

};

struct VCardEmulOptionsStruct {

    void *nss_db;

    VirtualReaderOptions *vreader;

    int vreader_count;

    VCardEmulType hw_card_type;

    const char *hw_type_params;

    PRBool use_hw;

};

static int nss_emul_init;

/* if we have more that just the slot, define

 * VCardEmulStruct here */

/*

 * allocate the set of arrays for certs, cert_len, key

 */

static PRBool

vcard_emul_alloc_arrays(unsigned char ***certsp, int **cert_lenp,

                        VCardKey ***keysp, int cert_count)

{

    *certsp = NULL;

    *cert_lenp = NULL;

    *keysp = NULL;

    *certsp = (unsigned char **)g_malloc(sizeof(unsigned char *)*cert_count);

    *cert_lenp = (int *)g_malloc(sizeof(int)*cert_count);

    *keysp = (VCardKey **)g_malloc(sizeof(VCardKey *)*cert_count);

    return PR_TRUE;

}

/*

 * Emulator specific card information

 */

typedef struct CardEmulCardStruct CardEmulPrivate;

static VCardEmul *

vcard_emul_new_card(PK11SlotInfo *slot)

{

    PK11_ReferenceSlot(slot);

    /* currently we don't need anything other than the slot */

    return (VCardEmul *)slot;

}

static void

vcard_emul_delete_card(VCardEmul *vcard_emul)

{

    PK11SlotInfo *slot = (PK11SlotInfo *)vcard_emul;

    if (slot == NULL) {

        return;

    }

    PK11_FreeSlot(slot);

}

static PK11SlotInfo *

vcard_emul_card_get_slot(VCard *card)

{

    /* note, the card is holding the reference, no need to get another one */

    return (PK11SlotInfo *)vcard_get_private(card);

}

/*

 * key functions

 */

/* private constructure */

static VCardKey *

vcard_emul_make_key(PK11SlotInfo *slot, CERTCertificate *cert)

{

    VCardKey *key;

    key = (VCardKey *)g_malloc(sizeof(VCardKey));

    key->slot = PK11_ReferenceSlot(slot);

    key->cert = CERT_DupCertificate(cert);

    /* NOTE: if we aren't logged into the token, this could return NULL */

    /* NOTE: the cert is a temp cert, not necessarily the cert in the token,

     * use the DER version of this function */

    key->key = PK11_FindKeyByDERCert(slot, cert, NULL);

    key->failedX509 = VCardEmulUnknown;

    return key;

}

/* destructor */

void

vcard_emul_delete_key(VCardKey *key)

{

    if (!nss_emul_init || (key == NULL)) {

        return;

    }

    if (key->key) {

        SECKEY_DestroyPrivateKey(key->key);

        key->key = NULL;

    }

    if (key->cert) {

        CERT_DestroyCertificate(key->cert);

    }

    if (key->slot) {

        PK11_FreeSlot(key->slot);

    }

    return;

}

/*

 * grab the nss key from a VCardKey. If it doesn't exist, try to look it up

 */

static SECKEYPrivateKey *

vcard_emul_get_nss_key(VCardKey *key)

{

    if (key->key) {

        return key->key;

    }

    /* NOTE: if we aren't logged into the token, this could return NULL */

    key->key = PK11_FindPrivateKeyFromCert(key->slot, key->cert, NULL);

    return key->key;

}

/*

 * Map NSS errors to 7816 errors

 */

static vcard_7816_status_t

vcard_emul_map_error(int error)

{

    switch (error) {

    case SEC_ERROR_TOKEN_NOT_LOGGED_IN:

        return VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED;

    case SEC_ERROR_BAD_DATA:

    case SEC_ERROR_OUTPUT_LEN:

    case SEC_ERROR_INPUT_LEN:

    case SEC_ERROR_INVALID_ARGS:

    case SEC_ERROR_INVALID_ALGORITHM:

    case SEC_ERROR_NO_KEY:

    case SEC_ERROR_INVALID_KEY:

    case SEC_ERROR_DECRYPTION_DISALLOWED:

        return VCARD7816_STATUS_ERROR_DATA_INVALID;

    case SEC_ERROR_NO_MEMORY:

        return VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE;

    }

    return VCARD7816_STATUS_EXC_ERROR_CHANGE;

}

/* RSA sign/decrypt with the key, signature happens 'in place' */

vcard_7816_status_t

vcard_emul_rsa_op(VCard *card, VCardKey *key,

                  unsigned char *buffer, int buffer_size)

{

    SECKEYPrivateKey *priv_key;

    unsigned signature_len;

    PK11SlotInfo *slot;

    SECStatus rv;

    unsigned char buf[2048];

    unsigned char *bp = NULL;

    int pad_len;

    vcard_7816_status_t ret = VCARD7816_STATUS_SUCCESS;

    if ((!nss_emul_init) || (key == NULL)) {

        /* couldn't get the key, indicate that we aren't logged in */

        return VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED;

    }

    priv_key = vcard_emul_get_nss_key(key);

    if (priv_key == NULL) {

        /* couldn't get the key, indicate that we aren't logged in */

        return VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED;

    }

    slot = vcard_emul_card_get_slot(card);

    /*

     * this is only true of the rsa signature

     */

    signature_len = PK11_SignatureLen(priv_key);

    if (buffer_size != signature_len) {

        return  VCARD7816_STATUS_ERROR_DATA_INVALID;

    }

    /* be able to handle larger keys if necessariy */

    bp = &buf[0];

    if (sizeof(buf) < signature_len) {

        bp = g_malloc(signature_len);

    }

    /*

     * do the raw operations. Some tokens claim to do CKM_RSA_X_509, but then

     * choke when they try to do the actual operations. Try to detect

     * those cases and treat them as if the token didn't claim support for

     * X_509.

     */

    if (key->failedX509 != VCardEmulTrue

                              && PK11_DoesMechanism(slot, CKM_RSA_X_509)) {

        rv = PK11_PrivDecryptRaw(priv_key, bp, &signature_len, signature_len,

                                 buffer, buffer_size);

        if (rv == SECSuccess) {

            assert(buffer_size == signature_len);

            memcpy(buffer, bp, signature_len);

            key->failedX509 = VCardEmulFalse;

            goto cleanup;

        }

        /*

         * we've had a successful X509 operation, this failure must be

         * somethine else

         */

        if (key->failedX509 == VCardEmulFalse) {

            ret = vcard_emul_map_error(PORT_GetError());

            goto cleanup;

        }

        /*

         * key->failedX509 must be Unknown at this point, try the

         * non-x_509 case

         */

    }

    /* token does not support CKM_RSA_X509, emulate that with CKM_RSA_PKCS */

    /* is this a PKCS #1 formatted signature? */

    if ((buffer[0] == 0) && (buffer[1] == 1)) {

        int i;

        for (i = 2; i < buffer_size; i++) {

            /* rsa signature pad */

            if (buffer[i] != 0xff) {

                break;

            }

        }

        if ((i < buffer_size) && (buffer[i] == 0)) {

            /* yes, we have a properly formated PKCS #1 signature */

            /*

             * NOTE: even if we accidentally got an encrypt buffer, which

             * through shear luck started with 00, 01, ff, 00, it won't matter

             * because the resulting Sign operation will effectively decrypt

             * the real buffer.

             */

            SECItem signature;

            SECItem hash;

            i++;

            hash.data = &buffer[i];

            hash.len = buffer_size - i;

            signature.data = bp;

            signature.len = signature_len;

            rv = PK11_Sign(priv_key,  &signature, &hash);

            if (rv != SECSuccess) {

                ret = vcard_emul_map_error(PORT_GetError());

                goto cleanup;

            }

            assert(buffer_size == signature.len);

            memcpy(buffer, bp, signature.len);

            /*

             * we got here because either the X509 attempt failed, or the

             * token couldn't do the X509 operation, in either case stay

             * with the PKCS version for future operations on this key

             */

            key->failedX509 = VCardEmulTrue;

            goto cleanup;

        }

    }

    pad_len = buffer_size - signature_len;

    assert(pad_len < 4);

    /*

     * OK now we've decrypted the payload, package it up in PKCS #1 for the

     * upper layer.

     */

    buffer[0] = 0;

    buffer[1] = 2; /* RSA_encrypt  */

    pad_len -= 3; /* format is 0 || 2 || pad || 0 || data */

    /*

     * padding for PKCS #1 encrypted data is a string of random bytes. The

     * random butes protect against potential decryption attacks against RSA.

     * Since PrivDecrypt has already stripped those bytes, we can't reconstruct

     * them. This shouldn't matter to the upper level code which should just

     * strip this code out anyway, so We'll pad with a constant 3.

     */

    memset(&buffer[2], 0x03, pad_len);

    pad_len += 2; /* index to the end of the pad */

    buffer[pad_len] = 0;

    pad_len++; /* index to the start of the data */

    memcpy(&buffer[pad_len], bp, signature_len);

    /*

     * we got here because either the X509 attempt failed, or the

     * token couldn't do the X509 operation, in either case stay

     * with the PKCS version for future operations on this key

     */

    key->failedX509 = VCardEmulTrue;

cleanup:

    if (bp != buf) {

        g_free(bp);

    }

    return ret;

}

/*

 * Login functions

 */

/* return the number of login attempts still possible on the card. if unknown,

 * return -1 */

int

vcard_emul_get_login_count(VCard *card)

{

    return -1;

}

/* login into the card, return the 7816 status word (sw2 || sw1) */

vcard_7816_status_t

vcard_emul_login(VCard *card, unsigned char *pin, int pin_len)

{

    PK11SlotInfo *slot;

    unsigned char *pin_string = NULL;

    int i;

    SECStatus rv;

    if (!nss_emul_init) {

        return VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED;

    }

    slot = vcard_emul_card_get_slot(card);

     /* We depend on the PKCS #11 module internal login state here because we

      * create a separate process to handle each guest instance. If we needed

      * to handle multiple guests from one process, then we would need to keep

      * a lot of extra state in our card structure

      * */

    pin_string = g_malloc(pin_len+1);

    memcpy(pin_string, pin, pin_len);

    pin_string[pin_len] = 0;

    /* handle CAC expanded pins correctly */

    for (i = pin_len-1; i >= 0 && (pin_string[i] == 0xff); i--) {

        pin_string[i] = 0;

    }

    rv = PK11_Authenticate(slot, PR_FALSE, pin_string);

    memset(pin_string, 0, pin_len);  /* don't let the pin hang around in memory

                                        to be snooped */

    g_free(pin_string);

    if (rv == SECSuccess) {

        return VCARD7816_STATUS_SUCCESS;

    }

    /* map the error from port get error */

    return VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED;

}

void

vcard_emul_reset(VCard *card, VCardPower power)

{

    PK11SlotInfo *slot;

    if (!nss_emul_init) {

        return;

    }

    /*

     * if we reset the card (either power on or power off), we lose our login

     * state

     */

    /* TODO: we may also need to send insertion/removal events? */

    slot = vcard_emul_card_get_slot(card);

    PK11_Logout(slot); /* NOTE: ignoring SECStatus return value */

    return;

}

static VReader *

vcard_emul_find_vreader_from_slot(PK11SlotInfo *slot)

{

    VReaderList *reader_list = vreader_get_reader_list();

    VReaderListEntry *current_entry = NULL;

    if (reader_list == NULL) {

        return NULL;

    }

    for (current_entry = vreader_list_get_first(reader_list); current_entry;

                        current_entry = vreader_list_get_next(current_entry)) {

        VReader *reader = vreader_list_get_reader(current_entry);

        VReaderEmul *reader_emul = vreader_get_private(reader);

        if (reader_emul->slot == slot) {

            return reader;

        }

        vreader_free(reader);

    }

    return NULL;

}

/*

 * create a new reader emul

 */

static VReaderEmul *

vreader_emul_new(PK11SlotInfo *slot, VCardEmulType type, const char *params)

{

    VReaderEmul *new_reader_emul;

    new_reader_emul = (VReaderEmul *)g_malloc(sizeof(VReaderEmul));

    new_reader_emul->slot = PK11_ReferenceSlot(slot);

    new_reader_emul->default_type = type;

    new_reader_emul->type_params = strdup(params);

    new_reader_emul->present = PR_FALSE;

    new_reader_emul->series = 0;

    new_reader_emul->saved_vcard = NULL;

    return new_reader_emul;

}

static void

vreader_emul_delete(VReaderEmul *vreader_emul)

{

    if (vreader_emul == NULL) {

        return;

    }

    if (vreader_emul->slot) {

        PK11_FreeSlot(vreader_emul->slot);

    }

    if (vreader_emul->type_params) {

        g_free(vreader_emul->type_params);

    }

    g_free(vreader_emul);

}

/*

 *  TODO: move this to emulater non-specific file

 */

static VCardEmulType

vcard_emul_get_type(VReader *vreader)

{

    VReaderEmul *vreader_emul;

    vreader_emul = vreader_get_private(vreader);

    if (vreader_emul && vreader_emul->default_type != VCARD_EMUL_NONE) {

        return vreader_emul->default_type;

    }

    return vcard_emul_type_select(vreader);

}

/*

 *  TODO: move this to emulater non-specific file

 */

static const char *

vcard_emul_get_type_params(VReader *vreader)

{

    VReaderEmul *vreader_emul;

    vreader_emul = vreader_get_private(vreader);

    if (vreader_emul && vreader_emul->type_params) {

        return vreader_emul->type_params;

    }

    return "";

}

/* pull the slot out of the reader private data */

static PK11SlotInfo *

vcard_emul_reader_get_slot(VReader *vreader)

{

    VReaderEmul *vreader_emul = vreader_get_private(vreader);

    if (vreader_emul == NULL) {

        return NULL;

    }

    return vreader_emul->slot;

}

/*

 *  Card ATR's map to physical cards. VCARD_ATR_PREFIX will set appropriate

 *  historical bytes for any software emulated card. The remaining bytes can be

 *  used to indicate the actual emulator

 */

static const unsigned char nss_atr[] = { VCARD_ATR_PREFIX(3), 'N', 'S', 'S' };

void

vcard_emul_get_atr(VCard *card, unsigned char *atr, int *atr_len)

{

    int len = MIN(sizeof(nss_atr), *atr_len);

    assert(atr != NULL);

    memcpy(atr, nss_atr, len);

    *atr_len = len;

    return;

}

/*

 * create a new card from certs and keys

 */

static VCard *

vcard_emul_make_card(VReader *reader,

                     unsigned char * const *certs, int *cert_len,

                     VCardKey *keys[], int cert_count)

{

    VCardEmul *vcard_emul;

    VCard *vcard;

    PK11SlotInfo *slot;

    VCardEmulType type;

    const char *params;

    type = vcard_emul_get_type(reader);

    /* ignore the inserted card */

    if (type == VCARD_EMUL_NONE) {

        return NULL;

    }

    slot = vcard_emul_reader_get_slot(reader);

    if (slot == NULL) {

        return NULL;

    }

    params = vcard_emul_get_type_params(reader);

    /* params these can be NULL */

    vcard_emul = vcard_emul_new_card(slot);

    if (vcard_emul == NULL) {

        return NULL;

    }

    vcard = vcard_new(vcard_emul, vcard_emul_delete_card);

    if (vcard == NULL) {

        vcard_emul_delete_card(vcard_emul);

        return NULL;

    }

    vcard_init(reader, vcard, type, params, certs, cert_len, keys, cert_count);

    return vcard;

}

/*

 * 'clone' a physical card as a virtual card

 */

static VCard *

vcard_emul_mirror_card(VReader *vreader)

{

    /*

     * lookup certs using the C_FindObjects. The Stan Cert handle won't give

     * us the real certs until we log in.

     */

    PK11GenericObject *firstObj, *thisObj;

    int cert_count;

    unsigned char **certs;

    int *cert_len;

    VCardKey **keys;

    PK11SlotInfo *slot;

    PRBool ret;

    VCard *card;

    slot = vcard_emul_reader_get_slot(vreader);

    if (slot == NULL) {

        return NULL;

    }

    firstObj = PK11_FindGenericObjects(slot, CKO_CERTIFICATE);

    if (firstObj == NULL) {

        return NULL;

    }

    /* count the certs */

    cert_count = 0;

    for (thisObj = firstObj; thisObj;

                             thisObj = PK11_GetNextGenericObject(thisObj)) {

        cert_count++;

    }

    if (cert_count == 0) {

        PK11_DestroyGenericObjects(firstObj);

        return NULL;

    }

    /* allocate the arrays */

    ret = vcard_emul_alloc_arrays(&certs, &cert_len, &keys, cert_count);

    if (ret == PR_FALSE) {

        return NULL;

    }

    /* fill in the arrays */

    cert_count = 0;

    for (thisObj = firstObj; thisObj;

                             thisObj = PK11_GetNextGenericObject(thisObj)) {

        SECItem derCert;

        CERTCertificate *cert;

        SECStatus rv;

        rv = PK11_ReadRawAttribute(PK11_TypeGeneric, thisObj,

                                   CKA_VALUE, &derCert);

        if (rv != SECSuccess) {

            continue;

        }

        /* create floating temp cert. This gives us a cert structure even if

         * the token isn't logged in */

        cert = CERT_NewTempCertificate(CERT_GetDefaultCertDB(), &derCert,

                                       NULL, PR_FALSE, PR_TRUE);

        SECITEM_FreeItem(&derCert, PR_FALSE);

        if (cert == NULL) {

            continue;

        }

        certs[cert_count] = cert->derCert.data;

        cert_len[cert_count] = cert->derCert.len;

        keys[cert_count] = vcard_emul_make_key(slot, cert);

        cert_count++;

        CERT_DestroyCertificate(cert); /* key obj still has a reference */

    }

    /* now create the card */

    card = vcard_emul_make_card(vreader, certs, cert_len, keys, cert_count);

    g_free(certs);

    g_free(cert_len);

    g_free(keys);

    return card;

}

static VCardEmulType default_card_type = VCARD_EMUL_NONE;

static const char *default_type_params = "";

/*

 * This thread looks for card and reader insertions and puts events on the

 * event queue

 */

static void

vcard_emul_event_thread(void *arg)

{

    PK11SlotInfo *slot;

    VReader *vreader;

    VReaderEmul *vreader_emul;

    VCard *vcard;

    SECMODModule *module = (SECMODModule *)arg;

    do {

        /*

         * XXX - the latency value doesn't matter one bit. you only get no

         * blocking (flags |= CKF_DONT_BLOCK) or PKCS11_WAIT_LATENCY (==500),

         * hard coded in coolkey.  And it isn't coolkey's fault - the timeout

         * value we pass get's dropped on the floor before C_WaitForSlotEvent

         * is called.

         */

        slot = SECMOD_WaitForAnyTokenEvent(module, 0, 500);

        if (slot == NULL) {

            /* this could be just a no event indication */

            if (PORT_GetError() == SEC_ERROR_NO_EVENT) {

                continue;

            }

            break;

        }

        vreader = vcard_emul_find_vreader_from_slot(slot);

        if (vreader == NULL) {

            /* new vreader */

            vreader_emul = vreader_emul_new(slot, default_card_type,

                                            default_type_params);

            vreader = vreader_new(PK11_GetSlotName(slot), vreader_emul,

                                  vreader_emul_delete);

            PK11_FreeSlot(slot);

            slot = NULL;

            vreader_add_reader(vreader);

            vreader_free(vreader);

            continue;

        }

        /* card remove/insert */

        vreader_emul = vreader_get_private(vreader);

        if (PK11_IsPresent(slot)) {

            int series = PK11_GetSlotSeries(slot);

            if (series != vreader_emul->series) {

                if (vreader_emul->present) {

                    vreader_insert_card(vreader, NULL);

                }

                vcard = vcard_emul_mirror_card(vreader);

                vreader_insert_card(vreader, vcard);

                vcard_free(vcard);

            }

            vreader_emul->series = series;

            vreader_emul->present = 1;

            vreader_free(vreader);

            PK11_FreeSlot(slot);

            continue;

        }

        if (vreader_emul->present) {

            vreader_insert_card(vreader, NULL);

        }

        vreader_emul->series = 0;

        vreader_emul->present = 0;

        PK11_FreeSlot(slot);

        vreader_free(vreader);

    } while (1);

}

/* if the card is inserted when we start up, make sure our state is correct */

static void

vcard_emul_init_series(VReader *vreader, VCard *vcard)

{

    VReaderEmul *vreader_emul = vreader_get_private(vreader);

    PK11SlotInfo *slot = vreader_emul->slot;

    vreader_emul->present = PK11_IsPresent(slot);

    vreader_emul->series = PK11_GetSlotSeries(slot);

    if (vreader_emul->present == 0) {

        vreader_insert_card(vreader, NULL);

    }

}

/*

 * each module has a separate wait call, create a thread for each module that

 * we are using.

 */

static void

vcard_emul_new_event_thread(SECMODModule *module)

{

    PR_CreateThread(PR_SYSTEM_THREAD, vcard_emul_event_thread,

                     module, PR_PRIORITY_HIGH, PR_GLOBAL_THREAD,

                     PR_UNJOINABLE_THREAD, 0);

}

static const VCardEmulOptions default_options = {

    .nss_db = NULL,

    .vreader = NULL,

    .vreader_count = 0,

    .hw_card_type = VCARD_EMUL_CAC,

    .hw_type_params = "",

    .use_hw = PR_TRUE

};

/*

 *  NSS needs the app to supply a password prompt. In our case the only time

 *  the password is supplied is as part of the Login APDU. The actual password

 *  is passed in the pw_arg in that case. In all other cases pw_arg should be

 *  NULL.

 */

static char *

vcard_emul_get_password(PK11SlotInfo *slot, PRBool retries, void *pw_arg)

{

    /* if it didn't work the first time, don't keep trying */

    if (retries) {

        return NULL;

    }

    /* we are looking up a password when we don't have one in hand */

    if (pw_arg == NULL) {

        return NULL;

    }

    /* TODO: we really should verify that were are using the right slot */

    return PORT_Strdup(pw_arg);

}

/* Force a card removal even if the card is not physically removed */

VCardEmulError

vcard_emul_force_card_remove(VReader *vreader)

{

    if (!nss_emul_init || (vreader_card_is_present(vreader) != VREADER_OK)) {

        return VCARD_EMUL_FAIL; /* card is already removed */

    }

    /* OK, remove it */

    vreader_insert_card(vreader, NULL);

    return VCARD_EMUL_OK;

}

/* Re-insert of a card that has been removed by force removal */

VCardEmulError

vcard_emul_force_card_insert(VReader *vreader)

{

    VReaderEmul *vreader_emul;

    VCard *vcard;

    if (!nss_emul_init || (vreader_card_is_present(vreader) == VREADER_OK)) {

        return VCARD_EMUL_FAIL; /* card is already removed */

    }

    vreader_emul = vreader_get_private(vreader);

    /* if it's a softcard, get the saved vcard from the reader emul structure */

    if (vreader_emul->saved_vcard) {

        vcard = vcard_reference(vreader_emul->saved_vcard);

    } else {

        /* it must be a physical card, rebuild it */

        if (!PK11_IsPresent(vreader_emul->slot)) {

            /* physical card has been removed, not way to reinsert it */

            return VCARD_EMUL_FAIL;

        }

        vcard = vcard_emul_mirror_card(vreader);

    }

    vreader_insert_card(vreader, vcard);

    vcard_free(vcard);

    return VCARD_EMUL_OK;

}

static PRBool

module_has_removable_hw_slots(SECMODModule *mod)

{

    int i;

    PRBool ret = PR_FALSE;

    SECMODListLock *moduleLock = SECMOD_GetDefaultModuleListLock();

    if (!moduleLock) {

        PORT_SetError(SEC_ERROR_NOT_INITIALIZED);

        return ret;

    }

    SECMOD_GetReadLock(moduleLock);

    for (i = 0; i < mod->slotCount; i++) {

        PK11SlotInfo *slot = mod->slots[i];

        if (PK11_IsRemovable(slot) && PK11_IsHW(slot)) {

            ret = PR_TRUE;

            break;

        }

    }

    SECMOD_ReleaseReadLock(moduleLock);

    return ret;

}

/* Previously we returned FAIL if no readers found. This makes

 * no sense when using hardware, since there may be no readers connected

 * at the time vcard_emul_init is called, but they will be properly

 * recognized later. So Instead return FAIL only if no_hw==1 and no

 * vcards can be created (indicates error with certificates provided

 * or db), or if any other higher level error (NSS error, missing coolkey). */

static int vcard_emul_init_called;

VCardEmulError

vcard_emul_init(const VCardEmulOptions *options)

{

    SECStatus rv;

    PRBool ret, has_readers = PR_FALSE, need_coolkey_module;

    VReader *vreader;

    VReaderEmul *vreader_emul;

    SECMODListLock *module_lock;

    SECMODModuleList *module_list;

    SECMODModuleList *mlp;

    int i;

    if (vcard_emul_init_called) {

        return VCARD_EMUL_INIT_ALREADY_INITED;

    }

    vcard_emul_init_called = 1;

    vreader_init();

    vevent_queue_init();

    if (options == NULL) {

        options = &default_options;

    }

    /* first initialize NSS */

    if (options->nss_db) {

        rv = NSS_Init(options->nss_db);

    } else {

        rv = NSS_Init("sql:/etc/pki/nssdb");

    }

    if (rv != SECSuccess) {

        return VCARD_EMUL_FAIL;

    }

    /* Set password callback function */

    PK11_SetPasswordFunc(vcard_emul_get_password);

    /* set up soft cards emulated by software certs rather than physical cards

     * */

    for (i = 0; i < options->vreader_count; i++) {

        int j;

        int cert_count;

        unsigned char **certs;

        int *cert_len;