/src/opensc/src/sm/sm-iso.c

Source
/*
 * Copyright (C) 2011-2015 Frank Morgner
 *
 * This file is part of OpenSC.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "sm-iso-internal.h"
#include "libopensc/asn1.h"
#include "libopensc/log.h"
#include "sm/sm-iso.h"
#include <stdlib.h>
#include <string.h>

#ifdef ENABLE_SM

static const struct sc_asn1_entry c_sm_capdu[] = {
  { "Cryptogram",
    SC_ASN1_OCTET_STRING, SC_ASN1_CTX|0x05, SC_ASN1_OPTIONAL, NULL, NULL },
  { "Padding-content indicator followed by cryptogram",
    SC_ASN1_OCTET_STRING, SC_ASN1_CTX|0x07, SC_ASN1_OPTIONAL, NULL, NULL },
  { "Protected Le",
    SC_ASN1_OCTET_STRING, SC_ASN1_CTX|0x17, SC_ASN1_OPTIONAL, NULL, NULL },
  { "Cryptographic Checksum",
    SC_ASN1_OCTET_STRING, SC_ASN1_CTX|0x0E, SC_ASN1_OPTIONAL, NULL, NULL },
  { NULL , 0 , 0 , 0 , NULL , NULL }
};

static const struct sc_asn1_entry c_sm_rapdu[] = {
  { "Cryptogram",
    SC_ASN1_OCTET_STRING, SC_ASN1_CTX|0x05, SC_ASN1_OPTIONAL, NULL, NULL },
  { "Padding-content indicator followed by cryptogram" ,
    SC_ASN1_OCTET_STRING, SC_ASN1_CTX|0x07, SC_ASN1_OPTIONAL, NULL, NULL },
  { "Processing Status",
    SC_ASN1_OCTET_STRING, SC_ASN1_CTX|0x19, 0               , NULL, NULL },
  { "Cryptographic Checksum",
    SC_ASN1_OCTET_STRING, SC_ASN1_CTX|0x0E, SC_ASN1_OPTIONAL, NULL, NULL },
  { NULL, 0, 0, 0, NULL, NULL }
};

static int
add_iso_pad(const u8 *data, size_t datalen, size_t block_size, u8 **padded)
{
  u8 *p;
  int p_len;

  if (!padded)
    return SC_ERROR_INVALID_ARGUMENTS;

  /* calculate length of padded message */
  p_len = (int)((datalen / block_size) * block_size + block_size);

  p = realloc(*padded, p_len);
  if (!p)
    return SC_ERROR_OUT_OF_MEMORY;

  if (*padded != data)
    memcpy(p, data, datalen);

  *padded = p;

  /* now add iso padding */
  memset(p + datalen, 0x80, 1);
  memset(p + datalen + 1, 0, p_len - datalen - 1);

  return p_len;
}

static int
add_padding(const struct iso_sm_ctx *ctx, const u8 *data, size_t datalen,
    u8 **padded)
{
  u8 *p;

  switch (ctx->padding_indicator) {
    case SM_NO_PADDING:
      if (*padded != data) {
        if (datalen != 0) {
          p = realloc(*padded, datalen);
          if (!p)
            return SC_ERROR_OUT_OF_MEMORY;
          *padded = p;
          memcpy(*padded, data, datalen);
        } else {
          *padded = NULL;
        }
      }
      return (int)datalen;
    case SM_ISO_PADDING:
      return add_iso_pad(data, datalen, ctx->block_length, padded);
    default:
      return SC_ERROR_INVALID_ARGUMENTS;
  }
}

static int
rm_padding(u8 padding_indicator, const u8 *data, size_t datalen)
{
  size_t len;

  if (!datalen || !data)
    return SC_ERROR_INVALID_ARGUMENTS;

  switch (padding_indicator) {
    case SM_NO_PADDING:
      len = datalen;
      break;

    case SM_ISO_PADDING:
      len = datalen;

      while (len) {
        len--;
        if (data[len])
          break;
      }

      if (data[len] != 0x80)
        return SC_ERROR_INVALID_DATA;

      break;

    default:
      return SC_ERROR_NOT_SUPPORTED;
  }

  return (int)len;
}

