429 lines
13 KiB
C
429 lines
13 KiB
C
/*
|
|
* implement the applets for the CAC card.
|
|
*
|
|
* This code is licensed under the GNU LGPL, version 2.1 or later.
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
*/
|
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "cac.h"
|
|
#include "vcard.h"
|
|
#include "vcard_emul.h"
|
|
#include "card_7816.h"
|
|
|
|
/* private data for PKI applets */
|
|
typedef struct CACPKIAppletDataStruct {
|
|
unsigned char *cert;
|
|
int cert_len;
|
|
unsigned char *cert_buffer;
|
|
int cert_buffer_len;
|
|
unsigned char *sign_buffer;
|
|
int sign_buffer_len;
|
|
VCardKey *key;
|
|
} CACPKIAppletData;
|
|
|
|
/*
|
|
* CAC applet private data
|
|
*/
|
|
struct VCardAppletPrivateStruct {
|
|
union {
|
|
CACPKIAppletData pki_data;
|
|
void *reserved;
|
|
} u;
|
|
};
|
|
|
|
/*
|
|
* handle all the APDU's that are common to all CAC applets
|
|
*/
|
|
static VCardStatus
|
|
cac_common_process_apdu(VCard *card, VCardAPDU *apdu, VCardResponse **response)
|
|
{
|
|
int ef;
|
|
VCardStatus ret = VCARD_FAIL;
|
|
|
|
switch (apdu->a_ins) {
|
|
case VCARD7816_INS_SELECT_FILE:
|
|
if (apdu->a_p1 != 0x02) {
|
|
/* let the 7816 code handle applet switches */
|
|
ret = VCARD_NEXT;
|
|
break;
|
|
}
|
|
/* handle file id setting */
|
|
if (apdu->a_Lc != 2) {
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_DATA_INVALID);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
}
|
|
/* CAC 1.0 only supports ef = 0 */
|
|
ef = apdu->a_body[0] | (apdu->a_body[1] << 8);
|
|
if (ef != 0) {
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_FILE_NOT_FOUND);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
}
|
|
*response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
case VCARD7816_INS_GET_RESPONSE:
|
|
case VCARD7816_INS_VERIFY:
|
|
/* let the 7816 code handle these */
|
|
ret = VCARD_NEXT;
|
|
break;
|
|
case CAC_GET_PROPERTIES:
|
|
case CAC_GET_ACR:
|
|
/* skip these for now, this will probably be needed */
|
|
*response = vcard_make_response(VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
default:
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* reset the inter call state between applet selects
|
|
*/
|
|
static VCardStatus
|
|
cac_applet_pki_reset(VCard *card, int channel)
|
|
{
|
|
VCardAppletPrivate *applet_private = NULL;
|
|
CACPKIAppletData *pki_applet = NULL;
|
|
applet_private = vcard_get_current_applet_private(card, channel);
|
|
assert(applet_private);
|
|
pki_applet = &(applet_private->u.pki_data);
|
|
|
|
pki_applet->cert_buffer = NULL;
|
|
if (pki_applet->sign_buffer) {
|
|
g_free(pki_applet->sign_buffer);
|
|
pki_applet->sign_buffer = NULL;
|
|
}
|
|
pki_applet->cert_buffer_len = 0;
|
|
pki_applet->sign_buffer_len = 0;
|
|
return VCARD_DONE;
|
|
}
|
|
|
|
static VCardStatus
|
|
cac_applet_pki_process_apdu(VCard *card, VCardAPDU *apdu,
|
|
VCardResponse **response)
|
|
{
|
|
CACPKIAppletData *pki_applet = NULL;
|
|
VCardAppletPrivate *applet_private = NULL;
|
|
int size, next;
|
|
unsigned char *sign_buffer;
|
|
vcard_7816_status_t status;
|
|
VCardStatus ret = VCARD_FAIL;
|
|
|
|
applet_private = vcard_get_current_applet_private(card, apdu->a_channel);
|
|
assert(applet_private);
|
|
pki_applet = &(applet_private->u.pki_data);
|
|
|
|
switch (apdu->a_ins) {
|
|
case CAC_UPDATE_BUFFER:
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
case CAC_GET_CERTIFICATE:
|
|
if ((apdu->a_p2 != 0) || (apdu->a_p1 != 0)) {
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
|
|
break;
|
|
}
|
|
assert(pki_applet->cert != NULL);
|
|
size = apdu->a_Le;
|
|
if (pki_applet->cert_buffer == NULL) {
|
|
pki_applet->cert_buffer = pki_applet->cert;
|
|
pki_applet->cert_buffer_len = pki_applet->cert_len;
|
|
}
|
|
size = MIN(size, pki_applet->cert_buffer_len);
|
|
next = MIN(255, pki_applet->cert_buffer_len - size);
|
|
*response = vcard_response_new_bytes(
|
|
card, pki_applet->cert_buffer, size,
|
|
apdu->a_Le, next ?
|
|
VCARD7816_SW1_WARNING_CHANGE :
|
|
VCARD7816_SW1_SUCCESS,
|
|
next);
|
|
pki_applet->cert_buffer += size;
|
|
pki_applet->cert_buffer_len -= size;
|
|
if ((*response == NULL) || (next == 0)) {
|
|
pki_applet->cert_buffer = NULL;
|
|
}
|
|
if (*response == NULL) {
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
|
|
}
|
|
ret = VCARD_DONE;
|
|
break;
|
|
case CAC_SIGN_DECRYPT:
|
|
if (apdu->a_p2 != 0) {
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
|
|
break;
|
|
}
|
|
size = apdu->a_Lc;
|
|
|
|
sign_buffer = realloc(pki_applet->sign_buffer,
|
|
pki_applet->sign_buffer_len+size);
|
|
if (sign_buffer == NULL) {
|
|
g_free(pki_applet->sign_buffer);
|
|
pki_applet->sign_buffer = NULL;
|
|
pki_applet->sign_buffer_len = 0;
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
}
|
|
memcpy(sign_buffer+pki_applet->sign_buffer_len, apdu->a_body, size);
|
|
size += pki_applet->sign_buffer_len;
|
|
switch (apdu->a_p1) {
|
|
case 0x80:
|
|
/* p1 == 0x80 means we haven't yet sent the whole buffer, wait for
|
|
* the rest */
|
|
pki_applet->sign_buffer = sign_buffer;
|
|
pki_applet->sign_buffer_len = size;
|
|
*response = vcard_make_response(VCARD7816_STATUS_SUCCESS);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
case 0x00:
|
|
/* we now have the whole buffer, do the operation, result will be
|
|
* in the sign_buffer */
|
|
status = vcard_emul_rsa_op(card, pki_applet->key,
|
|
sign_buffer, size);
|
|
if (status != VCARD7816_STATUS_SUCCESS) {
|
|
*response = vcard_make_response(status);
|
|
break;
|
|
}
|
|
*response = vcard_response_new(card, sign_buffer, size, apdu->a_Le,
|
|
VCARD7816_STATUS_SUCCESS);
|
|
if (*response == NULL) {
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_EXC_ERROR_MEMORY_FAILURE);
|
|
}
|
|
break;
|
|
default:
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_P1_P2_INCORRECT);
|
|
break;
|
|
}
|
|
g_free(sign_buffer);
|
|
pki_applet->sign_buffer = NULL;
|
|
pki_applet->sign_buffer_len = 0;
|
|
ret = VCARD_DONE;
|
|
break;
|
|
case CAC_READ_BUFFER:
|
|
/* new CAC call, go ahead and use the old version for now */
|
|
/* TODO: implement */
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
default:
|
|
ret = cac_common_process_apdu(card, apdu, response);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
static VCardStatus
|
|
cac_applet_id_process_apdu(VCard *card, VCardAPDU *apdu,
|
|
VCardResponse **response)
|
|
{
|
|
VCardStatus ret = VCARD_FAIL;
|
|
|
|
switch (apdu->a_ins) {
|
|
case CAC_UPDATE_BUFFER:
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_CONDITION_NOT_SATISFIED);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
case CAC_READ_BUFFER:
|
|
/* new CAC call, go ahead and use the old version for now */
|
|
/* TODO: implement */
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
default:
|
|
ret = cac_common_process_apdu(card, apdu, response);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/*
|
|
* TODO: if we ever want to support general CAC middleware, we will need to
|
|
* implement the various containers.
|
|
*/
|
|
static VCardStatus
|
|
cac_applet_container_process_apdu(VCard *card, VCardAPDU *apdu,
|
|
VCardResponse **response)
|
|
{
|
|
VCardStatus ret = VCARD_FAIL;
|
|
|
|
switch (apdu->a_ins) {
|
|
case CAC_READ_BUFFER:
|
|
case CAC_UPDATE_BUFFER:
|
|
*response = vcard_make_response(
|
|
VCARD7816_STATUS_ERROR_COMMAND_NOT_SUPPORTED);
|
|
ret = VCARD_DONE;
|
|
break;
|
|
default:
|
|
ret = cac_common_process_apdu(card, apdu, response);
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* utilities for creating and destroying the private applet data
|
|
*/
|
|
static void
|
|
cac_delete_pki_applet_private(VCardAppletPrivate *applet_private)
|
|
{
|
|
CACPKIAppletData *pki_applet_data = NULL;
|
|
|
|
if (applet_private == NULL) {
|
|
return;
|
|
}
|
|
pki_applet_data = &(applet_private->u.pki_data);
|
|
if (pki_applet_data->cert != NULL) {
|
|
g_free(pki_applet_data->cert);
|
|
}
|
|
if (pki_applet_data->sign_buffer != NULL) {
|
|
g_free(pki_applet_data->sign_buffer);
|
|
}
|
|
if (pki_applet_data->key != NULL) {
|
|
vcard_emul_delete_key(pki_applet_data->key);
|
|
}
|
|
g_free(applet_private);
|
|
}
|
|
|
|
static VCardAppletPrivate *
|
|
cac_new_pki_applet_private(const unsigned char *cert,
|
|
int cert_len, VCardKey *key)
|
|
{
|
|
CACPKIAppletData *pki_applet_data = NULL;
|
|
VCardAppletPrivate *applet_private = NULL;
|
|
applet_private = (VCardAppletPrivate *)g_malloc(sizeof(VCardAppletPrivate));
|
|
|
|
pki_applet_data = &(applet_private->u.pki_data);
|
|
pki_applet_data->cert_buffer = NULL;
|
|
pki_applet_data->cert_buffer_len = 0;
|
|
pki_applet_data->sign_buffer = NULL;
|
|
pki_applet_data->sign_buffer_len = 0;
|
|
pki_applet_data->key = NULL;
|
|
pki_applet_data->cert = (unsigned char *)g_malloc(cert_len+1);
|
|
/*
|
|
* if we want to support compression, then we simply change the 0 to a 1
|
|
* and compress the cert data with libz
|
|
*/
|
|
pki_applet_data->cert[0] = 0; /* not compressed */
|
|
memcpy(&pki_applet_data->cert[1], cert, cert_len);
|
|
pki_applet_data->cert_len = cert_len+1;
|
|
|
|
pki_applet_data->key = key;
|
|
return applet_private;
|
|
}
|
|
|
|
|
|
/*
|
|
* create a new cac applet which links to a given cert
|
|
*/
|
|
static VCardApplet *
|
|
cac_new_pki_applet(int i, const unsigned char *cert,
|
|
int cert_len, VCardKey *key)
|
|
{
|
|
VCardAppletPrivate *applet_private = NULL;
|
|
VCardApplet *applet = NULL;
|
|
unsigned char pki_aid[] = { 0xa0, 0x00, 0x00, 0x00, 0x79, 0x01, 0x00 };
|
|
int pki_aid_len = sizeof(pki_aid);
|
|
|
|
pki_aid[pki_aid_len-1] = i;
|
|
|
|
applet_private = cac_new_pki_applet_private(cert, cert_len, key);
|
|
if (applet_private == NULL) {
|
|
goto failure;
|
|
}
|
|
applet = vcard_new_applet(cac_applet_pki_process_apdu, cac_applet_pki_reset,
|
|
pki_aid, pki_aid_len);
|
|
if (applet == NULL) {
|
|
goto failure;
|
|
}
|
|
vcard_set_applet_private(applet, applet_private,
|
|
cac_delete_pki_applet_private);
|
|
applet_private = NULL;
|
|
|
|
return applet;
|
|
|
|
failure:
|
|
if (applet_private != NULL) {
|
|
cac_delete_pki_applet_private(applet_private);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static unsigned char cac_default_container_aid[] = {
|
|
0xa0, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00 };
|
|
static unsigned char cac_id_aid[] = {
|
|
0xa0, 0x00, 0x00, 0x00, 0x79, 0x03, 0x00 };
|
|
/*
|
|
* Initialize the cac card. This is the only public function in this file. All
|
|
* the rest are connected through function pointers.
|
|
*/
|
|
VCardStatus
|
|
cac_card_init(VReader *reader, VCard *card,
|
|
const char *params,
|
|
unsigned char * const *cert,
|
|
int cert_len[],
|
|
VCardKey *key[] /* adopt the keys*/,
|
|
int cert_count)
|
|
{
|
|
int i;
|
|
VCardApplet *applet;
|
|
|
|
/* CAC Cards are VM Cards */
|
|
vcard_set_type(card, VCARD_VM);
|
|
|
|
/* create one PKI applet for each cert */
|
|
for (i = 0; i < cert_count; i++) {
|
|
applet = cac_new_pki_applet(i, cert[i], cert_len[i], key[i]);
|
|
if (applet == NULL) {
|
|
goto failure;
|
|
}
|
|
vcard_add_applet(card, applet);
|
|
}
|
|
|
|
/* create a default blank container applet */
|
|
applet = vcard_new_applet(cac_applet_container_process_apdu,
|
|
NULL, cac_default_container_aid,
|
|
sizeof(cac_default_container_aid));
|
|
if (applet == NULL) {
|
|
goto failure;
|
|
}
|
|
vcard_add_applet(card, applet);
|
|
|
|
/* create a default blank container applet */
|
|
applet = vcard_new_applet(cac_applet_id_process_apdu,
|
|
NULL, cac_id_aid,
|
|
sizeof(cac_id_aid));
|
|
if (applet == NULL) {
|
|
goto failure;
|
|
}
|
|
vcard_add_applet(card, applet);
|
|
return VCARD_DONE;
|
|
|
|
failure:
|
|
return VCARD_FAIL;
|
|
}
|
|
|