client/src/emv/dol.c

   1 //-----------------------------------------------------------------------------
   2 // Borrowed initially from https://github.com/lumag/emv-tools/
   3 // Copyright (C) 2012, 2015 Dmitry Eremin-Solenikov
   4 // Copyright (C) Proxmark3 contributors. See AUTHORS.md for details.
   5 //
   6 // This program is free software: you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation, either version 3 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // See LICENSE.txt for the text of the license.
  17 //-----------------------------------------------------------------------------
  18 // libopenemv - a library to work with EMV family of smart cards
  19 //-----------------------------------------------------------------------------
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include "emv/dol.h"
  26 #include "emv/tlv.h"
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 static size_t dol_calculate_len(const struct tlv *tlv, size_t data_len) {
  32     if (!tlv)
  33         return 0;
  34
  35     const unsigned char *buf = tlv->value;
  36     size_t left = tlv->len;
  37     size_t count = 0;
  38
  39     while (left) {
  40         struct tlv cur_tlv;
  41         if (!tlv_parse_tl(&buf, &left, &cur_tlv))
  42             return 0;
  43
  44         count += cur_tlv.len;
  45
  46         /* Last tag can be of variable length */
  47         if (cur_tlv.len == 0 && left == 0)
  48             count = data_len;
  49     }
  50
  51     return count;
  52 }
  53
  54 struct tlv *dol_process(const struct tlv *tlv, const struct tlvdb *tlvdb, tlv_tag_t tag) {
  55     size_t res_len;
  56     if (!tlv || !(res_len = dol_calculate_len(tlv, 0))) {
  57         struct tlv *res_tlv = calloc(1, sizeof(*res_tlv));
  58
  59         res_tlv->tag = tag;
  60         res_tlv->len = 0;
  61         res_tlv->value = NULL;
  62
  63         return res_tlv;
  64     }
  65
  66     struct tlv *res_tlv = calloc(1, sizeof(*res_tlv) + res_len);
  67     if (!res_tlv)
  68         return NULL;
  69
  70     const unsigned char *buf = tlv->value;
  71     size_t left = tlv->len;
  72     unsigned char *res = (unsigned char *)(res_tlv + 1);
  73     size_t pos = 0;
  74
  75     while (left) {
  76         struct tlv cur_tlv;
  77         if (!tlv_parse_tl(&buf, &left, &cur_tlv) || pos + cur_tlv.len > res_len) {
  78             free(res_tlv);
  79
  80             return NULL;
  81         }
  82
  83         const struct tlv *tag_tlv = tlvdb_get(tlvdb, cur_tlv.tag, NULL);
  84         if (!tag_tlv) {
  85             memset(res + pos, 0, cur_tlv.len);
  86         } else if (tag_tlv->len > cur_tlv.len) {
  87             memcpy(res + pos, tag_tlv->value, cur_tlv.len);
  88         } else {
  89             // FIXME: cn data should be padded with 0xFF !!!
  90             memcpy(res + pos, tag_tlv->value, tag_tlv->len);
  91             memset(res + pos + tag_tlv->len, 0, cur_tlv.len - tag_tlv->len);
  92         }
  93         pos += cur_tlv.len;
  94     }
  95
  96     res_tlv->tag = tag;
  97     res_tlv->len = res_len;
  98     res_tlv->value = res;
  99
 100     return res_tlv;
 101 }
 102
 103 struct tlvdb *dol_parse(const struct tlv *tlv, const unsigned char *data, size_t data_len) {
 104     if (!tlv)
 105         return NULL;
 106
 107     const unsigned char *buf = tlv->value;
 108     size_t left = tlv->len;
 109     size_t res_len = dol_calculate_len(tlv, data_len);
 110     size_t pos = 0;
 111     struct tlvdb *db = NULL;
 112
 113     if (res_len != data_len)
 114         return NULL;
 115
 116     while (left) {
 117         struct tlv cur_tlv;
 118         if (!tlv_parse_tl(&buf, &left, &cur_tlv) || pos + cur_tlv.len > res_len) {
 119             tlvdb_free(db);
 120             return NULL;
 121         }
 122
 123         /* Last tag can be of variable length */
 124         if (cur_tlv.len == 0 && left == 0)
 125             cur_tlv.len = res_len - pos;
 126
 127         struct tlvdb *tag_db = tlvdb_fixed(cur_tlv.tag, cur_tlv.len, data + pos);
 128         if (!db)
 129             db = tag_db;
 130         else
 131             tlvdb_add(db, tag_db);
 132
 133         pos += cur_tlv.len;
 134     }
 135
 136     return db;
 137 }