static int format_le(size_t le, struct sc_asn1_entry *le_entry,
    u8 **lebuf, size_t *le_len)
{
  u8 *p;

  if (!lebuf || !le_len || !*le_len)
    return SC_ERROR_INVALID_ARGUMENTS;

  p = realloc(*lebuf, *le_len);
  if (!p)
    return SC_ERROR_OUT_OF_MEMORY;
  *lebuf = p;

  switch (*le_len) {
    case 1:
      p[0] = le & 0xff;
      break;
    case 2:
      p[0] = (le >> 8) & 0xff;
      p[1] = le & 0xff;
      break;
    case 3:
      p[0] = 0x00;
      p[1] = (le >> 8) & 0xff;
      p[2] = le & 0xff;
      break;
    default:
      return SC_ERROR_INVALID_ARGUMENTS;
  }

  sc_format_asn1_entry(le_entry, *lebuf, le_len, SC_ASN1_PRESENT);

  return SC_SUCCESS;
}

static int prefix_buf(u8 prefix, u8 *buf, size_t buflen, u8 **cat)
{
  u8 *p = NULL;
  int ptr_same = *cat == buf;

  p = realloc(*cat, buflen + 1);
  if (!p)
    return SC_ERROR_OUT_OF_MEMORY;

  if (ptr_same) {
    memmove(p + 1, p, buflen);
  } else {
    memcpy(p + 1, buf, buflen);
  }
  p[0] = prefix;

  *cat = p;

  return (int)buflen + 1;
}

static int format_data(sc_card_t *card, const struct iso_sm_ctx *ctx,
    int prepend_padding_indicator, const u8 *data, size_t datalen,
    struct sc_asn1_entry *formatted_encrypted_data_entry,
    u8 **formatted_data, size_t *formatted_data_len)
{
  int r;
  u8 *pad_data = NULL;
  size_t pad_data_len = 0;

  if (!ctx || !formatted_data || !formatted_data_len) {
    r = SC_ERROR_INVALID_ARGUMENTS;
    goto err;
  }

  r = add_padding(ctx, data, datalen, &pad_data);
  if (r < 0) {
    sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not add padding to data: %s",
        sc_strerror(r));
    goto err;
  }
  pad_data_len = r;

  sc_log_hex(card->ctx, "Data to encrypt", pad_data, pad_data_len);
  r = ctx->encrypt(card, ctx, pad_data, pad_data_len, formatted_data);
  if (r < 0) {
    sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not encrypt the data");
    goto err;
  }
  sc_log_hex(card->ctx, "Cryptogram", *formatted_data, r);

  if (prepend_padding_indicator) {
    r = prefix_buf(ctx->padding_indicator, *formatted_data, r, formatted_data);
    if (r < 0) {
      sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not prepend padding indicator to formatted "
          "data: %s", sc_strerror(r));
      goto err;
    }
  }

  *formatted_data_len = r;
  sc_format_asn1_entry(formatted_encrypted_data_entry,
      *formatted_data, formatted_data_len, SC_ASN1_PRESENT);

  r = SC_SUCCESS;

err:
  if (pad_data) {
    sc_mem_clear(pad_data, pad_data_len);
    free(pad_data);
  }

  return r;
}

static int format_head(const struct iso_sm_ctx *ctx, const sc_apdu_t *apdu,
    u8 **formatted_head)
{
  u8 *p;

  if (!apdu || !formatted_head)
    return SC_ERROR_INVALID_ARGUMENTS;

  p = realloc(*formatted_head, 4);
  if (!p)
    return SC_ERROR_OUT_OF_MEMORY;

  p[0] = apdu->cla;
  p[1] = apdu->ins;
  p[2] = apdu->p1;
  p[3] = apdu->p2;
  *formatted_head = p;

  return add_padding(ctx, *formatted_head, 4, formatted_head);
}

