VivoKey/vsmartcard
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

- sm.c (sm_encrypt) fixed header of sm apdu

Browse Source 
- pace.c (EstablishPACEChannel) Fixed initialisation of authentication_ctx.
  (pace_test) Fixed usage of SC_TEST_RET and initialisation of select apdu for
  EF.CardSecurity.


git-svn-id: https://vsmartcard.svn.sourceforge.net/svnroot/vsmartcard@55 96b47cad-a561-4643-ad3b-153ac7d7599c
This commit is contained in:
frankmorgner
2010-04-10 14:53:45 +00:00
parent 62e48e2a7c
commit cbc4dda0ed
3 changed files with 43 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
ccid/pace.c
View File

@@ -749,7 +749,7 @@ int EstablishPACEChannel(sc_card_t *card, const __u8 *in,
goto err;
}
sctx->authenticate = pace_sm_authenticate;
sctx->cipher_ctx = sctx->authenticate;
sctx->cipher_ctx = sctx->authentication_ctx;
sctx->encrypt = pace_sm_encrypt;
sctx->decrypt = pace_sm_decrypt;
sctx->padding_indicator = SM_ISO_PADDING;
@@ -829,12 +829,12 @@ int pace_test(sc_card_t *card)
in[9] = 0; // length_cert_desc
in[10]= 0; // length_cert_desc
SC_TEST_RET(card->ctx, SC_LOG_TYPE_ERROR,
EstablishPACEChannel(card, in, &out, &outlen, &sctx));
SC_TEST_RET(card->ctx, EstablishPACEChannel(card, in, &out, &outlen, &sctx),
"Could not establish PACE channel.");
/* select CardSecurity */
in[0] = 0x00;
in[1] = 0xA4;
apdu.cla = 0x00;
apdu.ins = 0xA4;
apdu.p1 = 0x08;
apdu.p2 = 0x00;
apdu.lc = 0x02;
@@ -843,12 +843,18 @@ int pace_test(sc_card_t *card)
apdu.data = in;
apdu.datalen = 2;
apdu.le = 0x00;
apdu.lc = SC_APDU_CASE_4_SHORT;
apdu.cse = SC_APDU_CASE_4_SHORT;
sm_encrypt(&sctx, card, &apdu, &sm_apdu);
SC_TEST_RET(card->ctx, SC_LOG_TYPE_ERROR,
my_transmit_apdu(card, &sm_apdu));
sm_decrypt(&sctx, card, &sm_apdu, &apdu);
SC_TEST_RET(card->ctx, reset_ssc(&sctx),
"Could not reset send sequence counter.");
SC_TEST_RET(card->ctx, sm_encrypt(&sctx, card, &apdu, &sm_apdu),
"Could not encrypt APDU.");
bin_log(card->ctx, "SM APDU data", sm_apdu.data, sm_apdu.datalen);
SC_TEST_RET(card->ctx, my_transmit_apdu(card, &sm_apdu),
"Could not send SM APDU.");
SC_TEST_RET(card->ctx, sm_decrypt(&sctx, card, &sm_apdu, &apdu),
"Could not decrypt APDU");
bin_log(card->ctx, "SM APDU response", sm_apdu.resp, apdu.resplen);
return SC_SUCCESS;
}
@@ -971,7 +977,7 @@ reset_ssc(struct sm_ctx *ctx)
struct pace_sm_ctx *psmctx = ctx->cipher_ctx;
psmctx->ssc = 0;
return SC_SUCCESS;
return increment_ssc(ctx);
}
int pace_sm_encrypt(sc_card_t *card, const struct sm_ctx *ctx,
@@ -1069,6 +1075,7 @@ int pace_sm_authenticate(sc_card_t *card, const struct sm_ctx *ctx,
BUF_MEM *databuf = NULL, *macbuf = NULL;
u8 *p = NULL;
int r;
size_t oldlen;
if (!ctx || !ctx->cipher_ctx) {
r = SC_ERROR_INVALID_ARGUMENTS;
@@ -1077,12 +1084,17 @@ int pace_sm_authenticate(sc_card_t *card, const struct sm_ctx *ctx,
struct pace_sm_ctx *psmctx = ctx->cipher_ctx;
databuf = encoded_ssc(psmctx->ssc, psmctx->ctx);
if (!databuf ||
!BUF_MEM_grow(databuf, databuf->length + datalen)) {
if (!databuf) {
r = SC_ERROR_INTERNAL;
goto err;
}
memcpy(databuf->data + databuf->length, data, datalen);
oldlen = databuf->length;
if (!BUF_MEM_grow(databuf, oldlen + datalen)) {
r = SC_ERROR_INTERNAL;
goto err;
}
memcpy(databuf->data + oldlen, data, datalen);
databuf->length = oldlen + datalen;
macbuf = PACE_authenticate(psmctx->ctx, psmctx->protocol,
psmctx->key_mac, databuf);

3
ccid/pace.h
View File

@@ -58,6 +58,9 @@ pace_sm_ctx_free(struct pace_sm_ctx *ctx);
void
pace_sm_ctx_clear_free(struct pace_sm_ctx *ctx);
int reset_ssc(struct sm_ctx *ctx);
int increment_ssc(struct sm_ctx *ctx);
int pace_sm_encrypt(sc_card_t *card, const struct sm_ctx *ctx,
const u8 *data, size_t datalen, u8 **enc);
int pace_sm_decrypt(sc_card_t *card, const struct sm_ctx *ctx,

37
ccid/sm.c
View File

@@ -222,10 +222,9 @@ int sm_encrypt(const struct sm_ctx *ctx, sc_card_t *card,
const sc_apdu_t *apdu, sc_apdu_t *sm_apdu)
{
struct sc_asn1_entry sm_capdu[4];
u8 *le = NULL;
size_t oldlen;
BUF_MEM *fdata = NULL, *sm_data = NULL,
*mac_data = NULL, *mac = NULL, *tmp = NULL;
u8 *le = NULL, *sm_data = NULL;
size_t oldlen, sm_data_len;
BUF_MEM *fdata = NULL, *mac_data = NULL, *mac = NULL, *tmp = NULL;
int r;
if (!apdu || !ctx || !card || !card->slot || !sm_apdu) {
@@ -235,6 +234,11 @@ int sm_encrypt(const struct sm_ctx *ctx, sc_card_t *card,
sc_copy_asn1_entry(c_sm_capdu, sm_capdu);
sm_apdu->flags = apdu->flags;
sm_apdu->cla = 0x0C;
sm_apdu->ins = apdu->ins;
sm_apdu->p1 = apdu->p1;
sm_apdu->p2 = apdu->p2;
mac_data = format_head(ctx, apdu);
if (!mac_data) {
sc_error(card->ctx, "Could not format header of SM apdu.");
@@ -365,26 +369,16 @@ int sm_encrypt(const struct sm_ctx *ctx, sc_card_t *card,
/* format SM apdu */
sm_data = BUF_MEM_new();
if (!sm_data) {
r = SC_ERROR_OUT_OF_MEMORY;
goto err;
}
r = sc_asn1_encode(card->ctx, sm_capdu, (u8 **) &sm_data->data, &sm_data->length);
r = sc_asn1_encode(card->ctx, sm_capdu, (u8 **) &sm_data, &sm_data_len);
if (r < 0)
goto err;
memcpy(sm_apdu, apdu, sizeof *sm_apdu);
sm_apdu->cla = 0x0C;
sm_apdu->data = (u8 *) sm_data->data;
sm_apdu->lc = sm_data->length;
sm_apdu->data = sm_data;
sm_apdu->datalen = sm_data_len;
sm_apdu->lc = sm_apdu->datalen;
sm_apdu->le = 0;
sm_apdu->cse = SC_APDU_CASE_4;
/* BUF_MEM_free must not free sm_data->data */
sm_data->data = NULL;
sm_data->length = 0;
sm_data->max = 0;
bin_log(card->ctx, "sm apdu data", sm_apdu->data, sm_apdu->datalen);
printf("%s:%d\n", __FILE__, __LINE__);
err:
if (fdata) {
@@ -399,9 +393,6 @@ err:
if (mac) {
BUF_MEM_free(mac);
}
if (sm_data) {
BUF_MEM_free(sm_data);
}
if (le) {
free(le);
}