cvs.zerfleddert.de Git - proxmark3-svn/blob - armsrc/emvutil.c

   1 //-----------------------------------------------------------------------------
   2 // Peter Fillmore 2015
   3 // Many authors, whom made it possible
   4 //
   5 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
   6 // at your option, any later version. See the LICENSE.txt file for the text of
   7 // the license.
   8 //-----------------------------------------------------------------------------
   9 // various EMV related functions.
  10 //-----------------------------------------------------------------------------
  11 #include <stdarg.h>
  12 #include "proxmark3.h"
  13 #include "apps.h"
  14 #include "util.h"
  15 #include "string.h"
  16
  17 #include "BigBuf.h"
  18
  19 #include "iso14443crc.h"
  20 #include "iso14443a.h"
  21 #include "emvutil.h"
  22 #include "emvdataels.h" //EMV data elements
  23 #include "emvtags.h" //EMV card structure
  24
  25 #define DUMP(varname) Dbprintf("%s=", #varname);
  26
  27 int EMV_DBGLEVEL = EMV_DBG_ALL;
  28 //uint8_t PCB = 0x00; //track Protocol Control Byte externally
  29
  30 //util functions
  31 //print detected tag name over the serial link
  32 int emv_printtag(uint8_t* selected_tag, emvtags* inputcard, uint8_t* outputstring, uint8_t* outputlen)
  33 {
  34     //search tag list and print the match
  35     //get the value of the tag
  36     uint8_t tagvalue[255];
  37     uint8_t tagvaluelen;
  38     emv_lookuptag(selected_tag, inputcard, tagvalue, &tagvaluelen);
  39     //loop through selected tag, print the value found
  40     for(int i=0; i<(sizeof(EMV_TAG_LIST)/sizeof(EMV_TAG_LIST[0])); i++){
  41         if(!memcmp(selected_tag, EMV_TAG_LIST[i].tag, 2)){
  42             memcpy(outputstring, EMV_TAG_LIST[i].description, strlen(EMV_TAG_LIST[i].description));
  43             memcpy(outputstring+(strlen(EMV_TAG_LIST[i].description)), "=", 1);
  44             memcpy(outputstring+(strlen(EMV_TAG_LIST[i].description))+1, tagvalue, tagvaluelen);
  45             *outputlen = strlen(EMV_TAG_LIST[i].description) + 1 + tagvaluelen;
  46             break;
  47         }
  48     }
  49     return 0;
  50 }
  51
  52 //returns the value of the emv tag in the supplied emvtags structure
  53 int emv_lookuptag(uint8_t* tag, emvtags *currentcard, uint8_t* outputval, uint8_t* outputvallen)
  54 {
  55     //loop through tag and return the appropriate value
  56     uint8_t returnedtag[255];
  57     uint8_t returnedlength;
  58     memset(returnedtag, 0x00, sizeof(returnedtag));
  59     if(!memcmp(tag, "\x4F\x00",2)){
  60          memcpy(&returnedtag, currentcard->tag_4F,  currentcard->tag_4F_len);
  61          returnedlength = currentcard->tag_4F_len; goto exitfunction;}
  62     else if(!memcmp(tag, "\x50\x00",2)){
  63          memcpy(&returnedtag, currentcard->tag_50,  currentcard->tag_50_len);
  64          returnedlength = currentcard->tag_50_len; goto exitfunction;}
  65     else if(!memcmp(tag, "\x56\x00",2)){
  66          memcpy(&returnedtag, currentcard->tag_56,  currentcard->tag_56_len);
  67          returnedlength = currentcard->tag_56_len; goto exitfunction;}
  68     else if(!memcmp(tag, "\x57\x00",2)){
  69          memcpy(&returnedtag, currentcard->tag_57,  currentcard->tag_57_len);
  70          returnedlength = currentcard->tag_57_len; goto exitfunction;}
  71     else if(!memcmp(tag, "\x5A\x00",2)){
  72          memcpy(&returnedtag, currentcard->tag_5A,  currentcard->tag_5A_len);
  73          returnedlength = currentcard->tag_5A_len; goto exitfunction;}
  74     else if(!memcmp(tag, "\x82\x00",2)){
  75          memcpy(&returnedtag, currentcard->tag_82,  sizeof(currentcard->tag_82));
  76          returnedlength = sizeof(currentcard->tag_82);goto exitfunction;}
  77     else if(!memcmp(tag, "\x84\x00",2)){
  78          memcpy(&returnedtag, currentcard->tag_84,  currentcard->tag_84_len);
  79          returnedlength = currentcard->tag_84_len; goto exitfunction;}
  80     else if(!memcmp(tag, "\x86\x00",2)){
  81          memcpy(&returnedtag, currentcard->tag_86,  currentcard->tag_86_len);
  82          returnedlength = currentcard->tag_86_len; goto exitfunction;}
  83     else if(!memcmp(tag, "\x87\x00",2)){
  84          memcpy(&returnedtag, currentcard->tag_87,  sizeof(currentcard->tag_87));
  85          returnedlength = sizeof(currentcard->tag_87);goto exitfunction;}
  86     else if(!memcmp(tag, "\x88\x00",2)){
  87          memcpy(&returnedtag, currentcard->tag_88,  currentcard->tag_50_len);
  88          returnedlength = sizeof(currentcard->tag_88); goto exitfunction;}
  89     else if(!memcmp(tag, "\x8A\x00",2)){
  90          memcpy(&returnedtag, currentcard->tag_8A,  sizeof(currentcard->tag_8A));
  91          returnedlength = sizeof(currentcard->tag_8A);goto exitfunction;}
  92     else if(!memcmp(tag, "\x8C\x00",2)){
  93          memcpy(&returnedtag, currentcard->tag_8C,  currentcard->tag_8C_len);
  94          returnedlength = currentcard->tag_8C_len; goto exitfunction;}
  95     else if(!memcmp(tag, "\x8D\x00",2)){
  96          memcpy(&returnedtag, currentcard->tag_8D,  currentcard->tag_8D_len);
  97          returnedlength = currentcard->tag_8D_len; goto exitfunction;}
  98     else if(!memcmp(tag, "\x8E\x00",2)){
  99         memcpy(&returnedtag, currentcard->tag_8E,  currentcard->tag_8E_len);
 100          returnedlength = currentcard->tag_8E_len; goto exitfunction;}
 101     else if(!memcmp(tag, "\x8F\x00",2)){
 102          memcpy(&returnedtag, currentcard->tag_8F,  sizeof(currentcard->tag_8F));
 103          returnedlength = sizeof(currentcard->tag_8F);goto exitfunction;}
 104     else if(!memcmp(tag, "\x90\x00",2)){
 105          memcpy(&returnedtag, currentcard->tag_90,  currentcard->tag_90_len);
 106          returnedlength = currentcard->tag_90_len; goto exitfunction;}
 107     else if(!memcmp(tag, "\x92\x00",2)){
 108          memcpy(&returnedtag, currentcard->tag_92,  currentcard->tag_92_len);
 109          returnedlength = currentcard->tag_92_len; goto exitfunction;}
 110     else if(!memcmp(tag, "\x93\x00",2)){
 111          memcpy(&returnedtag, currentcard->tag_93,  currentcard->tag_93_len);
 112          returnedlength = currentcard->tag_93_len; goto exitfunction;}
 113     else if(!memcmp(tag, "\x94\x00",2)){
 114          memcpy(&returnedtag, currentcard->tag_94,  currentcard->tag_94_len);
 115          returnedlength = currentcard->tag_94_len; goto exitfunction;}
 116     else if(!memcmp(tag, "\x95\x00",2)){
 117          memcpy(&returnedtag, currentcard->tag_95,  sizeof(currentcard->tag_95));
 118          returnedlength = sizeof(currentcard->tag_95);goto exitfunction;}
 119     else if(!memcmp(tag, "\x97\x00",2)){
 120         memcpy(&returnedtag, currentcard->tag_97,  currentcard->tag_97_len);
 121          returnedlength = currentcard->tag_97_len; goto exitfunction;}
 122     else if(!memcmp(tag, "\x98\x00",2)){
 123          memcpy(&returnedtag, currentcard->tag_98,  sizeof(currentcard->tag_98));
 124          returnedlength = sizeof(currentcard->tag_98);goto exitfunction;}
 125     else if(!memcmp(tag, "\x99\x00",2)){
 126         memcpy(&returnedtag, currentcard->tag_99,  currentcard->tag_99_len);
 127          returnedlength = currentcard->tag_99_len; goto exitfunction;}
 128     else if(!memcmp(tag, "\x9A\x00",2)){
 129          memcpy(&returnedtag, currentcard->tag_9A,  sizeof(currentcard->tag_9A));
 130          returnedlength = sizeof(currentcard->tag_9A);goto exitfunction;}
 131     else if(!memcmp(tag, "\x9B\x00",2)){
 132          memcpy(&returnedtag, currentcard->tag_9B,  sizeof(currentcard->tag_9B));
 133          returnedlength = sizeof(currentcard->tag_9B);goto exitfunction;}
 134     else if(!memcmp(tag, "\x9C\x00",2)){
 135          memcpy(&returnedtag, currentcard->tag_9C,  sizeof(currentcard->tag_9C));
 136          returnedlength = sizeof(currentcard->tag_9C);goto exitfunction;}
 137     else if(!memcmp(tag, "\x9D\x00",2)){
 138          memcpy(&returnedtag, currentcard->tag_9D,  currentcard->tag_9D_len);
 139          returnedlength = currentcard->tag_9D_len; goto exitfunction;}
 140     else if(!memcmp(tag, "\x9D\x00",2)){
 141          memcpy(&returnedtag, currentcard->tag_9D,  currentcard->tag_9D_len);
 142          returnedlength = currentcard->tag_9D_len; goto exitfunction;}
 143     else if(!memcmp(tag, "\xCD\x00",2)){
 144          memcpy(&returnedtag, currentcard->tag_CD,  sizeof(currentcard->tag_CD));
 145          returnedlength = sizeof(currentcard->tag_CD);goto exitfunction;}
 146     else if(!memcmp(tag, "\xCE\x00",2)){
 147          memcpy(&returnedtag, currentcard->tag_CE,  sizeof(currentcard->tag_CE));
 148          returnedlength = sizeof(currentcard->tag_CE);goto exitfunction;}
 149     else if(!memcmp(tag, "\xCF\x00",2)){
 150          memcpy(&returnedtag, currentcard->tag_CF,  sizeof(currentcard->tag_CF));
 151          returnedlength = sizeof(currentcard->tag_CF);goto exitfunction;}
 152     else if(!memcmp(tag, "\xD7\x00",2)){
 153          memcpy(&returnedtag, currentcard->tag_D7,  sizeof(currentcard->tag_D7));
 154          returnedlength = sizeof(currentcard->tag_D7);goto exitfunction;}
 155     else if(!memcmp(tag, "\xD8\x00",2)){
 156          memcpy(&returnedtag, currentcard->tag_D8,  sizeof(currentcard->tag_D8));
 157          returnedlength = sizeof(currentcard->tag_D8);goto exitfunction;}
 158     else if(!memcmp(tag, "\xD9\x00",2)){
 159     memcpy(&returnedtag, currentcard->tag_D9,  currentcard->tag_D9_len);
 160          returnedlength = currentcard->tag_D9_len;goto exitfunction;}
 161     else if(!memcmp(tag, "\xDA\x00",2)){
 162          memcpy(&returnedtag, currentcard->tag_DA,  sizeof(currentcard->tag_DA));
 163          returnedlength = sizeof(currentcard->tag_DA);goto exitfunction;}
 164     else if(!memcmp(tag, "\xDB\x00",2)){
 165          memcpy(&returnedtag, currentcard->tag_DB,  sizeof(currentcard->tag_DB));
 166          returnedlength = sizeof(currentcard->tag_DB);goto exitfunction;}
 167     else if(!memcmp(tag, "\xDC\x00",2)){
 168          memcpy(&returnedtag, currentcard->tag_DC,  sizeof(currentcard->tag_DC));
 169          returnedlength = sizeof(currentcard->tag_DC);goto exitfunction;}
 170     else if(!memcmp(tag, "\xDD\x00",2)){
 171          memcpy(&returnedtag, currentcard->tag_DD,  sizeof(currentcard->tag_DD));
 172          returnedlength = sizeof(currentcard->tag_DD);goto exitfunction;}
 173     else if(!memcmp(tag, "\xA5\x00",2)){
 174    memcpy(&returnedtag, currentcard->tag_A5,  currentcard->tag_A5_len);
 175          returnedlength = currentcard->tag_A5_len; goto exitfunction;}
 176     else if(!memcmp(tag, "\xAF\x00",2)){
 177    memcpy(&returnedtag, currentcard->tag_AF,  currentcard->tag_AF_len);
 178          returnedlength = currentcard->tag_AF_len; goto exitfunction;}
 179     if(*tag == 0x5F){
 180         if(*(tag+1) == 0x20){
 181             memcpy(&returnedtag, currentcard->tag_5F20,  currentcard->tag_5F20_len);
 182              returnedlength = currentcard->tag_5F20_len; goto exitfunction;}
 183         else if(*(tag+1) == 0x24){
 184              memcpy(&returnedtag, currentcard->tag_5F24,  sizeof(currentcard->tag_5F24));
 185              returnedlength = sizeof(currentcard->tag_5F24);goto exitfunction;}
 186         else if(*(tag+1) == 0x25){
 187              memcpy(&returnedtag, currentcard->tag_5F25,  sizeof(currentcard->tag_5F25));
 188              returnedlength = sizeof(currentcard->tag_5F25);goto exitfunction;}
 189         else if(*(tag+1) == 0x28){
 190              memcpy(&returnedtag, currentcard->tag_5F28,  sizeof(currentcard->tag_5F28));
 191              returnedlength = sizeof(currentcard->tag_5F28);goto exitfunction;}
 192         else if(*(tag+1) == 0x2A){
 193              memcpy(&returnedtag, currentcard->tag_5F2A,  sizeof(currentcard->tag_5F2A));
 194              returnedlength = sizeof(currentcard->tag_5F2A);goto exitfunction;}
 195         else if(*(tag+1) == 0x2D){
 196             memcpy(&returnedtag, currentcard->tag_5F2D,  currentcard->tag_5F2D_len);
 197              returnedlength = currentcard->tag_5F2D_len; goto exitfunction;}
 198         else if(*(tag+1) == 0x30){
 199              memcpy(&returnedtag, currentcard->tag_5F30,  sizeof(currentcard->tag_5F30));
 200              returnedlength = sizeof(currentcard->tag_5F30);goto exitfunction;}
 201         else if(*(tag+1) == 0x34){
 202              memcpy(&returnedtag, currentcard->tag_5F34,  sizeof(currentcard->tag_5F34));
 203              returnedlength = sizeof(currentcard->tag_5F34);goto exitfunction;}
 204         else if(*(tag+1) == 0x36){
 205              memcpy(&returnedtag, currentcard->tag_5F36,  sizeof(currentcard->tag_5F36));
 206              returnedlength = sizeof(currentcard->tag_5F36);goto exitfunction;}
 207         else if(*(tag+1) == 0x50){
 208             memcpy(&returnedtag, currentcard->tag_5F50,  currentcard->tag_5F50_len);
 209              returnedlength = currentcard->tag_5F50_len; goto exitfunction;}
 210         else if(*(tag+1) == 0x54){
 211             memcpy(&returnedtag, currentcard->tag_5F54,  currentcard->tag_5F54_len);
 212              returnedlength = currentcard->tag_5F54_len; goto exitfunction;}
 213         }
 214     if(*tag == 0x9F) {
 215         if(*(tag+1) == 0x01){
 216              memcpy(&returnedtag, currentcard->tag_9F01,  sizeof(currentcard->tag_9F01));
 217              returnedlength = sizeof(currentcard->tag_9F01);goto exitfunction;}
 218         else if(*(tag+1) == 0x02){
 219              memcpy(&returnedtag, currentcard->tag_9F02,  sizeof(currentcard->tag_9F02));
 220              returnedlength = sizeof(currentcard->tag_9F02);goto exitfunction;}
 221         else if(*(tag+1) == 0x03){
 222              returnedlength = sizeof(currentcard->tag_9F03);goto exitfunction;}
 223         else if(*(tag+1) == 0x04){
 224              memcpy(&returnedtag, currentcard->tag_9F04,  sizeof(currentcard->tag_9F04));
 225              returnedlength = sizeof(currentcard->tag_9F04);goto exitfunction;}
 226         else if(*(tag+1) == 0x05){
 227        memcpy(&returnedtag, currentcard->tag_9F05,  currentcard->tag_9F05_len);
 228              returnedlength = currentcard->tag_9F05_len; goto exitfunction;}
 229         else if(*(tag+1) == 0x06){
 230        memcpy(&returnedtag, currentcard->tag_9F06,  currentcard->tag_9F06_len);
 231              returnedlength = currentcard->tag_9F06_len; goto exitfunction;}
 232         else if(*(tag+1) == 0x07){
 233              memcpy(&returnedtag, currentcard->tag_9F07,  sizeof(currentcard->tag_9F07));
 234              returnedlength = sizeof(currentcard->tag_9F07);goto exitfunction;}
 235         else if(*(tag+1) == 0x08){
 236              memcpy(&returnedtag, currentcard->tag_9F08,  sizeof(currentcard->tag_9F08));
 237              returnedlength = sizeof(currentcard->tag_9F08);goto exitfunction;}
 238         else if(*(tag+1) == 0x09){
 239              memcpy(&returnedtag, currentcard->tag_9F09,  sizeof(currentcard->tag_9F09));
 240              returnedlength = sizeof(currentcard->tag_9F09);goto exitfunction;}
 241         else if(*(tag+1) == 0x0B){
 242        memcpy(&returnedtag, currentcard->tag_9F0B,  currentcard->tag_9F0B_len);
 243              returnedlength = currentcard->tag_9F0B_len; goto exitfunction;}
 244         else if(*(tag+1) == 0x0D){
 245              memcpy(&returnedtag, currentcard->tag_9F0D,  sizeof(currentcard->tag_9F0D));
 246              returnedlength = sizeof(currentcard->tag_9F0D);goto exitfunction;}
 247         else if(*(tag+1) == 0x0E){
 248              memcpy(&returnedtag, currentcard->tag_9F0E,  sizeof(currentcard->tag_9F0E));
 249              returnedlength = sizeof(currentcard->tag_9F0E);goto exitfunction;}
 250         else if(*(tag+1) == 0x0F){
 251              memcpy(&returnedtag, currentcard->tag_9F0F,  sizeof(currentcard->tag_9F0F));
 252              returnedlength = sizeof(currentcard->tag_9F0F);goto exitfunction;}
 253         else if(*(tag+1) == 0x10){
 254             memcpy(&returnedtag, currentcard->tag_9F10,  currentcard->tag_9F10_len);
 255              returnedlength = currentcard->tag_9F10_len;goto exitfunction;}
 256         else if(*(tag+1) == 0x11){
 257              memcpy(&returnedtag, currentcard->tag_9F11,  sizeof(currentcard->tag_9F11));
 258              returnedlength = sizeof(currentcard->tag_9F11);goto exitfunction;}
 259         else if(*(tag+1) == 0x12){
 260              memcpy(&returnedtag, currentcard->tag_9F12,  currentcard->tag_9F12_len);
 261              returnedlength = currentcard->tag_9F12_len;goto exitfunction;}
 262         else if(*(tag+1) == 0x1A){
 263              memcpy(&returnedtag, currentcard->tag_9F1A,  sizeof(currentcard->tag_9F1A));
 264             goto exitfunction;}
 265         else if(*(tag+1) == 0x1F){
 266        memcpy(&returnedtag, currentcard->tag_9F1F,  currentcard->tag_9F1F_len);
 267              returnedlength = currentcard->tag_9F1F_len; goto exitfunction;}
 268         else if(*(tag+1) == 0x32){
 269        memcpy(&returnedtag, currentcard->tag_9F32,  currentcard->tag_9F32_len);
 270              returnedlength = currentcard->tag_9F32_len; goto exitfunction;}
 271         else if(*(tag+1) == 0x34){
 272        memcpy(&returnedtag, currentcard->tag_9F34,  sizeof(currentcard->tag_9F34));
 273              returnedlength = sizeof(currentcard->tag_9F34); goto exitfunction;}
 274 else if(*(tag+1) == 0x35){
 275        memcpy(&returnedtag, currentcard->tag_9F35,  sizeof(currentcard->tag_9F35));
 276              returnedlength = sizeof(currentcard->tag_9F35); goto exitfunction;}
 277 else if(*(tag+1) == 0x37){
 278              memcpy(&returnedtag, currentcard->tag_9F37,  sizeof(currentcard->tag_9F37));
 279              returnedlength = sizeof(currentcard->tag_9F37);goto exitfunction;}
 280         else if(*(tag+1) == 0x38){
 281        memcpy(&returnedtag, currentcard->tag_9F38,  currentcard->tag_9F38_len);
 282              returnedlength = currentcard->tag_9F38_len; goto exitfunction;}
 283         else if(*(tag+1) == 0x44){
 284              memcpy(&returnedtag, currentcard->tag_9F44,  sizeof(currentcard->tag_9F44));
 285              returnedlength = sizeof(currentcard->tag_9F44);goto exitfunction;}
 286         else if(*(tag+1) == 0x45){
 287              memcpy(&returnedtag, currentcard->tag_9F45,  sizeof(currentcard->tag_9F45));
 288              returnedlength = sizeof(currentcard->tag_9F45);goto exitfunction;}
 289         else if(*(tag+1) == 0x46){
 290             memcpy(&returnedtag, currentcard->tag_9F46,  currentcard->tag_9F46_len);
 291              returnedlength = currentcard->tag_9F46_len; goto exitfunction;}
 292         else if(*(tag+1) == 0x47){
 293        memcpy(&returnedtag, currentcard->tag_9F47,  currentcard->tag_9F47_len);
 294              returnedlength = currentcard->tag_9F47_len; goto exitfunction;}
 295         else if(*(tag+1) == 0x48){
 296        memcpy(&returnedtag, currentcard->tag_9F48,  currentcard->tag_9F48_len);
 297              returnedlength = currentcard->tag_9F48_len; goto exitfunction;}
 298         else if(*(tag+1) == 0x49){
 299        memcpy(&returnedtag, currentcard->tag_9F49,  currentcard->tag_9F49_len);
 300              returnedlength = currentcard->tag_9F49_len; goto exitfunction;}
 301         else if(*(tag+1) == 0x4A){
 302              memcpy(&returnedtag, currentcard->tag_9F4A,  sizeof(currentcard->tag_9F4A));
 303              returnedlength = sizeof(currentcard->tag_9F4A);goto exitfunction;}
 304         else if(*(tag+1) == 0x4B){
 305        memcpy(&returnedtag, currentcard->tag_9F4B,  currentcard->tag_9F4B_len);
 306              returnedlength = currentcard->tag_9F4B_len; goto exitfunction;}
 307         else if(*(tag+1) == 0x4C){
 308              memcpy(&returnedtag, currentcard->tag_9F4C,  sizeof(currentcard->tag_9F4C));
 309              returnedlength = sizeof(currentcard->tag_9F4C); goto exitfunction;}
 310 else if(*(tag+1) == 0x60){
 311              memcpy(&returnedtag, currentcard->tag_9F60,  sizeof(currentcard->tag_9F60));
 312              returnedlength = sizeof(currentcard->tag_9F60);goto exitfunction;}
 313         else if(*(tag+1) == 0x61){
 314              memcpy(&returnedtag, currentcard->tag_9F61,  sizeof(currentcard->tag_9F61));
 315              returnedlength = sizeof(currentcard->tag_9F61);goto exitfunction;}
 316         else if(*(tag+1) == 0x62){
 317              memcpy(&returnedtag, currentcard->tag_9F62,  sizeof(currentcard->tag_9F62));
 318              returnedlength = sizeof(currentcard->tag_9F62);goto exitfunction;}
 319         else if(*(tag+1) == 0x63){
 320              memcpy(&returnedtag, currentcard->tag_9F63,  sizeof(currentcard->tag_9F63));
 321              returnedlength = sizeof(currentcard->tag_9F63);goto exitfunction;}
 322         else if(*(tag+1) == 0x64){
 323              memcpy(&returnedtag, currentcard->tag_9F64,  sizeof(currentcard->tag_9F64));
 324              returnedlength = sizeof(currentcard->tag_9F64);goto exitfunction;}
 325         else if(*(tag+1) == 0x65){
 326              memcpy(&returnedtag, currentcard->tag_9F65,  sizeof(currentcard->tag_9F65));
 327              returnedlength = sizeof(currentcard->tag_9F65);goto exitfunction;}
 328         else if(*(tag+1) == 0x66){
 329             memcpy(&returnedtag, currentcard->tag_9F66,  sizeof(currentcard->tag_9F66));
 330              returnedlength = sizeof(currentcard->tag_9F66);goto exitfunction;}
 331         else if(*(tag+1) == 0x67){
 332              memcpy(&returnedtag, currentcard->tag_9F67,  sizeof(currentcard->tag_9F67));
 333              returnedlength = sizeof(currentcard->tag_9F67);goto exitfunction;}
 334         else if(*(tag+1) == 0x68){
 335         memcpy(&returnedtag, currentcard->tag_9F68,  currentcard->tag_9F68_len);
 336              returnedlength = currentcard->tag_9F68_len;goto exitfunction;}
 337         else if(*(tag+1) == 0x69){
 338        memcpy(&returnedtag, currentcard->tag_9F69,  currentcard->tag_9F69_len);
 339              returnedlength = currentcard->tag_9F69_len; goto exitfunction;}
 340         else if(*(tag+1) == 0x6A){
 341              memcpy(&returnedtag, currentcard->tag_9F6A,  sizeof(currentcard->tag_9F6A));
 342              returnedlength = sizeof(currentcard->tag_9F6A);goto exitfunction;}
 343         else if(*(tag+1) == 0x6B){
 344        memcpy(&returnedtag, currentcard->tag_9F6B,  currentcard->tag_9F6B_len);
 345              returnedlength = currentcard->tag_9F6B_len; goto exitfunction;}
 346         else if(*(tag+1) == 0x6C){
 347              memcpy(&returnedtag, currentcard->tag_9F6C,  sizeof(currentcard->tag_9F6C));
 348              returnedlength = sizeof(currentcard->tag_9F6C);goto exitfunction;}
 349     }
 350     else {
 351         if(!memcmp(tag, "\x61\x00",2)){
 352        memcpy(&returnedtag, currentcard->tag_61,  currentcard->tag_61_len);
 353              returnedlength = currentcard->tag_61_len; goto exitfunction;}
 354         else if(!memcmp(tag, "\x6F\x00",2)){
 355        memcpy(&returnedtag, currentcard->tag_6F,  currentcard->tag_6F_len);
 356              returnedlength = currentcard->tag_6F_len; goto exitfunction;}
 357         else if(!memcmp(tag, "\xAF\x00",2)){
 358        memcpy(&returnedtag, currentcard->tag_AF,  currentcard->tag_AF_len);
 359              returnedlength = currentcard->tag_AF_len; goto exitfunction;}
 360         else if(!memcmp(tag, "\x70\x00",2)){
 361        memcpy(&returnedtag, currentcard->tag_70,  currentcard->tag_70_len);
 362              returnedlength = currentcard->tag_70_len; goto exitfunction;}
 363         else if(!memcmp(tag, "\x77\x00",2)){
 364        memcpy(&returnedtag, currentcard->tag_77,  currentcard->tag_77_len);
 365              returnedlength = currentcard->tag_77_len; goto exitfunction;}
 366         else if(!memcmp(tag, "\x80\x00",2)){
 367        memcpy(&returnedtag, currentcard->tag_80,  currentcard->tag_80_len);
 368              returnedlength = currentcard->tag_80_len; goto exitfunction;}
 369         else if(!memcmp(tag, "\xBF\x0C",2)){
 370        memcpy(&returnedtag, currentcard->tag_BF0C,  currentcard->tag_BF0C_len);
 371              returnedlength = currentcard->tag_BF0C_len; goto exitfunction;}
 372         else if(!memcmp(tag, "\xFF\x01",2)){ //special DF tag
 373        memcpy(&returnedtag, currentcard->tag_DFName,  currentcard->tag_DFName_len);
 374              returnedlength = currentcard->tag_DFName_len; goto exitfunction;}
 375     }
 376 exitfunction:  //goto label to exit search quickly once found
 377     memcpy(outputval, &returnedtag, returnedlength);
 378     *outputvallen = returnedlength;
 379     return 0;
 380 }
 381
 382 //function to
 383 int emv_settag(uint32_t tag, uint8_t *datain, emvtags *currentcard){
 384     char binarydata[255] = {0};
 385     //if((strlen((const char *)datain)%2) != 0){ //must be an even string
 386     //    return -1;
 387     //}
 388     //if(strlen((const char *)datain) > 255) {
 389     //    return -1;
 390     //}
 391     uint8_t datalen = strlen((const char *)datain) / 2; //length of datain
 392     for(int i=0;i<strlen((const char *)datain);i+=2){
 393         binarydata[i/2] |= (char)hex2int(datain[i]) << 4;
 394         binarydata[i/2] |= (char)hex2int(datain[i+1]);
 395     }
 396     Dbprintf("BINARYDATA=");
 397     Dbhexdump(datalen,(uint8_t *)binarydata,false);
 398
 399     switch(tag){
 400         case 0x4F:
 401             memcpy(currentcard->tag_4F, binarydata, datalen);
 402             currentcard->tag_4F_len = datalen;
 403             break;
 404         case 0x50:
 405             memcpy(currentcard->tag_50, binarydata, datalen);
 406             currentcard->tag_50_len = datalen;
 407             break;
 408         case 0x56:
 409             memcpy(currentcard->tag_56, binarydata, datalen);
 410             currentcard->tag_56_len = datalen;
 411             break;
 412         case 0x57:
 413             memcpy(currentcard->tag_57, binarydata, datalen);
 414             currentcard->tag_57_len = datalen;
 415             break;
 416         case 0x5a:
 417             memcpy(currentcard->tag_5A, binarydata, datalen);
 418             currentcard->tag_5A_len = datalen;
 419             break;
 420         case 0x61:
 421             memcpy(currentcard->tag_61, binarydata, datalen);
 422             currentcard->tag_61_len = datalen;
 423             break;
 424         case 0x6f:
 425             memcpy(currentcard->tag_6F, binarydata, datalen);
 426             currentcard->tag_6F_len = datalen;
 427             break;
 428         case 0x70:
 429             memcpy(currentcard->tag_70, binarydata, datalen);
 430             currentcard->tag_70_len = datalen;
 431             break;
 432         case 0x77:
 433             memcpy(currentcard->tag_77, binarydata, datalen);
 434             currentcard->tag_77_len = datalen;
 435             break;
 436         case 0x80:
 437             memcpy(currentcard->tag_80, binarydata, datalen);
 438             currentcard->tag_80_len = datalen;
 439             break;
 440         case 0x82:
 441             memcpy(currentcard->tag_82, binarydata, sizeof(currentcard->tag_82));
 442             break;
 443         case 0x84:
 444             memcpy(currentcard->tag_84, binarydata, datalen);
 445             currentcard->tag_84_len = datalen;
 446             break;
 447         case 0x86:
 448             memcpy(currentcard->tag_86, binarydata, datalen);
 449             currentcard->tag_86_len = datalen;
 450             break;
 451         case 0x87:
 452             memcpy(currentcard->tag_87, binarydata, sizeof(currentcard->tag_87));
 453             break;
 454         case 0x88:
 455             memcpy(currentcard->tag_88, binarydata, sizeof(currentcard->tag_88));
 456             break;
 457         case 0x8a:
 458             memcpy(currentcard->tag_8A, binarydata, sizeof(currentcard->tag_8A));
 459             break;
 460         case 0x8c:
 461             memcpy(currentcard->tag_8C, binarydata, datalen);
 462             currentcard->tag_8C_len = datalen;
 463             break;
 464         case 0x8d:
 465             memcpy(currentcard->tag_8D, binarydata, datalen);
 466             currentcard->tag_8D_len = datalen;
 467             break;
 468         case 0x8e:
 469             memcpy(currentcard->tag_8E, binarydata, datalen);
 470             currentcard->tag_8E_len = datalen;
 471             break;
 472         case 0x8f:
 473             memcpy(currentcard->tag_8F, binarydata, sizeof(currentcard->tag_8F));
 474             break;
 475         case 0x90:
 476             memcpy(currentcard->tag_90, binarydata, datalen);
 477             currentcard->tag_90_len = datalen;
 478             break;
 479         case 0x91:
 480             memcpy(currentcard->tag_91, binarydata, datalen);
 481             currentcard->tag_91_len = datalen;
 482             break;
 483         case 0x92:
 484             memcpy(currentcard->tag_92, binarydata, datalen);
 485             currentcard->tag_92_len = datalen;
 486             break;
 487         case 0x93:
 488             memcpy(currentcard->tag_93, binarydata, datalen);
 489             currentcard->tag_93_len = datalen;
 490             break;
 491         case 0x94:
 492             memcpy(currentcard->tag_94, binarydata, datalen);
 493             currentcard->tag_94_len = datalen;
 494             break;
 495         case 0x95:
 496             memcpy(currentcard->tag_95, binarydata, sizeof(currentcard->tag_95));
 497             break;
 498         case 0x97:
 499             memcpy(currentcard->tag_97, binarydata, datalen);
 500             currentcard->tag_97_len = datalen;
 501             break;
 502         case 0x98:
 503             memcpy(currentcard->tag_98, binarydata, sizeof(currentcard->tag_98));
 504             break;
 505         case 0x99:
 506             memcpy(currentcard->tag_99, binarydata, datalen);
 507             currentcard->tag_99_len = datalen;
 508             break;
 509         case 0x9a:
 510             memcpy(currentcard->tag_9A, binarydata, sizeof(currentcard->tag_9A));
 511             break;
 512         case 0x9b:
 513             memcpy(currentcard->tag_9B, binarydata, sizeof(currentcard->tag_9B));
 514             break;
 515         case 0x9c:
 516             memcpy(currentcard->tag_9C, binarydata, sizeof(currentcard->tag_9C));
 517             break;
 518         case 0x9d:
 519             memcpy(currentcard->tag_9D, binarydata, datalen);
 520             currentcard->tag_9D_len = datalen;
 521             break;
 522         case 0xa5:
 523             memcpy(currentcard->tag_A5, binarydata, datalen);
 524             currentcard->tag_A5_len = datalen;
 525             break;
 526         case 0xaf:
 527             memcpy(currentcard->tag_AF, binarydata, datalen);
 528             currentcard->tag_AF_len = datalen;
 529             break;
 530         case 0xcd:
 531             memcpy(currentcard->tag_CD, binarydata, sizeof(currentcard->tag_CD));
 532             break;
 533         case 0xce:
 534             memcpy(currentcard->tag_CE, binarydata, sizeof(currentcard->tag_CE));
 535             break;
 536         case 0xcf:
 537             memcpy(currentcard->tag_CF, binarydata, sizeof(currentcard->tag_CF));
 538             break;
 539         case 0xd7:
 540             memcpy(currentcard->tag_CF, binarydata, sizeof(currentcard->tag_CF));
 541             break;
 542         case 0xd8:
 543             memcpy(currentcard->tag_CF, binarydata, sizeof(currentcard->tag_CF));
 544             break;
 545         case 0xd9:
 546             break;
 547         case 0xda:
 548             memcpy(currentcard->tag_DA, binarydata, sizeof(currentcard->tag_DA));
 549             break;
 550         case 0xdb:
 551             memcpy(currentcard->tag_DB, binarydata, sizeof(currentcard->tag_DB));
 552             break;
 553         case 0xdc:
 554             memcpy(currentcard->tag_DB, binarydata, sizeof(currentcard->tag_DB));
 555             break;
 556         case 0xdd:
 557             memcpy(currentcard->tag_DD, binarydata, sizeof(currentcard->tag_DD));
 558             break;
 559         case 0x5f20:
 560             break;
 561         case 0x5f24:
 562             memcpy(currentcard->tag_5F24, binarydata, sizeof(currentcard->tag_5F24));
 563             break;
 564         case 0x5f25:
 565             memcpy(currentcard->tag_5F25, binarydata, sizeof(currentcard->tag_5F25));
 566             break;
 567         case 0x5f28:
 568             memcpy(currentcard->tag_5F28, binarydata, sizeof(currentcard->tag_5F28));
 569             break;
 570         case 0x5f2a:
 571             memcpy(currentcard->tag_5F2A, binarydata, sizeof(currentcard->tag_5F2A));
 572             break;
 573         case 0x5f2d:
 574             break;
 575         case 0x5f30:
 576             memcpy(currentcard->tag_5F30, binarydata, sizeof(currentcard->tag_5F30));
 577             break;
 578         case 0x5f34:
 579             memcpy(currentcard->tag_5F34, binarydata, sizeof(currentcard->tag_5F34));
 580             break;
 581         case 0x5f36:
 582             memcpy(currentcard->tag_5F36, binarydata, sizeof(currentcard->tag_5F36));
 583             break;
 584         case 0x5f50:
 585             break;
 586         case 0x5f54:
 587             memcpy(currentcard->tag_5F54, binarydata, sizeof(currentcard->tag_5F54));
 588             break;
 589         case 0x9f01:
 590             memcpy(currentcard->tag_9F01, binarydata, sizeof(currentcard->tag_9F01));
 591             break;
 592         case 0x9f02:
 593             memcpy(currentcard->tag_9F02, binarydata, sizeof(currentcard->tag_9F02));
 594             break;
 595         case 0x9f03:
 596             memcpy(currentcard->tag_9F03, binarydata, sizeof(currentcard->tag_9F03));
 597             break;
 598         case 0x9f04:
 599             memcpy(currentcard->tag_9F04, binarydata, sizeof(currentcard->tag_9F04));
 600             break;
 601         case 0x9f05:
 602             memcpy(currentcard->tag_9F05, binarydata, datalen);
 603             currentcard->tag_9F05_len = datalen;
 604             break;
 605         case 0x9f06:
 606             memcpy(currentcard->tag_9F06, binarydata, datalen);
 607             currentcard->tag_9F06_len = datalen;
 608             break;
 609         case 0x9f07:
 610             memcpy(currentcard->tag_9F07, binarydata, sizeof(currentcard->tag_9F07));
 611             break;
 612         case 0x9f08:
 613             memcpy(currentcard->tag_9F08, binarydata, sizeof(currentcard->tag_9F08));
 614             break;
 615         case 0x9f09:
 616             memcpy(currentcard->tag_9F09, binarydata, sizeof(currentcard->tag_9F09));
 617             break;
 618         case 0x9f0b:
 619             memcpy(currentcard->tag_9F0B, binarydata, sizeof(currentcard->tag_9F0B));
 620             break;
 621         case 0x9f0d:
 622             memcpy(currentcard->tag_9F0D, binarydata, sizeof(currentcard->tag_9F0D));
 623             break;
 624         case 0x9f0e:
 625             memcpy(currentcard->tag_9F0E, binarydata, sizeof(currentcard->tag_9F0E));
 626             break;
 627         case 0x9f0f:
 628             memcpy(currentcard->tag_9F0F, binarydata, sizeof(currentcard->tag_9F0F));
 629             break;
 630         case 0x9f10:
 631             memcpy(currentcard->tag_9F10, binarydata, datalen);
 632             currentcard->tag_9F10_len = datalen;break;
 633         case 0x9f11:
 634             memcpy(currentcard->tag_9F11, binarydata, sizeof(currentcard->tag_9F11));
 635             break;
 636         case 0x9f12:
 637             memcpy(currentcard->tag_9F12, binarydata, datalen);
 638             currentcard->tag_9F12_len = datalen;break;
 639         case 0x9f13:
 640             memcpy(currentcard->tag_9F13, binarydata, sizeof(currentcard->tag_9F13));
 641             break;
 642         case 0x9f14:
 643             memcpy(currentcard->tag_9F14, binarydata, sizeof(currentcard->tag_9F14));
 644             break;
 645         case 0x9f15:
 646             memcpy(currentcard->tag_9F15, binarydata, sizeof(currentcard->tag_9F15));
 647             break;
 648         case 0x9f16:
 649             memcpy(currentcard->tag_9F16, binarydata, sizeof(currentcard->tag_9F16));
 650             break;
 651         case 0x9f17:
 652             memcpy(currentcard->tag_9F17, binarydata, sizeof(currentcard->tag_9F17));
 653             break;
 654         case 0x9f18:
 655             memcpy(currentcard->tag_9F18, binarydata, sizeof(currentcard->tag_9F18));
 656             break;
 657         case 0x9f1a:
 658             memcpy(currentcard->tag_9F1A, binarydata, sizeof(currentcard->tag_9F1A));
 659             break;
 660         case 0x9f1b:
 661             memcpy(currentcard->tag_9F1B, binarydata, sizeof(currentcard->tag_9F1B));
 662             break;
 663         case 0x9f1c:
 664             memcpy(currentcard->tag_9F1C, binarydata, sizeof(currentcard->tag_9F1C));
 665             break;
 666         case 0x9f1d:
 667             memcpy(currentcard->tag_9F1D, binarydata, datalen);
 668             currentcard->tag_9F1D_len = datalen;break;
 669         case 0x9f1e:
 670             memcpy(currentcard->tag_9F1E, binarydata, sizeof(currentcard->tag_9F1E));
 671             break;
 672         case 0x9f1f:
 673             memcpy(currentcard->tag_9F1F, binarydata, datalen);
 674             currentcard->tag_9F1F_len = datalen;break;
 675         case 0x9f20:
 676             memcpy(currentcard->tag_9F20, binarydata, datalen);
 677             currentcard->tag_9F20_len = datalen;break;
 678         case 0x9f21:
 679             memcpy(currentcard->tag_9F21, binarydata, sizeof(currentcard->tag_9F21));
 680             break;
 681         case 0x9f22:
 682             memcpy(currentcard->tag_9F22, binarydata, sizeof(currentcard->tag_9F22));
 683             break;
 684         case 0x9f23:
 685             memcpy(currentcard->tag_9F23, binarydata, sizeof(currentcard->tag_9F23));
 686             break;
 687         case 0x9f26:
 688             memcpy(currentcard->tag_9F26, binarydata, sizeof(currentcard->tag_9F26));
 689             break;
 690         case 0x9f27:
 691             memcpy(currentcard->tag_9F27, binarydata, sizeof(currentcard->tag_9F27));
 692             break;
 693         case 0x9f2d:
 694             memcpy(currentcard->tag_9F2D, binarydata, datalen);
 695             currentcard->tag_9F2D_len = datalen;break;
 696         case 0x9f2e:
 697             memcpy(currentcard->tag_9F2E, binarydata, sizeof(currentcard->tag_9F2E));
 698             break;
 699         case 0x9f2f:
 700             memcpy(currentcard->tag_9F2F, binarydata, datalen);
 701             currentcard->tag_9F2F_len = datalen;break;
 702         case 0x9f32:
 703             memcpy(currentcard->tag_9F32, binarydata, datalen);
 704             currentcard->tag_9F32_len = datalen;break;
 705         case 0x9f33:
 706             memcpy(currentcard->tag_9F33, binarydata, sizeof(currentcard->tag_9F33));
 707             break;
 708         case 0x9f34:
 709             memcpy(currentcard->tag_9F34, binarydata, sizeof(currentcard->tag_9F34));
 710             break;
 711         case 0x9f35:
 712             memcpy(currentcard->tag_9F35, binarydata, sizeof(currentcard->tag_9F35));
 713             break;
 714         case 0x9f36:
 715             memcpy(currentcard->tag_9F36, binarydata, sizeof(currentcard->tag_9F36));
 716             break;
 717         case 0x9f37:
 718             memcpy(currentcard->tag_9F37, binarydata, sizeof(currentcard->tag_9F37));
 719             break;
 720         case 0x9f38:
 721             break;
 722         case 0x9f39:
 723             memcpy(currentcard->tag_9F39, binarydata, sizeof(currentcard->tag_9F39));
 724             break;
 725         case 0x9f40:
 726             memcpy(currentcard->tag_9F40, binarydata, sizeof(currentcard->tag_9F40));
 727             break;
 728         case 0x9f41:
 729             memcpy(currentcard->tag_9F41, binarydata, sizeof(currentcard->tag_9F41));
 730             break;
 731         case 0x9f42:
 732             memcpy(currentcard->tag_9F42, binarydata, sizeof(currentcard->tag_9F42));
 733             break;
 734         case 0x9f43:
 735             memcpy(currentcard->tag_9F43, binarydata, sizeof(currentcard->tag_9F43));
 736             break;
 737         case 0x9f44:
 738             memcpy(currentcard->tag_9F44, binarydata, sizeof(currentcard->tag_9F44));
 739             break;
 740         case 0x9f45:
 741             memcpy(currentcard->tag_9F45, binarydata, sizeof(currentcard->tag_9F45));
 742             break;
 743         case 0x9f46:
 744             memcpy(currentcard->tag_9F46, binarydata, datalen);
 745             currentcard->tag_9F46_len = datalen;break;
 746         case 0x9f47:
 747             memcpy(currentcard->tag_9F47, binarydata, datalen);
 748             currentcard->tag_9F47_len = datalen;break;
 749         case 0x9f48:
 750             memcpy(currentcard->tag_9F48, binarydata, datalen);
 751             currentcard->tag_9F48_len = datalen;break;
 752         case 0x9f49:
 753             memcpy(currentcard->tag_9F49, binarydata, datalen);
 754             currentcard->tag_9F49_len = datalen;break;
 755         case 0x9f4a:
 756             memcpy(currentcard->tag_9F4A, binarydata, sizeof(currentcard->tag_9F4A));
 757             break;
 758         case 0x9f4b:
 759             memcpy(currentcard->tag_9F4B, binarydata, datalen);
 760             currentcard->tag_9F4B_len = datalen;break;
 761         case 0x9f4c:
 762             memcpy(currentcard->tag_9F4C, binarydata, sizeof(currentcard->tag_9F4C));
 763             break;
 764         case 0x9f4d:
 765             memcpy(currentcard->tag_9F4D, binarydata, sizeof(currentcard->tag_9F4D));
 766             break;
 767         case 0x9f4e:
 768             memcpy(currentcard->tag_9F4E, binarydata, sizeof(currentcard->tag_9F4E));
 769             break;
 770         case 0x9f60:
 771             memcpy(currentcard->tag_9F60, binarydata, sizeof(currentcard->tag_9F60));
 772             break;
 773         case 0x9f61:
 774             memcpy(currentcard->tag_9F61, binarydata, sizeof(currentcard->tag_9F61));
 775             break;
 776         case 0x9f62:
 777             memcpy(currentcard->tag_9F62, binarydata, sizeof(currentcard->tag_9F62));
 778             break;
 779         case 0x9f63:
 780             memcpy(currentcard->tag_9F63, binarydata, sizeof(currentcard->tag_9F63));
 781             break;
 782         case 0x9f64:
 783             memcpy(currentcard->tag_9F64, binarydata, sizeof(currentcard->tag_9F64));
 784             break;
 785         case 0x9f65:
 786             memcpy(currentcard->tag_9F65, binarydata, sizeof(currentcard->tag_9F65));
 787             break;
 788         case 0x9f66:
 789             memcpy(currentcard->tag_9F66, binarydata, sizeof(currentcard->tag_9F66));
 790             break;
 791         case 0x9f67:
 792             memcpy(currentcard->tag_9F67, binarydata, sizeof(currentcard->tag_9F67));
 793             break;
 794         case 0x9f68:
 795             memcpy(currentcard->tag_9F68, binarydata, datalen);
 796             currentcard->tag_9F68_len = datalen;break;
 797         case 0x9f69:
 798             memcpy(currentcard->tag_9F69, binarydata, datalen);
 799             currentcard->tag_9F69_len = datalen;break;
 800         case 0x9f6a:
 801             memcpy(currentcard->tag_9F6A, binarydata, sizeof(currentcard->tag_9F6A));
 802             break;
 803         case 0x9f6b:
 804             memcpy(currentcard->tag_9F6B, binarydata, sizeof(currentcard->tag_9F6B));
 805             break;
 806         case 0x9f6c:
 807             memcpy(currentcard->tag_9F6C, binarydata, sizeof(currentcard->tag_9F6C));
 808             break;
 809         case 0xbf0c:
 810             memcpy(currentcard->tag_BF0C, binarydata, datalen);
 811             currentcard->tag_BF0C_len = datalen;break;
 812         default:
 813             break;
 814         }
 815     return 0;
 816 }
 817
 818 /* generates an emv template based off tag values supplied */
 819 int emv_generatetemplate(uint8_t* templateval,emvtags* currentcard, uint8_t* returnedval, uint8_t* returnedlen,uint8_t numtags, ...)
 820 {
 821     va_list arguments;
 822     uint8_t* currenttag; //value of the current tag
 823     uint8_t tagval[255]; //buffer to hold the extracted tag value
 824     uint8_t taglen = 0; //extracted tag length
 825     uint8_t bufferval[255];
 826     uint8_t counter = 0;
 827     uint32_t encodedlen = 0;
 828     va_start(arguments, numtags);
 829     for(int x=0; x<numtags; x++){
 830         currenttag = va_arg(arguments, uint8_t*);
 831         emv_lookuptag(currenttag, currentcard, tagval, &taglen);
 832         encode_ber_tlv_item(currenttag, (uint8_t)strlen((const char*)currenttag), tagval, (uint32_t)taglen, bufferval+counter, &encodedlen);
 833         counter +=encodedlen;
 834     }
 835     encode_ber_tlv_item(templateval, strlen((const char*) templateval), bufferval, counter, returnedval, &encodedlen);
 836     *returnedlen = encodedlen;
 837     return 0;
 838 }
 839
 840 //generate a valid pdol list
 841 int emv_generateDOL(uint8_t* DOL, uint8_t DOLlen,emvtags* currentcard,uint8_t* DOLoutput, uint8_t* DOLoutputlen)
 842 {
 843     if(!DOL || !currentcard || !DOLoutput) // null pointer checks
 844         return 1;
 845     //scan through the DOL list and construct the result.
 846     uint8_t i = 0;
 847     uint8_t DOLcounter = 0; //points to the current DOL buffer location
 848     uint8_t scannedtaglen = 0; //length of a scanned tag
 849     uint8_t scannedtag[2] = {0x00,0x00}; //buffer for the scanned tag
 850     uint8_t DOLoutputbuffer[255];
 851     uint8_t retrievedtagvallen;
 852
 853     memset(DOLoutputbuffer,0x00, 255); //clear the output buffer
 854     while(i < DOLlen)
 855     {
 856         //length of DOL tag
 857         if((*(DOL+i) & 0x1F) == 0x1F)
 858             { scannedtaglen = 2;}
 859         else
 860             {scannedtaglen=1;}
 861         memcpy(scannedtag, DOL+i,scannedtaglen);
 862         //look up tag value and copy
 863         //Dbhexdump(2,scannedtag,false);
 864         emv_lookuptag(scannedtag,currentcard,&(DOLoutputbuffer[DOLcounter]),&retrievedtagvallen);
 865         DOLcounter += (uint8_t)DOL[i+scannedtaglen];
 866         i += scannedtaglen + 1;
 867         memset(scannedtag, 0x00, 2); //clear current tag
 868
 869     }
 870     memcpy(DOLoutput, DOLoutputbuffer, DOLcounter);
 871     *DOLoutputlen = DOLcounter;
 872     return 0;
 873 }
 874
 875
 876 //decode the tag inputted and fill in the supplied structure. clean up the cleanup_passpass function
 877 int emv_emvtags_decode_tag(tlvtag* inputtag, emvtags* currentcard)
 878 {
 879     if(!inputtag || !currentcard) {
 880         return 1;
 881     }
 882     //scan decoded tag
 883     if(*(inputtag->tag) == 0x5F) {
 884         if(*(inputtag->tag+1) == 0x20){
 885             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F20)))
 886             return 1;
 887             memcpy(currentcard->tag_5F20, inputtag->value, inputtag->valuelength);
 888             currentcard->tag_5F20_len = inputtag->valuelength;
 889         }
 890         if(*(inputtag->tag+1) == 0x24){
 891             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F24)))
 892                 return 1;
 893             memcpy(currentcard->tag_5F24, inputtag->value, sizeof(currentcard->tag_5F24));}
 894         if(*(inputtag->tag+1) == 0x25){
 895             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F25)))
 896                 return 1;
 897             memcpy(currentcard->tag_5F25, inputtag->value, inputtag->valuelength);}
 898         if(*(inputtag->tag+1) == 0x28){
 899             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F28)))
 900                 return 1;
 901             memcpy(currentcard->tag_5F28, inputtag->value, inputtag->valuelength);}
 902         if(*(inputtag->tag+1) == 0x2A){
 903             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F2A)))
 904                 return 1;
 905             memcpy(currentcard->tag_5F2A, inputtag->value, inputtag->valuelength);}
 906         if(*(inputtag->tag+1) == 0x2D){
 907             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F2D)))
 908                 return 1;
 909             memcpy(currentcard->tag_5F2D, inputtag->value, inputtag->valuelength);
 910             currentcard->tag_5F2D_len = inputtag->valuelength;}
 911         if(*(inputtag->tag+1) == 0x30){
 912             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F30)))
 913                 return 1;
 914             memcpy(currentcard->tag_5F30, inputtag->value, inputtag->valuelength);}
 915         if(*(inputtag->tag+1) == 0x34){
 916             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F34)))
 917                 return 1;
 918             memcpy(currentcard->tag_5F34, inputtag->value, sizeof(currentcard->tag_5F34));}
 919         if(*(inputtag->tag+1) == 0x36){
 920             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F36)))
 921                 return 1;
 922             memcpy(currentcard->tag_5F36, inputtag->value, sizeof(currentcard->tag_5F36));}
 923         if(*(inputtag->tag+1) == 0x50){
 924             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F50)))
 925                 return 1;
 926             memcpy(currentcard->tag_5F50, inputtag->value, inputtag->valuelength);
 927             currentcard->tag_5F50_len = inputtag->valuelength;}
 928         if(*(inputtag->tag+1) == 0x54){
 929             if(!(inputtag->valuelength <= sizeof(currentcard->tag_5F54)))
 930                 return 1;
 931             memcpy(currentcard->tag_5F54, inputtag->value, inputtag->valuelength);
 932             currentcard->tag_5F54_len = inputtag->valuelength;}
 933     }
 934     if(*(inputtag->tag) == 0x9F){
 935         if(*(inputtag->tag+1) == 0x01){
 936         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F01)))
 937             return 1;
 938         memcpy(currentcard->tag_9F01, inputtag->value, inputtag->valuelength);}
 939         if(*(inputtag->tag+1) == 0x02){
 940         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F02)))
 941             return 1;
 942         memcpy(currentcard->tag_9F02, inputtag->value, inputtag->valuelength);}
 943         if(*(inputtag->tag+1) == 0x03){
 944         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F03)))
 945             return 1;
 946         memcpy(currentcard->tag_9F03, inputtag->value, inputtag->valuelength);}
 947         if(*(inputtag->tag+1) == 0x04){
 948         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F04)))
 949             return 1;
 950         memcpy(currentcard->tag_9F04, inputtag->value, inputtag->valuelength);}
 951         if(*(inputtag->tag+1) == 0x05){
 952         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F05)))
 953             return 1;
 954         memcpy(currentcard->tag_9F05, inputtag->value, inputtag->valuelength);
 955         currentcard->tag_9F05_len = inputtag->valuelength;}
 956         if(*(inputtag->tag+1) == 0x06){
 957         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F06)))
 958             return 1;
 959         memcpy(currentcard->tag_9F06, inputtag->value, inputtag->valuelength);
 960         currentcard->tag_9F06_len = inputtag->valuelength;}
 961         if(*(inputtag->tag+1) == 0x07){
 962         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F07)))
 963             return 1;
 964         memcpy(currentcard->tag_9F07, inputtag->value, inputtag->valuelength);}
 965         if(*(inputtag->tag+1) == 0x08){
 966         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F08)))
 967             return 1;
 968         memcpy(currentcard->tag_9F08, inputtag->value, inputtag->valuelength);}
 969         if(*(inputtag->tag+1) == 0x09){
 970         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F09)))
 971             return 1;
 972         memcpy(currentcard->tag_9F09, inputtag->value, inputtag->valuelength);}
 973         if(*(inputtag->tag+1) == 0x0B){
 974         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F0B)))
 975             return 1;
 976         memcpy(currentcard->tag_9F0B, inputtag->value, inputtag->valuelength);
 977         currentcard->tag_9F0B_len = inputtag->valuelength;}
 978         if(*(inputtag->tag+1) == 0x0D){
 979         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F0D)))
 980             return 1;
 981         memcpy(currentcard->tag_9F0D, inputtag->value, inputtag->valuelength);}
 982         if(*(inputtag->tag+1) == 0x0E){
 983         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F0E)))
 984             return 1;
 985         memcpy(currentcard->tag_9F0E, inputtag->value, inputtag->valuelength);}
 986         if(*(inputtag->tag+1) == 0x0F){
 987         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F0F)))
 988             return 1;
 989         memcpy(currentcard->tag_9F0F, inputtag->value, inputtag->valuelength);}
 990         if(*(inputtag->tag+1) == 0x11){
 991             if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F11)))
 992                 return 1;
 993             memcpy(currentcard->tag_9F11, inputtag->value, inputtag->valuelength);}
 994         if(*(inputtag->tag+1) == 0x12){
 995             if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F12)))
 996                 return 1;
 997             memcpy(currentcard->tag_9F12, inputtag->value, inputtag->valuelength);
 998             currentcard->tag_9F12_len = inputtag->valuelength;}
 999         if(*(inputtag->tag+1) == 0x13){
1000         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F13)))
1001             return 1;
1002         memcpy(currentcard->tag_9F13, inputtag->value, inputtag->valuelength);}
1003         if(*(inputtag->tag+1) == 0x14){
1004         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F14)))
1005             return 1;
1006         memcpy(currentcard->tag_9F14, inputtag->value, inputtag->valuelength);}
1007         if(*(inputtag->tag+1) == 0x15){
1008         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F15)))
1009             return 1;
1010         memcpy(currentcard->tag_9F15, inputtag->value, inputtag->valuelength);}
1011         if(*(inputtag->tag+1) == 0x16){
1012         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F16)))
1013             return 1;
1014         memcpy(currentcard->tag_9F16, inputtag->value, inputtag->valuelength);}
1015         if(*(inputtag->tag+1) == 0x17){
1016         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F17)))
1017             return 1;
1018         memcpy(currentcard->tag_9F17, inputtag->value, inputtag->valuelength);}
1019         if(*(inputtag->tag+1) == 0x18){
1020         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F18)))
1021             return 1;
1022         memcpy(currentcard->tag_9F18, inputtag->value, inputtag->valuelength);}
1023         if(*(inputtag->tag+1) == 0x1A){
1024         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1A)))
1025             return 1;
1026         memcpy(currentcard->tag_9F1A, inputtag->value, inputtag->valuelength);}
1027         if(*(inputtag->tag+1) == 0x1B){
1028         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1B)))
1029             return 1;
1030         memcpy(currentcard->tag_9F1B, inputtag->value, inputtag->valuelength);}
1031         if(*(inputtag->tag+1) == 0x1C){
1032         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1C)))
1033             return 1;
1034         memcpy(currentcard->tag_9F1C, inputtag->value, inputtag->valuelength);}
1035         if(*(inputtag->tag+1) == 0x1D){
1036         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1D)))
1037             return 1;
1038         memcpy(currentcard->tag_9F1D, inputtag->value, inputtag->valuelength);
1039         currentcard->tag_9F1D_len = inputtag->valuelength;}
1040         if(*(inputtag->tag+1) == 0x1E){
1041         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1E)))
1042             return 1;
1043         memcpy(currentcard->tag_9F1E, inputtag->value, inputtag->valuelength);}
1044         if(*(inputtag->tag+1) == 0x1F){
1045         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F1F)))
1046             return 1;
1047         memcpy(currentcard->tag_9F1F, inputtag->value, inputtag->valuelength);
1048         currentcard->tag_9F1F_len = inputtag->valuelength;}
1049         if(*(inputtag->tag+1) == 0x32){
1050             if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F32)))
1051                 return 1;
1052             currentcard->tag_9F32_len = inputtag->valuelength;
1053             memcpy(currentcard->tag_9F32, inputtag->value, inputtag->valuelength);
1054         }
1055         if(*(inputtag->tag+1) == 0x34){
1056         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F34)))
1057             return 1;
1058         memcpy(currentcard->tag_9F34, inputtag->value, inputtag->valuelength);}
1059 if(*(inputtag->tag+1) == 0x35){
1060         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F35)))
1061             return 1;
1062         memcpy(currentcard->tag_9F35, inputtag->value, inputtag->valuelength);}
1063 if(*(inputtag->tag+1) == 0x37){
1064         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F37)))
1065             return 1;
1066         memcpy(currentcard->tag_9F37, inputtag->value, inputtag->valuelength);}
1067         if(*(inputtag->tag+1) == 0x38){
1068         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F38)))
1069             return 1;
1070         memcpy(currentcard->tag_9F38, inputtag->value, inputtag->valuelength);
1071         currentcard->tag_9F38_len = inputtag->valuelength;}
1072         if(*(inputtag->tag+1) == 0x44){
1073         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F44)))
1074             return 1;
1075         memcpy(currentcard->tag_9F44, inputtag->value, inputtag->valuelength);}
1076         if(*(inputtag->tag+1) == 0x45){
1077         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F45)))
1078             return 1;
1079         memcpy(currentcard->tag_9F45, inputtag->value, inputtag->valuelength);}
1080 if(*(inputtag->tag+1) == 0x46){
1081         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F46)))
1082             return 1;
1083         memcpy(currentcard->tag_9F46, inputtag->value, inputtag->valuelength);
1084         currentcard->tag_9F46_len = inputtag->valuelength;}
1085         if(*(inputtag->tag+1) == 0x47){
1086         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F47)))
1087             return 1;
1088         memcpy(currentcard->tag_9F47, inputtag->value, inputtag->valuelength);
1089         currentcard->tag_9F47_len = inputtag->valuelength;}
1090         if(*(inputtag->tag+1) == 0x48){
1091         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F48)))
1092             return 1;
1093         memcpy(currentcard->tag_9F48, inputtag->value, inputtag->valuelength);
1094         currentcard->tag_9F48_len = inputtag->valuelength;}
1095         if(*(inputtag->tag+1) == 0x49){
1096         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F49)))
1097             return 1;
1098         memcpy(currentcard->tag_9F49, inputtag->value, inputtag->valuelength);
1099         currentcard->tag_9F49_len = inputtag->valuelength;}
1100         if(*(inputtag->tag+1) == 0x4A){
1101         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F4A)))
1102             return 1;
1103         memcpy(currentcard->tag_9F4A, inputtag->value, inputtag->valuelength);}
1104         if(*(inputtag->tag+1) == 0x4B){
1105         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F4B)))
1106             return 1;
1107         memcpy(currentcard->tag_9F4B, inputtag->value, inputtag->valuelength);
1108         currentcard->tag_9F4B_len = inputtag->valuelength;}
1109         if(*(inputtag->tag+1) == 0x4C){
1110         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F4C)))
1111             return 1;
1112         memcpy(currentcard->tag_9F4C, inputtag->value, inputtag->valuelength);}
1113 if(*(inputtag->tag+1) == 0x60){
1114         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F60)))
1115             return 1;
1116         memcpy(currentcard->tag_9F60, inputtag->value, inputtag->valuelength);}
1117         if(*(inputtag->tag+1) == 0x61){
1118         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F61)))
1119             return 1;
1120         memcpy(currentcard->tag_9F61, inputtag->value, inputtag->valuelength);}
1121         if(*(inputtag->tag+1) == 0x62){
1122         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F62)))
1123             return 1;
1124         memcpy(currentcard->tag_9F62, inputtag->value, inputtag->valuelength);}
1125         if(*(inputtag->tag+1) == 0x63){
1126         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F63)))
1127             return 1;
1128         memcpy(currentcard->tag_9F63, inputtag->value, inputtag->valuelength);}
1129         if(*(inputtag->tag+1) == 0x64){
1130         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F64)))
1131             return 1;
1132         memcpy(currentcard->tag_9F64, inputtag->value, inputtag->valuelength);}
1133         if(*(inputtag->tag+1) == 0x65){
1134         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F65)))
1135             return 1;
1136         memcpy(currentcard->tag_9F65, inputtag->value, inputtag->valuelength);}
1137         if(*(inputtag->tag+1) == 0x66){
1138         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F66)))
1139             return 1;
1140         memcpy(currentcard->tag_9F66, inputtag->value, inputtag->valuelength);}
1141         if(*(inputtag->tag+1) == 0x67){
1142         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F67)))
1143             return 1;
1144         memcpy(currentcard->tag_9F67, inputtag->value, inputtag->valuelength);}
1145         if(*(inputtag->tag+1) == 0x68){
1146         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F68)))
1147             return 1;
1148         memcpy(currentcard->tag_9F68, inputtag->value, inputtag->valuelength);
1149         currentcard->tag_9F68_len = inputtag->valuelength;}
1150         if(*(inputtag->tag+1) == 0x69){
1151         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F69)))
1152             return 1;
1153         memcpy(currentcard->tag_9F69, inputtag->value, inputtag->valuelength);
1154         currentcard->tag_9F69_len = inputtag->valuelength;}
1155         if(*(inputtag->tag+1) == 0x6A){
1156         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F6A)))
1157             return 1;
1158         memcpy(currentcard->tag_9F6A, inputtag->value, inputtag->valuelength);}
1159         if(*(inputtag->tag+1) == 0x6B){
1160         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F6B)))
1161             return 1;
1162         memcpy(currentcard->tag_9F6B, inputtag->value, inputtag->valuelength);
1163         currentcard->tag_9F6B_len = inputtag->valuelength;}
1164         if(*(inputtag->tag+1) == 0x6C){
1165         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9F6C)))
1166             return 1;
1167         memcpy(currentcard->tag_9F6C, inputtag->value, inputtag->valuelength);}
1168 }
1169 else
1170 {
1171     if(*(inputtag->tag) == 0xBF){ //BF0C
1172         if(*(inputtag->tag+1) == 0x0C){
1173             if(!(inputtag->valuelength <= sizeof(currentcard->tag_BF0C)))
1174                 return 1;
1175             memcpy(currentcard->tag_BF0C, inputtag->value, inputtag->valuelength);
1176             currentcard->tag_BF0C_len = inputtag->valuelength;}
1177     }
1178     else if(*(inputtag->tag) == 0x4F){ //BF0C
1179         if(!(inputtag->valuelength <= sizeof(currentcard->tag_4F)))
1180             return 1;
1181         memcpy(currentcard->tag_4F, inputtag->value, inputtag->valuelength);
1182         currentcard->tag_4F_len = inputtag->valuelength;}
1183     else if(*(inputtag->tag) == 0x50){ //BF0C
1184         if(!(inputtag->valuelength <= sizeof(currentcard->tag_50)))
1185             return 1;
1186         memcpy(currentcard->tag_50, inputtag->value, inputtag->valuelength);
1187         currentcard->tag_50_len = inputtag->valuelength;
1188     }
1189     else if(*(inputtag->tag) == 0x56){ //BF0C
1190         if(!(inputtag->valuelength <= sizeof(currentcard->tag_56)))
1191             return 1;
1192         memcpy(currentcard->tag_56, inputtag->value, inputtag->valuelength);
1193         currentcard->tag_56_len = inputtag->valuelength;
1194     }
1195     else if(*(inputtag->tag) == 0x57){ //BF0C
1196         if(!(inputtag->valuelength <= sizeof(currentcard->tag_57)))
1197             return 1;
1198         memcpy(currentcard->tag_57, inputtag->value, inputtag->valuelength);
1199         currentcard->tag_57_len = inputtag->valuelength;
1200     }
1201     else if(*(inputtag->tag) == 0x5A){ //BF0C
1202         if(!(inputtag->valuelength <= sizeof(currentcard->tag_5A)))
1203             return 1;
1204         memcpy(currentcard->tag_5A, inputtag->value, inputtag->valuelength);
1205         currentcard->tag_5A_len = inputtag->valuelength;}
1206     else if(*(inputtag->tag) == 0x61){ //BF0C
1207         if(!(inputtag->valuelength <= sizeof(currentcard->tag_61)))
1208             return 1;
1209         memcpy(currentcard->tag_61, inputtag->value, inputtag->valuelength);
1210         currentcard->tag_61_len = inputtag->valuelength;
1211     }
1212     else if(*(inputtag->tag) == 0x6F){ //BF0C
1213         memcpy(currentcard->tag_6F,inputtag->value,inputtag->valuelength);}
1214
1215     else if(*(inputtag->tag) == 0x70){ //BF0C
1216         memcpy(currentcard->tag_70,inputtag->value,inputtag->valuelength);}
1217     else if(*(inputtag->tag) == 0x77){ //BF0C
1218         memcpy(currentcard->tag_77,inputtag->value,inputtag->valuelength);}
1219     else if(*(inputtag->tag) == 0x80){ //BF0C
1220         memcpy(currentcard->tag_80,inputtag->value,inputtag->valuelength);}
1221     else if(*(inputtag->tag) == 0x82){ //BF0C
1222         if(!(inputtag->valuelength <= sizeof(currentcard->tag_82)))
1223             return 1;
1224         memcpy(currentcard->tag_82, inputtag->value, inputtag->valuelength);}
1225     else if(*(inputtag->tag) == 0x84){ //BF0C
1226         if(!(inputtag->valuelength <= sizeof(currentcard->tag_84)))
1227             return 1;
1228         memcpy(currentcard->tag_84, inputtag->value, inputtag->valuelength);
1229         currentcard->tag_84_len = inputtag->valuelength;
1230     }
1231     else if(*(inputtag->tag) == 0x86){ //BF0C
1232         if(!(inputtag->valuelength <= sizeof(currentcard->tag_86)))
1233             return 1;
1234         memcpy(currentcard->tag_86, inputtag->value, inputtag->valuelength);
1235         currentcard->tag_86_len = inputtag->valuelength;
1236     }
1237     else if(*(inputtag->tag) == 0x87){ //BF0C
1238         if(!(inputtag->valuelength <= sizeof(currentcard->tag_87)))
1239             return 1;
1240         memcpy(currentcard->tag_87, inputtag->value, inputtag->valuelength);}
1241     else if(*(inputtag->tag) == 0x88){ //BF0C
1242         if(!(inputtag->valuelength <= sizeof(currentcard->tag_88)))
1243             return 1;
1244         memcpy(currentcard->tag_88, inputtag->value, inputtag->valuelength);}
1245     else if(*(inputtag->tag) == 0x8A){ //BF0C
1246         if(!(inputtag->valuelength <= sizeof(currentcard->tag_8A)))
1247             return 1;
1248         memcpy(currentcard->tag_8A, inputtag->value, inputtag->valuelength);}
1249     else if(*(inputtag->tag) == 0x8C){ //BF0C
1250         if(!(inputtag->valuelength <= sizeof(currentcard->tag_8C)))
1251             return 1;
1252         memcpy(currentcard->tag_8C, inputtag->value, inputtag->valuelength);
1253         currentcard->tag_8C_len = inputtag->valuelength;
1254     }
1255     else if(*(inputtag->tag) == 0x8D){ //BF0C
1256         if(!(inputtag->valuelength <= sizeof(currentcard->tag_8D)))
1257             return 1;
1258         memcpy(currentcard->tag_8D, inputtag->value, inputtag->valuelength);
1259         currentcard->tag_8D_len = inputtag->valuelength;
1260     }
1261     else if(*(inputtag->tag) == 0x8E){ //BF0C
1262         if(!(inputtag->valuelength <= sizeof(currentcard->tag_8E)))
1263             return 1;
1264         memcpy(currentcard->tag_8E, inputtag->value, inputtag->valuelength);
1265         currentcard->tag_8E_len = inputtag->valuelength;
1266     }
1267     else if(*(inputtag->tag) == 0x8F){ //BF0C
1268         if(!(inputtag->valuelength <= sizeof(currentcard->tag_8F)))
1269             return 1;
1270         memcpy(currentcard->tag_8F,inputtag->value,sizeof(currentcard->tag_8F));}
1271     else if(*(inputtag->tag) == 0x90){ //BF0C
1272         if(!(inputtag->valuelength <= sizeof(currentcard->tag_90)))
1273             return 1;
1274         memcpy(currentcard->tag_90, inputtag->value, inputtag->valuelength);
1275         currentcard->tag_90_len = inputtag->valuelength;}
1276     else if(*(inputtag->tag) == 0x92){ //BF0C
1277         if(!(inputtag->valuelength <= sizeof(currentcard->tag_92)))
1278             return 1;
1279         memcpy(currentcard->tag_92, inputtag->value, inputtag->valuelength);
1280         currentcard->tag_92_len = inputtag->valuelength;}
1281     else if(*(inputtag->tag) == 0x93){ //BF0C
1282         if(!(inputtag->valuelength <= sizeof(currentcard->tag_93)))
1283             return 1;
1284         memcpy(currentcard->tag_93, inputtag->value, inputtag->valuelength);
1285         currentcard->tag_93_len = inputtag->valuelength;}
1286     else if(*(inputtag->tag) == 0x94){ //BF0C
1287         if(!(inputtag->valuelength <= sizeof(currentcard->tag_94)))
1288             return 1;
1289         memcpy(currentcard->tag_94, inputtag->value, inputtag->valuelength);
1290         currentcard->tag_94_len = inputtag->valuelength;}
1291     else if(*(inputtag->tag) == 0x95){ //BF0C
1292         if(!(inputtag->valuelength <= sizeof(currentcard->tag_95)))
1293             return 1;
1294         memcpy(currentcard->tag_95, inputtag->value, inputtag->valuelength);}
1295     else if(*(inputtag->tag) == 0x97){ //BF0C
1296         if(!(inputtag->valuelength <= sizeof(currentcard->tag_97)))
1297             return 1;
1298         memcpy(currentcard->tag_97, inputtag->value, inputtag->valuelength);
1299         currentcard->tag_97_len = inputtag->valuelength;}
1300     else if(*(inputtag->tag) == 0x98){ //BF0C
1301         if(!(inputtag->valuelength <= sizeof(currentcard->tag_98)))
1302             return 1;
1303         memcpy(currentcard->tag_98, inputtag->value, inputtag->valuelength);}
1304     else if(*(inputtag->tag) == 0x99){ //BF0C
1305         if(!(inputtag->valuelength <= sizeof(currentcard->tag_99)))
1306             return 1;
1307         memcpy(currentcard->tag_99, inputtag->value, inputtag->valuelength);
1308         currentcard->tag_99_len = inputtag->valuelength;}
1309     else if(*(inputtag->tag) == 0x9A){ //BF0C
1310         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9A)))
1311             return 1;
1312         memcpy(currentcard->tag_9A, inputtag->value, inputtag->valuelength);}
1313     else if(*(inputtag->tag) == 0x9B){ //BF0C
1314         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9B)))
1315             return 1;
1316         memcpy(currentcard->tag_9B, inputtag->value, inputtag->valuelength);}
1317     else if(*(inputtag->tag) == 0x9C){ //BF0C
1318         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9C)))
1319             return 1;
1320         memcpy(currentcard->tag_9C, inputtag->value, inputtag->valuelength);}
1321     else if(*(inputtag->tag) == 0x9D){ //BF0C
1322         if(!(inputtag->valuelength <= sizeof(currentcard->tag_9D)))
1323             return 1;
1324         memcpy(currentcard->tag_9D, inputtag->value, inputtag->valuelength);
1325         currentcard->tag_9D_len = inputtag->valuelength;}
1326     else if(*(inputtag->tag) == 0xA5){ //BF0C
1327         if(!(inputtag->valuelength <= sizeof(currentcard->tag_A5)))
1328             return 1;
1329         memcpy(currentcard->tag_A5, inputtag->value, inputtag->valuelength);
1330         currentcard->tag_A5_len = inputtag->valuelength;}
1331    }
1332    return 0;
1333 }
1334
1335 int emv_decode_field(uint8_t* inputfield,uint16_t inputlength, emvtags *result)
1336 {
1337     uint16_t lengthcounter=0;
1338     tlvtag newtag;
1339     //copy result to the testtag
1340     if(!result){
1341         return 1;
1342     }
1343     //loop through and decode template
1344     while(lengthcounter < inputlength)
1345     {
1346         //decode the tlv tag
1347         decode_ber_tlv_item((inputfield+lengthcounter),&newtag);
1348         //write the emvtags strucutre
1349         emv_emvtags_decode_tag(&newtag,result);
1350         //move to next value and decode
1351         lengthcounter += newtag.fieldlength-1;
1352     }
1353     return 0;
1354 }
1355
1356 int emv_select(uint8_t* AID, uint8_t AID_len, void* data)
1357 {
1358     uint16_t selectCmd_len = 4 + 1 + AID_len + 1;
1359     uint8_t selectCmd[selectCmd_len];
1360
1361     selectCmd[0] = 0x00;
1362     selectCmd[1] = 0xA4;
1363     selectCmd[2] = 0x04;
1364     selectCmd[3] = 0x00;
1365     selectCmd[4] = AID_len;
1366     memcpy(&(selectCmd[5]), AID, AID_len);
1367     selectCmd[selectCmd_len-1] = 0x00;
1368     return iso14_apdu(selectCmd,selectCmd_len,false, 0,data);
1369 }
1370
1371 //perform READ RECORD
1372 int emv_readrecord(uint8_t recordnumber, uint8_t sfi, void* data)
1373 {
1374     uint16_t readRecordCmd_len = 5;
1375     uint8_t readRecordCmd[readRecordCmd_len];
1376
1377     readRecordCmd[0] = 0x00;
1378     readRecordCmd[1] = 0xB2;
1379     readRecordCmd[2] = recordnumber;
1380     readRecordCmd[3] = ((sfi << 3) | 0x04);
1381     readRecordCmd[4] = 0x00;
1382     return iso14_apdu(readRecordCmd,readRecordCmd_len,false,0,data);
1383 }
1384
1385 int emv_getprocessingoptions(uint8_t* pdol, uint8_t pdol_len, void* data)
1386 {
1387     uint16_t processingCmd_len = 4 + 1 + 2 + pdol_len + 1;
1388     uint8_t processingCmd[processingCmd_len];
1389
1390     processingCmd[0] = 0x80;
1391     processingCmd[1] = 0xA8;
1392     processingCmd[2] = 0x00;
1393     processingCmd[3] = 0x00;
1394     processingCmd[4] = pdol_len + 2;
1395     processingCmd[5] = 0x83; //template
1396     processingCmd[6] = pdol_len;
1397     if(pdol_len > 0){
1398         memcpy(&(processingCmd[7]), pdol, pdol_len);}
1399     processingCmd[processingCmd_len] = 0x00;
1400     //Dbhexdump(processingCmd_len, processingCmd, false);
1401     return iso14_apdu(processingCmd,processingCmd_len,false, 0, data);
1402 }
1403
1404 int emv_computecryptogram(uint8_t* UDOL, uint8_t UDOL_len, void *data)
1405 {
1406     uint16_t cryptogramCmd_len = 4 + 1 + UDOL_len + 1;
1407     uint8_t cryptogramCmd[cryptogramCmd_len];
1408
1409     cryptogramCmd[0] = 0x80;
1410     cryptogramCmd[1] = 0x2A;
1411     cryptogramCmd[2] = 0x8E;
1412     cryptogramCmd[3] = 0x80;
1413     cryptogramCmd[4] = UDOL_len;
1414     memcpy(&(cryptogramCmd[5]), UDOL, UDOL_len);
1415     cryptogramCmd[cryptogramCmd_len-1] = 0x00;
1416
1417     return iso14_apdu(cryptogramCmd,cryptogramCmd_len,false, 0,data);
1418 }
1419
1420 int emv_getchallenge(void *data)
1421 {
1422     uint16_t challengeCmd_len = 5;
1423     uint8_t challengeCmd[challengeCmd_len];
1424
1425     challengeCmd[0] = 0x00;
1426     challengeCmd[1] = 0x84;
1427     challengeCmd[2] = 0x00;
1428     challengeCmd[3] = 0x00;
1429     challengeCmd[4] = 0x00;
1430
1431     return iso14_apdu(challengeCmd,challengeCmd_len,false, 0,data);
1432 }
1433
1434 int emv_loopback(uint8_t* transData , uint8_t transData_len, void *data)
1435 {
1436     uint16_t loopbackCmd_len = 4 + 1 + transData_len + 1;
1437     uint8_t loopbackCmd[loopbackCmd_len];
1438
1439     loopbackCmd[0] = 0x00;
1440     loopbackCmd[1] = 0xEE;
1441     loopbackCmd[2] = 0x00;
1442     loopbackCmd[3] = 0x00;
1443     loopbackCmd[4] = loopbackCmd_len;
1444     memcpy(&(loopbackCmd[5]), transData, transData_len);
1445     return iso14_apdu(loopbackCmd,loopbackCmd_len,false, 0,data);
1446 }
1447
1448 //generateAC
1449 int emv_generateAC(uint8_t refcontrolparam, uint8_t* cdolinput, uint8_t cdolinputlen, void* data)
1450 {
1451     uint16_t acCmd_len = 4 + 1 + cdolinputlen + 1;
1452     uint8_t acCmd[acCmd_len];
1453
1454     acCmd[0] = 0x80;
1455     acCmd[1] = 0xAE;
1456     acCmd[2] = refcontrolparam;
1457     acCmd[3] = 0x00;
1458     acCmd[4] = cdolinputlen;
1459     memcpy(&(acCmd[5]), cdolinput, cdolinputlen);
1460     acCmd[acCmd_len-1] = 0x00;
1461     Dbhexdump(acCmd_len, acCmd,false);
1462     return iso14_apdu(acCmd,acCmd_len,false,0,data);
1463 }
1464
1465 int emv_decodeAFL(uint8_t* AFL, uint8_t AFLlen )
1466 {
1467
1468     return 0;
1469 }
1470
1471 //Print out AIP Bit meanings
1472 int emv_decodeAIP(uint8_t* AIP)
1473 {
1474     if((AIP[0] & AIP_SDA_SUPPORTED) == AIP_SDA_SUPPORTED)
1475         Dbprintf("SDA supported");
1476     if((AIP[0] & AIP_DDA_SUPPORTED) == AIP_DDA_SUPPORTED)
1477         Dbprintf("DDA supported");
1478     if((AIP[0] & AIP_CARDHOLDER_VERIFICATION)==AIP_CARDHOLDER_VERIFICATION)
1479         Dbprintf("Cardholder verification is supported");
1480     if((AIP[0] & AIP_TERMINAL_RISK) == AIP_TERMINAL_RISK)
1481         Dbprintf("Terminal risk management is to be performed");
1482     if((AIP[0] & AIP_ISSUER_AUTH) == AIP_ISSUER_AUTH)
1483         Dbprintf("Issuer authentication is supported ");
1484     if((AIP[0] & AIP_CDA_SUPPORTED) == AIP_CDA_SUPPORTED)
1485         Dbprintf("CDA supported");
1486     if((AIP[1] & AIP_CHIP_SUPPORTED) == AIP_CHIP_SUPPORTED)
1487         Dbprintf("Chip supported");
1488     if((AIP[1] & AIP_MSR_SUPPORTED) == AIP_MSR_SUPPORTED)
1489         Dbprintf("MSR supported");
1490     return 0;
1491 }
1492
1493 int emv_decodeCVM(uint8_t* CVM, uint8_t CVMlen)
1494 {
1495     uint8_t counter = 0;
1496     uint32_t amountX = 0;
1497     uint32_t amountY = 0;
1498     amountX = bytes_to_num(CVM, 4);
1499     amountY = bytes_to_num(CVM+4, 4);
1500     counter +=8;
1501     while(counter < CVMlen)
1502     {
1503         if((CVM[counter] & 0x40) == 0x40){
1504             if((CVM[counter] & 0x3F)== 0x00){
1505                 Dbprintf("Fail CVM processing");
1506             }
1507             if((CVM[counter] & 0x3F) == 0x01){
1508                 Dbprintf("Plaintext PIN verification performed by ICC");
1509             }
1510             if((CVM[counter] & 0x3F) == 0x02){
1511                 Dbprintf("Enciphered PIN verified online");
1512             }
1513             if((CVM[counter] & 0x3F) == 0x03){
1514                 Dbprintf("Plaintext PIN verification performed by ICC and signature (paper)");
1515             }
1516             if((CVM[counter] & 0x3F) == 0x04){
1517                 Dbprintf("Enciphered PIN verification performed by ICC");
1518             }
1519             if((CVM[counter] & 0x3F) == 0x05){
1520                 Dbprintf("Enciphered PIN verification performed by ICC and signature (paper)");
1521             }
1522             if((CVM[counter] & 0x3F) == 0x30){
1523                 Dbprintf("Signature (paper)");
1524             }
1525             if((CVM[counter] & 0x3F) == 0x40){
1526                 Dbprintf("No CVM required");
1527             }
1528             counter +=2;
1529         }
1530         else{
1531             Dbprintf("Fail cardholder verification if this CVM is unsuccessful");
1532             counter +=2;
1533         }
1534         if(CVM[counter+1] == 0x00){
1535             Dbprintf("Always");}
1536         if(CVM[counter+1] == 0x01){
1537             Dbprintf("If unattended cash");}
1538         if(CVM[counter+1] == 0x02){
1539             Dbprintf("If not unattended cash and not manual cash and not purchase with cashback");}
1540         if(CVM[counter+1] == 0x03){
1541             Dbprintf("If terminal supports the CVM");}
1542         if(CVM[counter+1] == 0x04){
1543             Dbprintf("If manual cash");}
1544         if(CVM[counter+1] == 0x05){
1545             Dbprintf("If purchase with cashback");}
1546         if(CVM[counter+1] == 0x06){
1547             Dbprintf("If transaction is in the application currency and is under %lu value", amountX);}
1548          if(CVM[counter+1] == 0x07){
1549             Dbprintf("If transaction is in the application currency and is over %lu value", amountX);}
1550          if(CVM[counter+1] == 0x08){
1551             Dbprintf("If transaction is in the application currency and is under %lu value", amountY);}
1552          if(CVM[counter+1] == 0x09){
1553             Dbprintf("If transaction is in the application currency and is over %lu value", amountY);}
1554      }
1555     return 0;
1556 }
1557
1558 //dump the current card to the console
1559 void dumpCard(emvtags* currentcard){
1560     DUMP(currentcard->ATQA);
1561     Dbhexdump(sizeof(currentcard->ATQA), currentcard->ATQA, false);
1562     DUMP(currentcard->UID);
1563     Dbhexdump(currentcard->UID_len,  currentcard->UID, false);
1564     DUMP(currentcard->SAK1);
1565     Dbhexdump(1,  &currentcard->SAK1, false);
1566     DUMP(currentcard->SAK2);
1567     Dbhexdump(1,  &currentcard->SAK2, false);
1568     DUMP(currentcard->ATS);
1569     Dbhexdump(currentcard->ATS_len,  currentcard->ATS, false);
1570
1571     DUMP(currentcard->tag_4F);
1572     Dbhexdump(currentcard->tag_4F_len,  currentcard->tag_4F, false);
1573     DUMP(currentcard->tag_50);
1574     Dbhexdump(currentcard->tag_50_len,  currentcard->tag_50, false);
1575     DUMP(currentcard->tag_56);
1576     Dbhexdump(currentcard->tag_56_len,  currentcard->tag_56, false);
1577     DUMP(currentcard->tag_57);
1578     Dbhexdump(currentcard->tag_57_len,  currentcard->tag_57, false);
1579     DUMP(currentcard->tag_5A);
1580     Dbhexdump(currentcard->tag_5A_len,  currentcard->tag_5A, false);
1581     DUMP(currentcard->tag_82);
1582     Dbhexdump(sizeof(currentcard->tag_82),  currentcard->tag_82, false);
1583     DUMP(currentcard->tag_84);
1584     Dbhexdump(currentcard->tag_84_len,  currentcard->tag_84, false);
1585     DUMP(currentcard->tag_86);
1586     Dbhexdump(currentcard->tag_86_len,  currentcard->tag_86, false);
1587     DUMP(currentcard->tag_87);
1588     Dbhexdump(1,  currentcard->tag_87, false);
1589 DUMP(currentcard->tag_88);
1590     Dbhexdump(1,  currentcard->tag_88, false);
1591 DUMP(currentcard->tag_8A);
1592     Dbhexdump(2,  currentcard->tag_8A, false);
1593     DUMP(currentcard->tag_8C);
1594     Dbhexdump(currentcard->tag_8C_len,  currentcard->tag_8C, false);
1595     DUMP(currentcard->tag_8D);
1596     Dbhexdump(currentcard->tag_8D_len,  currentcard->tag_8D, false);
1597     DUMP(currentcard->tag_8E);
1598     Dbhexdump(currentcard->tag_8E_len,  currentcard->tag_8E, false);
1599     DUMP(currentcard->tag_8F);
1600     Dbhexdump(1,  currentcard->tag_8F, false);
1601     DUMP(currentcard->tag_90);
1602     Dbhexdump(currentcard->tag_90_len,  currentcard->tag_90, false);
1603     DUMP(currentcard->tag_92);
1604     Dbhexdump(currentcard->tag_92_len,  currentcard->tag_92, false);
1605     DUMP(currentcard->tag_93);
1606     Dbhexdump(currentcard->tag_93_len,  currentcard->tag_93, false);
1607     DUMP(currentcard->tag_94);
1608     Dbhexdump(currentcard->tag_94_len,  currentcard->tag_94, false);
1609     DUMP(currentcard->tag_95);
1610     Dbhexdump(5,  currentcard->tag_95, false);
1611     DUMP(currentcard->tag_97);
1612     Dbhexdump(currentcard->tag_97_len,  currentcard->tag_97, false);
1613     DUMP(currentcard->tag_98);
1614     Dbhexdump(20, currentcard->tag_98, false);
1615     DUMP(currentcard->tag_99);
1616     Dbhexdump(currentcard->tag_99_len,  currentcard->tag_99, false);
1617     DUMP(currentcard->tag_9A);
1618     Dbhexdump(3,  currentcard->tag_9A, false);
1619     DUMP(currentcard->tag_9B);
1620     Dbhexdump(2,  currentcard->tag_9B, false);
1621     DUMP(currentcard->tag_9C);
1622     Dbhexdump(1,  currentcard->tag_9C, false);
1623     DUMP(currentcard->tag_9D);
1624     Dbhexdump(currentcard->tag_9D_len,  currentcard->tag_9D, false);
1625     DUMP(currentcard->tag_CD);
1626     Dbhexdump(3,  currentcard->tag_CD, false);
1627     DUMP(currentcard->tag_CE);
1628     Dbhexdump(3,  currentcard->tag_CE, false);
1629     DUMP(currentcard->tag_CF);
1630     Dbhexdump(3,  currentcard->tag_CF, false);
1631     DUMP(currentcard->tag_D7);
1632     Dbhexdump(3,  currentcard->tag_D7, false);
1633     DUMP(currentcard->tag_D8);
1634     Dbhexdump(2,  currentcard->tag_D8, false);
1635     DUMP(currentcard->tag_D9);
1636     Dbhexdump(currentcard->tag_D9_len,  currentcard->tag_D9, false);
1637     DUMP(currentcard->tag_DA);
1638     Dbhexdump(2,  currentcard->tag_DA, false);
1639     DUMP(currentcard->tag_DB);
1640     Dbhexdump(2,  currentcard->tag_DB, false);
1641     DUMP(currentcard->tag_DC);
1642     Dbhexdump(2,  currentcard->tag_DC, false);
1643     DUMP(currentcard->tag_DD);
1644     Dbhexdump(2,  currentcard->tag_DD, false);
1645     DUMP(currentcard->tag_AF);
1646     Dbhexdump(currentcard->tag_AF_len,  currentcard->tag_AF, false);
1647     DUMP(currentcard->tag_5F20);
1648     Dbhexdump(currentcard->tag_5F20_len,  currentcard->tag_5F20, false);
1649     DUMP(currentcard->tag_5F24);
1650     Dbhexdump(3,  currentcard->tag_5F24, false);
1651     DUMP(currentcard->tag_5F25);
1652     Dbhexdump(3,  currentcard->tag_5F25, false);
1653     DUMP(currentcard->tag_5F28);
1654     Dbhexdump(2,  currentcard->tag_5F28, false);
1655     DUMP(currentcard->tag_5F2A);
1656     Dbhexdump(2,  currentcard->tag_5F2A, false);
1657     DUMP(currentcard->tag_5F2D);
1658     Dbhexdump(currentcard->tag_5F2D_len,  currentcard->tag_5F2D, false);
1659     DUMP(currentcard->tag_5F30);
1660     Dbhexdump(3,  currentcard->tag_5F30, false);
1661     DUMP(currentcard->tag_5F34);
1662     Dbhexdump(1,  currentcard->tag_5F34, false);
1663     DUMP(currentcard->tag_5F36);
1664     Dbhexdump(2,  currentcard->tag_5F36, false);
1665     DUMP(currentcard->tag_5F50);
1666     Dbhexdump(currentcard->tag_5F50_len,  currentcard->tag_5F50, false);
1667     DUMP(currentcard->tag_5F54);
1668     Dbhexdump(currentcard->tag_5F54_len,  currentcard->tag_5F54, false);
1669     DUMP(currentcard->tag_9F01);
1670     Dbhexdump(6,  currentcard->tag_9F01, false);
1671     DUMP(currentcard->tag_9F02);
1672     Dbhexdump(6,  currentcard->tag_9F02, false);
1673     DUMP(currentcard->tag_9F03);
1674     Dbhexdump(6,  currentcard->tag_9F03, false);
1675     DUMP(currentcard->tag_9F04);
1676     Dbhexdump(4,  currentcard->tag_9F04, false);
1677     DUMP(currentcard->tag_9F05);
1678     Dbhexdump(currentcard->tag_9F05_len,  currentcard->tag_9F05, false);
1679     DUMP(currentcard->tag_9F06);
1680     Dbhexdump(currentcard->tag_9F06_len,  currentcard->tag_9F06, false);
1681     DUMP(currentcard->tag_9F07);
1682     Dbhexdump(2,  currentcard->tag_9F07, false);
1683     DUMP(currentcard->tag_9F08);
1684     Dbhexdump(2,  currentcard->tag_9F08, false);
1685     DUMP(currentcard->tag_9F09);
1686     Dbhexdump(2,  currentcard->tag_9F09, false);
1687     DUMP(currentcard->tag_9F0B);
1688     Dbhexdump(currentcard->tag_9F0B_len,  currentcard->tag_9F0B, false);
1689     DUMP(currentcard->tag_9F0D);
1690     Dbhexdump(5,  currentcard->tag_9F0D, false);
1691     DUMP(currentcard->tag_9F0E);
1692     Dbhexdump(5,  currentcard->tag_9F0E, false);
1693     DUMP(currentcard->tag_9F0F);
1694     Dbhexdump(5,  currentcard->tag_9F0F, false);
1695     DUMP(currentcard->tag_9F10);
1696     Dbhexdump(currentcard->tag_9F10_len,  currentcard->tag_9F10, false);
1697     DUMP(currentcard->tag_9F11);
1698     Dbhexdump(1,  currentcard->tag_9F11, false);
1699     DUMP(currentcard->tag_9F12);
1700     Dbhexdump(currentcard->tag_9F12_len,  currentcard->tag_9F12, false);
1701     DUMP(currentcard->tag_9F13);
1702     Dbhexdump(2,  currentcard->tag_9F13, false);
1703     DUMP(currentcard->tag_9F14);
1704     Dbhexdump(1,  currentcard->tag_9F14, false);
1705     DUMP(currentcard->tag_9F15);
1706     Dbhexdump(2,  currentcard->tag_9F15, false);
1707     DUMP(currentcard->tag_9F16);
1708     Dbhexdump(15,  currentcard->tag_9F16, false);
1709     DUMP(currentcard->tag_9F17);
1710     Dbhexdump(1,  currentcard->tag_9F17, false);
1711     DUMP(currentcard->tag_9F18);
1712     Dbhexdump(4,  currentcard->tag_9F18, false);
1713     DUMP(currentcard->tag_9F1A);
1714     Dbhexdump(2,  currentcard->tag_9F1A, false);
1715     DUMP(currentcard->tag_9F1B);
1716     Dbhexdump(4,  currentcard->tag_9F1B, false);
1717     DUMP(currentcard->tag_9F1C);
1718     Dbhexdump(8,  currentcard->tag_9F1C, false);
1719     DUMP(currentcard->tag_9F1D);
1720     Dbhexdump(currentcard->tag_9F1D_len,  currentcard->tag_9F1D, false);
1721     DUMP(currentcard->tag_9F1E);
1722     Dbhexdump(8,  currentcard->tag_9F1E, false);
1723     DUMP(currentcard->tag_9F1F);
1724     Dbhexdump(currentcard->tag_9F1F_len,  currentcard->tag_9F1F, false);
1725     DUMP(currentcard->tag_9F20);
1726     Dbhexdump(currentcard->tag_9F20_len,  currentcard->tag_9F20, false);
1727     DUMP(currentcard->tag_9F21);
1728     Dbhexdump(3,  currentcard->tag_9F1E, false);
1729     DUMP(currentcard->tag_9F22);
1730     Dbhexdump(1,  currentcard->tag_9F22, false);
1731     DUMP(currentcard->tag_9F23);
1732     Dbhexdump(1,  currentcard->tag_9F23, false);
1733     DUMP(currentcard->tag_9F26);
1734     Dbhexdump(8,  currentcard->tag_9F26, false);
1735     DUMP(currentcard->tag_9F27);
1736     Dbhexdump(1,  currentcard->tag_9F27, false);
1737     DUMP(currentcard->tag_9F2D);
1738     Dbhexdump(currentcard->tag_9F2D_len,  currentcard->tag_9F2D, false);
1739     DUMP(currentcard->tag_9F2E);
1740     Dbhexdump(3,  currentcard->tag_9F2E, false);
1741     DUMP(currentcard->tag_9F2F);
1742     Dbhexdump(currentcard->tag_9F2F_len,  currentcard->tag_9F2F, false);
1743     DUMP(currentcard->tag_9F32);
1744     Dbhexdump(currentcard->tag_9F32_len,  currentcard->tag_9F32, false);
1745     DUMP(currentcard->tag_9F33);
1746     Dbhexdump(3,  currentcard->tag_9F33, false);
1747     DUMP(currentcard->tag_9F34);
1748     Dbhexdump(3,  currentcard->tag_9F34, false);
1749     DUMP(currentcard->tag_9F35);
1750     Dbhexdump(1,  currentcard->tag_9F35, false);
1751     DUMP(currentcard->tag_9F36);
1752     Dbhexdump(2,  currentcard->tag_9F36, false);
1753     DUMP(currentcard->tag_9F37);
1754     Dbhexdump(4,  currentcard->tag_9F37, false);
1755     DUMP(currentcard->tag_9F38);
1756     Dbhexdump(currentcard->tag_9F38_len,  currentcard->tag_9F38, false);
1757     DUMP(currentcard->tag_9F39);
1758     Dbhexdump(1,  currentcard->tag_9F39, false);
1759     DUMP(currentcard->tag_9F39);
1760     Dbhexdump(1,  currentcard->tag_9F39, false);
1761     DUMP(currentcard->tag_9F40);
1762     Dbhexdump(5,  currentcard->tag_9F40, false);
1763     DUMP(currentcard->tag_9F41);
1764     Dbhexdump(4,  currentcard->tag_9F41, false);
1765     DUMP(currentcard->tag_9F42);
1766     Dbhexdump(2,  currentcard->tag_9F42, false);
1767     DUMP(currentcard->tag_9F43);
1768     Dbhexdump(4,  currentcard->tag_9F43, false);
1769     DUMP(currentcard->tag_9F44);
1770     Dbhexdump(1,  currentcard->tag_9F44, false);
1771     DUMP(currentcard->tag_9F45);
1772     Dbhexdump(2,  currentcard->tag_9F45, false);
1773     DUMP(currentcard->tag_9F46);
1774     Dbhexdump(currentcard->tag_9F46_len,  currentcard->tag_9F46, false);
1775     DUMP(currentcard->tag_9F47);
1776     Dbhexdump(currentcard->tag_9F47_len,  currentcard->tag_9F47, false);
1777     DUMP(currentcard->tag_9F48);
1778     Dbhexdump(currentcard->tag_9F48_len,  currentcard->tag_9F48, false);
1779     DUMP(currentcard->tag_9F49);
1780     Dbhexdump(currentcard->tag_9F49_len,  currentcard->tag_9F49, false);
1781     DUMP(currentcard->tag_9F4A);
1782     Dbhexdump(1,  currentcard->tag_9F4A, false);
1783     DUMP(currentcard->tag_9F4B);
1784     Dbhexdump(currentcard->tag_9F4B_len,  currentcard->tag_9F4B, false);
1785     DUMP(currentcard->tag_9F4C);
1786     Dbhexdump(8,  currentcard->tag_9F4C, false);
1787     DUMP(currentcard->tag_9F4D);
1788     Dbhexdump(2,  currentcard->tag_9F4D, false);
1789     DUMP(currentcard->tag_9F4E);
1790     Dbhexdump(255,  currentcard->tag_9F4E, false);
1791     DUMP(currentcard->tag_9F60);
1792     Dbhexdump(2,  currentcard->tag_9F60, false);
1793     DUMP(currentcard->tag_9F61);
1794     Dbhexdump(2,  currentcard->tag_9F61, false);
1795     DUMP(currentcard->tag_9F62);
1796     Dbhexdump(6,  currentcard->tag_9F62, false);
1797     DUMP(currentcard->tag_9F63);
1798     Dbhexdump(6,  currentcard->tag_9F63, false);
1799     DUMP(currentcard->tag_9F64);
1800     Dbhexdump(1,  currentcard->tag_9F64, false);
1801     DUMP(currentcard->tag_9F65);
1802     Dbhexdump(2,  currentcard->tag_9F65, false);
1803     DUMP(currentcard->tag_9F66);
1804     Dbhexdump(2,  currentcard->tag_9F66, false);
1805     DUMP(currentcard->tag_9F67);
1806     Dbhexdump(1,  currentcard->tag_9F67, false);
1807     DUMP(currentcard->tag_9F68);
1808     Dbhexdump(currentcard->tag_9F68_len,  currentcard->tag_9F68, false);
1809     DUMP(currentcard->tag_9F69);
1810     Dbhexdump(currentcard->tag_9F69_len,  currentcard->tag_9F69, false);
1811     DUMP(currentcard->tag_9F6A);
1812     Dbhexdump(8,  currentcard->tag_9F6A, false);
1813     DUMP(currentcard->tag_9F6B);
1814     Dbhexdump(currentcard->tag_9F6B_len,  currentcard->tag_9F6B, false);
1815     DUMP(currentcard->tag_9F6C);
1816     Dbhexdump(2,  currentcard->tag_9F6C, false);
1817     DUMP(currentcard->tag_61);
1818     Dbhexdump(currentcard->tag_61_len,  currentcard->tag_61, false);
1819     DUMP(currentcard->tag_A5);
1820     Dbhexdump(currentcard->tag_A5_len,  currentcard->tag_A5, false);
1821     DUMP(currentcard->tag_DFNAME);
1822     Dbhexdump(currentcard->tag_DFNAME_len,  currentcard->tag_DFNAME, false);
1823     DUMP(currentcard->tag_70);
1824     Dbhexdump(currentcard->tag_70_len,  currentcard->tag_70, false);
1825     DUMP(currentcard->tag_77);
1826     Dbhexdump(currentcard->tag_77_len,  currentcard->tag_77, false);
1827     DUMP(currentcard->tag_80);
1828     Dbhexdump(currentcard->tag_80_len,  currentcard->tag_80, false);
1829     DUMP(currentcard->tag_91);
1830     Dbhexdump(currentcard->tag_91_len,  currentcard->tag_91, false);
1831     DUMP(currentcard->tag_BF0C);
1832     Dbhexdump(currentcard->tag_BF0C_len,  currentcard->tag_BF0C, false);
1833     DUMP(currentcard->tag_DFName);
1834     Dbhexdump(currentcard->tag_DFName_len,  currentcard->tag_DFName, false);
1835 }
1836
1837