static int sm_encrypt(const struct iso_sm_ctx *ctx, sc_card_t *card,
    const sc_apdu_t *apdu, sc_apdu_t **psm_apdu)
{
  struct sc_asn1_entry sm_capdu[5];
  u8 *p, *le = NULL, *sm_data = NULL, *fdata = NULL, *mac_data = NULL,
     *asn1 = NULL, *mac = NULL, *resp_data = NULL;
  size_t sm_data_len, fdata_len, mac_data_len, asn1_len, mac_len, le_len;
  int r;
  sc_apdu_t *sm_apdu = NULL;

  if (!apdu || !ctx || !card || !card->reader || !psm_apdu) {
    r = SC_ERROR_INVALID_ARGUMENTS;
    goto err;
  }

  if ((apdu->cla & 0x0C) == 0x0C) {
    r = SC_ERROR_INVALID_ARGUMENTS;
    sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Given APDU is already protected with some secure messaging");
    goto err;
  }

  sc_copy_asn1_entry(c_sm_capdu, sm_capdu);

  sm_apdu = malloc(sizeof(sc_apdu_t));
  if (!sm_apdu) {
    r = SC_ERROR_OUT_OF_MEMORY;
    goto err;
  }
  sm_apdu->control = apdu->control;
  sm_apdu->flags = apdu->flags;
  sm_apdu->cla = apdu->cla|0x0C;
  sm_apdu->ins = apdu->ins;
  sm_apdu->p1 = apdu->p1;
  sm_apdu->p2 = apdu->p2;
  r = format_head(ctx, sm_apdu, &mac_data);
  if (r < 0) {
    sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format header of SM apdu");
    goto err;
  }
  mac_data_len = r;

  switch (apdu->cse) {
    case SC_APDU_CASE_1:
      break;
  case SC_APDU_CASE_2_SHORT:
      le_len = 1;
      r = format_le(apdu->le, sm_capdu + 2, &le, &le_len);
      if (r < 0) {
        sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format Le of SM apdu");
        goto err;
      }
      sc_log_hex(card->ctx, "Protected Le (plain)", le, le_len);
      break;
  case SC_APDU_CASE_2_EXT:
      if (card->reader->active_protocol == SC_PROTO_T0) {
        /* T0 extended APDUs look just like short APDUs */
        le_len = 1;
        r = format_le(apdu->le, sm_capdu + 2, &le, &le_len);
        if (r < 0) {
          sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format Le of SM apdu");
          goto err;
        }
      } else {
        /* in case of T1 always use 2 bytes for length */
        le_len = 2;
        r = format_le(apdu->le, sm_capdu + 2, &le, &le_len);
        if (r < 0) {
          sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format Le of SM apdu");
          goto err;
        }
      }
      sc_log_hex(card->ctx, "Protected Le (plain)", le, le_len);
      break;
    case SC_APDU_CASE_3_SHORT:
    case SC_APDU_CASE_3_EXT:
      if (apdu->ins & 1) {
        r = format_data(card, ctx, 0, apdu->data, apdu->datalen,
            sm_capdu + 0, &fdata, &fdata_len);
      } else {
        r = format_data(card, ctx, 1, apdu->data, apdu->datalen,
            sm_capdu + 1, &fdata, &fdata_len);
      }
      if (r < 0) {
        sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format data of SM apdu");
        goto err;
      }
      sc_log_hex(card->ctx, "Padding-content indicator followed by cryptogram (plain)",
          fdata, fdata_len);
      break;
    case SC_APDU_CASE_4_SHORT:
      /* in case of T0 no Le byte is added */
      if (card->reader->active_protocol != SC_PROTO_T0) {
        le_len = 1;
        r = format_le(apdu->le, sm_capdu + 2, &le, &le_len);
        if (r < 0) {
          sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format Le of SM apdu");
          goto err;
        }
        sc_log_hex(card->ctx, "Protected Le (plain)", le, le_len);
      }

      if (apdu->ins & 1) {
        r = format_data(card, ctx, 0, apdu->data, apdu->datalen,
            sm_capdu + 0, &fdata, &fdata_len);
      } else {
        r = format_data(card, ctx, 1, apdu->data, apdu->datalen,
            sm_capdu + 1, &fdata, &fdata_len);
      }
      if (r < 0) {
        sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format data of SM apdu");
        goto err;
      }
      sc_log_hex(card->ctx, "Padding-content indicator followed by cryptogram (plain)",
          fdata, fdata_len);
      break;
    case SC_APDU_CASE_4_EXT:
      if (card->reader->active_protocol == SC_PROTO_T0) {
        /* again a T0 extended case 4 APDU looks just
         * like a short APDU, the additional data is
         * transferred using ENVELOPE and GET RESPONSE */
      } else {
        /* only 2 bytes are use to specify the length of the
         * expected data */
        le_len = 2;
        r = format_le(apdu->le, sm_capdu + 2, &le, &le_len);
        if (r < 0) {
          sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format Le of SM apdu");
          goto err;
        }
        sc_log_hex(card->ctx, "Protected Le (plain)", le, le_len);
      }

      if (apdu->ins & 1) {
        r = format_data(card, ctx, 0, apdu->data, apdu->datalen,
            sm_capdu + 0, &fdata, &fdata_len);
      } else {
        r = format_data(card, ctx, 1, apdu->data, apdu->datalen,
            sm_capdu + 1, &fdata, &fdata_len);
      }
      if (r < 0) {
        sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not format data of SM apdu");
        goto err;
      }
      sc_log_hex(card->ctx, "Padding-content indicator followed by cryptogram (plain)",
          fdata, fdata_len);
      break;
    default:
      sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Unhandled apdu case");
      r = SC_ERROR_INVALID_DATA;
      goto err;
  }


  r = sc_asn1_encode(card->ctx, sm_capdu, (u8 **) &asn1, &asn1_len);
  if (r < 0) {
    goto err;
  }
  if (asn1_len) {
    p = realloc(mac_data, mac_data_len + asn1_len);
    if (!p) {
      r = SC_ERROR_OUT_OF_MEMORY;
      goto err;
    }
    mac_data = p;
    memcpy(mac_data + mac_data_len, asn1, asn1_len);
    mac_data_len += asn1_len;
    r = add_padding(ctx, mac_data, mac_data_len, &mac_data);
    if (r < 0) {
      goto err;
    }
    mac_data_len = r;
  }
  sc_log_hex(card->ctx, "Data to authenticate", mac_data, mac_data_len);

  r = ctx->authenticate(card, ctx, mac_data, mac_data_len,
      &mac);
  if (r < 0) {
    sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not get authentication code");
    goto err;
  }
  mac_len = r;
  sc_log_hex(card->ctx, "Cryptographic Checksum (plain)", mac, mac_len);


  /* format SM apdu */
  sc_format_asn1_entry(sm_capdu + 3, mac, &mac_len, SC_ASN1_PRESENT);
  r = sc_asn1_encode(card->ctx, sm_capdu, (u8 **) &sm_data, &sm_data_len);
  if (r < 0)
    goto err;
  sm_apdu->data = sm_data;
  sm_apdu->datalen = sm_data_len;
  sm_apdu->lc = sm_data_len;
  sm_apdu->le = 0;
  /* for encrypted APDUs we usually get authenticated status bytes (4B), a
   * MAC (2B without data) and a cryptogram with padding indicator (2B tag
   * and indicator, max. 2B/3B ASN.1 length, without data). The cryptogram is
   * always padded to the block size. */
  if (apdu->cse & SC_APDU_EXT) {
    sm_apdu->cse = SC_APDU_CASE_4_EXT;
    sm_apdu->resplen = 4 + 2 + mac_len + 2 + 3 + ((apdu->resplen+1)/ctx->block_length+1)*ctx->block_length;
    if (sm_apdu->resplen > SC_MAX_EXT_APDU_RESP_SIZE)
      sm_apdu->resplen = SC_MAX_EXT_APDU_RESP_SIZE;
  } else {
    sm_apdu->cse = SC_APDU_CASE_4_SHORT;
    sm_apdu->resplen = 4 + 2 + mac_len + 2 + 2 + ((apdu->resplen+1)/ctx->block_length+1)*ctx->block_length;
    if (sm_apdu->resplen > SC_MAX_APDU_RESP_SIZE)
      sm_apdu->resplen = SC_MAX_APDU_RESP_SIZE;
  }
  resp_data = calloc(1, sm_apdu->resplen);
  if (!resp_data) {
    r = SC_ERROR_OUT_OF_MEMORY;
    goto err;
  }
  sm_apdu->resp = resp_data;
  sc_log_hex(card->ctx, "ASN.1 encoded encrypted APDU data", sm_apdu->data, sm_apdu->datalen);

  *psm_apdu = sm_apdu;

err:
  free(fdata);
  free(asn1);
  free(mac_data);
  free(mac);
  free(le);
  if (r < 0) {
    free(resp_data);
    free(sm_apdu);
    free(sm_data);
  }

  return r;
}

static int sm_decrypt(const struct iso_sm_ctx *ctx, sc_card_t *card,
    const sc_apdu_t *sm_apdu, sc_apdu_t *apdu)
{
  int r;
  struct sc_asn1_entry sm_rapdu[5];
  struct sc_asn1_entry my_sm_rapdu[5];
  u8 sw[2], mac[8], fdata[SC_MAX_EXT_APDU_BUFFER_SIZE];
  size_t sw_len = sizeof sw, mac_len = sizeof mac, fdata_len = sizeof fdata,
       buf_len, asn1_len, fdata_offset = 0;
  const u8 *buf;
  u8 *data = NULL, *mac_data = NULL, *asn1 = NULL;

  sc_copy_asn1_entry(c_sm_rapdu, sm_rapdu);
  sc_format_asn1_entry(sm_rapdu + 0, fdata, &fdata_len, 0);
  sc_format_asn1_entry(sm_rapdu + 1, fdata, &fdata_len, 0);
  sc_format_asn1_entry(sm_rapdu + 2, sw, &sw_len, 0);
  sc_format_asn1_entry(sm_rapdu + 3, mac, &mac_len, 0);

  r = sc_asn1_decode(card->ctx, sm_rapdu, sm_apdu->resp, sm_apdu->resplen,
      &buf, &buf_len);
  if (r < 0)
    goto err;
  if (buf_len > 0) {
    r = SC_ERROR_UNKNOWN_DATA_RECEIVED;
    goto err;
  }


  if (sm_rapdu[3].flags & SC_ASN1_PRESENT) {
    /* copy from sm_apdu to my_sm_apdu, but leave mac at default */
    sc_copy_asn1_entry(sm_rapdu, my_sm_rapdu);
    sc_copy_asn1_entry(&c_sm_rapdu[3], &my_sm_rapdu[3]);

    r = sc_asn1_encode(card->ctx, my_sm_rapdu, &asn1, &asn1_len);
    if (r < 0)
      goto err;
    r = add_padding(ctx, asn1, asn1_len, &mac_data);
    if (r < 0) {
      goto err;
    }

    r = ctx->verify_authentication(card, ctx, mac, mac_len,
        mac_data, r);
    if (r < 0)
      goto err;
  } else {
    sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Cryptographic Checksum missing");
    r = SC_ERROR_ASN1_OBJECT_NOT_FOUND;
    goto err;
  }


  if (sm_rapdu[1].flags & SC_ASN1_PRESENT) {
    if (ctx->padding_indicator != fdata[0]) {
      r = SC_ERROR_UNKNOWN_DATA_RECEIVED;
      goto err;
    }
    fdata_offset = 1;
  }
  if (sm_rapdu[0].flags & SC_ASN1_PRESENT
      || sm_rapdu[1].flags & SC_ASN1_PRESENT) {
    r = ctx->decrypt(card, ctx, fdata + fdata_offset,
        fdata_len - fdata_offset, &data);
    if (r < 0)
      goto err;
    buf_len = r;

    r = rm_padding(ctx->padding_indicator, data, buf_len);
    if (r < 0) {
      sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Could not remove padding");
      goto err;
    }

    if (apdu->resplen < (size_t) r || (r && !apdu->resp)) {
      sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE,
          "Response of SM APDU %"SC_FORMAT_LEN_SIZE_T"u byte%s too long",
          r-apdu->resplen,
          r-apdu->resplen < 2 ? "" : "s");
      r = SC_ERROR_OUT_OF_MEMORY;
      goto err;
    }
    memcpy(apdu->resp, data, r);
    apdu->resplen = r;
  } else {
    apdu->resplen = 0;
  }

  if (sm_rapdu[2].flags & SC_ASN1_PRESENT) {
    if (sw_len != 2) {
      sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Length of processing status bytes must be 2");
      r = SC_ERROR_ASN1_END_OF_CONTENTS;
      goto err;
    }
    apdu->sw1 = sw[0];
    apdu->sw2 = sw[1];
  } else {
    sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Authenticated status bytes are missing");
    r = SC_ERROR_ASN1_OBJECT_NOT_FOUND;
    goto err;
  }

  sc_log(card->ctx,  "Decrypted APDU sw1=%02x sw2=%02x",
      apdu->sw1, apdu->sw2);
  sc_log_hex(card->ctx, "Decrypted APDU response data",
      apdu->resp, apdu->resplen);

  r = SC_SUCCESS;

err:
  free(asn1);
  free(mac_data);
  if (data) {
    sc_mem_clear(data, buf_len);
    free(data);
  }

  return r;
}

static int iso_add_sm(struct iso_sm_ctx *sctx, sc_card_t *card,
    sc_apdu_t *apdu, sc_apdu_t **sm_apdu)
{
  if (!card || !sctx)
    return SC_ERROR_INVALID_ARGUMENTS;

  if ((apdu->cla & 0x0C) == 0x0C) {
    sc_debug(card->ctx, SC_LOG_DEBUG_VERBOSE, "Given APDU is already protected with some secure messaging. Closing own SM context.");
    LOG_TEST_RET(card->ctx, sc_sm_stop(card),
        "Could not close ISO SM session");
    return SC_ERROR_SM_NOT_APPLIED;
  }

  if (sctx->pre_transmit)
    LOG_TEST_RET(card->ctx, sctx->pre_transmit(card, sctx, apdu),
        "Could not complete SM specific pre transmit routine");
  LOG_TEST_RET(card->ctx, sm_encrypt(sctx, card, apdu, sm_apdu),
      "Could not encrypt APDU");

  return SC_SUCCESS;
}

static int iso_rm_sm(struct iso_sm_ctx *sctx, sc_card_t *card,
    sc_apdu_t *sm_apdu, sc_apdu_t *apdu)
{
  if (!sctx)
    LOG_TEST_RET(card->ctx, SC_ERROR_INVALID_ARGUMENTS,
      "Invalid SM context. No SM processing performed.");

  if (sctx->post_transmit)
    LOG_TEST_RET(card->ctx, sctx->post_transmit(card, sctx, sm_apdu),
        "Could not complete SM specific post transmit routine");
  LOG_TEST_RET(card->ctx, sm_decrypt(sctx, card, sm_apdu, apdu),
      "Could not decrypt APDU");
  if (sctx->finish)
    LOG_TEST_RET(card->ctx, sctx->finish(card, sctx, apdu),
        "Could not complete SM specific post transmit routine");

  return SC_SUCCESS;
}

int iso_sm_close(struct sc_card *card)
{
  if (card) {
    iso_sm_ctx_clear_free(card->sm_ctx.info.cmd_data);
    card->sm_ctx.info.cmd_data = NULL;
  }

  return SC_SUCCESS;
}

int iso_get_sm_apdu(struct sc_card *card, struct sc_apdu *apdu, struct sc_apdu **sm_apdu)
{
  return iso_add_sm(card->sm_ctx.info.cmd_data, card, apdu, sm_apdu);
}

int iso_free_sm_apdu(struct sc_card *card, struct sc_apdu *apdu, struct sc_apdu **sm_apdu)
{
  struct sc_apdu *p;
  int r;

  if (!sm_apdu)
    return SC_ERROR_INVALID_ARGUMENTS;

  p = *sm_apdu;

  r = iso_rm_sm(card->sm_ctx.info.cmd_data, card, p, apdu);

  if (p) {
    free((unsigned char *) p->data);
    free((unsigned char *) p->resp);
  }
  free(*sm_apdu);
  *sm_apdu = NULL;

  return r;
}

struct iso_sm_ctx *iso_sm_ctx_create(void)
{
  struct iso_sm_ctx *sctx = malloc(sizeof *sctx);
  if (!sctx)
    return NULL;

  sctx->priv_data = NULL;
  sctx->padding_indicator = SM_ISO_PADDING;
  sctx->block_length = 0;
  sctx->authenticate = NULL;
  sctx->verify_authentication = NULL;
  sctx->encrypt = NULL;
  sctx->decrypt = NULL;
  sctx->pre_transmit = NULL;
  sctx->post_transmit = NULL;
  sctx->finish = NULL;
  sctx->clear_free = NULL;

  return sctx;
}

void iso_sm_ctx_clear_free(struct iso_sm_ctx *sctx)
{
  if (sctx && sctx->clear_free)
    sctx->clear_free(sctx);
  free(sctx);
}

int iso_sm_start(struct sc_card *card, struct iso_sm_ctx *sctx)
{
  if (!card)
    return SC_ERROR_INVALID_ARGUMENTS;

  if (card->sm_ctx.ops.close)
    card->sm_ctx.ops.close(card);

  card->sm_ctx.info.cmd_data = sctx;
  card->sm_ctx.ops.close = iso_sm_close;
  card->sm_ctx.ops.free_sm_apdu = iso_free_sm_apdu;
  card->sm_ctx.ops.get_sm_apdu = iso_get_sm_apdu;
  card->sm_ctx.sm_mode = SM_MODE_TRANSMIT;

  return SC_SUCCESS;
}

#else

int iso_sm_close(struct sc_card *card)
{
  return SC_ERROR_NOT_SUPPORTED;
}

int iso_get_sm_apdu(struct sc_card *card, struct sc_apdu *apdu, struct sc_apdu **sm_apdu)
{
  return SC_ERROR_NOT_SUPPORTED;
}

struct iso_sm_ctx *iso_sm_ctx_create(void)
{
  return NULL;
}

void iso_sm_ctx_clear_free(struct iso_sm_ctx *sctx)
{
}

int iso_sm_start(struct sc_card *card, struct iso_sm_ctx *sctx)
{
  return SC_ERROR_NOT_SUPPORTED;
}

#endif

Coverage Report

Created: 2026-03-08 07:03