git.zerfleddert.de Git - proxmark3-svn/blob - client/emv/emv_tags.c

   1 /*
   2  * libopenemv - a library to work with EMV family of smart cards
   3  * Copyright (C) 2015 Dmitry Eremin-Solenikov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  */
  15
  16 #ifdef HAVE_CONFIG_H
  17 #include <config.h>
  18 #endif
  19
  20 #include "tlv.h"
  21 #include "emv_tags.h"
  22
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #define PRINT_INDENT(level)     {for (int i = 0; i < (level); i++) fprintf(f, "\t");}
  27
  28 enum emv_tag_t {
  29         EMV_TAG_GENERIC,
  30         EMV_TAG_BITMASK,
  31         EMV_TAG_DOL,
  32         EMV_TAG_CVM_LIST,
  33         EMV_TAG_AFL,
  34         EMV_TAG_STRING,
  35         EMV_TAG_NUMERIC,
  36         EMV_TAG_YYMMDD,
  37         EMV_TAG_CVR,
  38         EMV_TAG_CID,
  39 };
  40
  41 struct emv_tag {
  42         tlv_tag_t tag;
  43         char *name;
  44         enum emv_tag_t type;
  45         const void *data;
  46 };
  47
  48 struct emv_tag_bit {
  49         unsigned bit;
  50         const char *name;
  51 };
  52
  53 #define EMV_BIT(byte, bit) ((byte - 1) * 8 + (8 - bit))
  54 #define EMV_BIT_FINISH { (~0), NULL }
  55
  56 static const struct emv_tag_bit EMV_AIP[] = {
  57         { EMV_BIT(1, 7), "SDA supported" },
  58         { EMV_BIT(1, 6), "DDA supported" },
  59         { EMV_BIT(1, 5), "Cardholder verification is supported" },
  60         { EMV_BIT(1, 4), "Terminal risk management is to be performed" },
  61         { EMV_BIT(1, 3), "Issuer authentication is supported" },
  62         { EMV_BIT(1, 2), "Reserved for use by the EMV Contactless Specifications" },
  63         { EMV_BIT(1, 1), "CDA supported (Combined Dynamic Data Authentication / Application Cryptogram Generation)" },
  64         { EMV_BIT(2, 8), "MSD is supported (Magnetic Stripe Data)" },
  65         { EMV_BIT(2, 7), "Reserved for use by the EMV Contactless Specifications" },
  66         { EMV_BIT(2, 6), "Reserved for use by the EMV Contactless Specifications" },
  67         { EMV_BIT(2, 1), "Reserved for use by the EMV Contactless Specifications" },
  68         EMV_BIT_FINISH,
  69 };
  70
  71 static const struct emv_tag_bit EMV_AUC[] = {
  72         { EMV_BIT(1, 8), "Valid for domestic cash transactions" },
  73         { EMV_BIT(1, 7), "Valid for international cash transactions" },
  74         { EMV_BIT(1, 6), "Valid for domestic goods" },
  75         { EMV_BIT(1, 5), "Valid for international goods" },
  76         { EMV_BIT(1, 4), "Valid for domestic services" },
  77         { EMV_BIT(1, 3), "Valid for international services" },
  78         { EMV_BIT(1, 2), "Valid for ATMs" },
  79         { EMV_BIT(1, 1), "Valid at terminals other than ATMs" },
  80         { EMV_BIT(2, 8), "Domestic cashback allowed" },
  81         { EMV_BIT(2, 7), "International cashback allowed" },
  82         EMV_BIT_FINISH,
  83 };
  84
  85 static const struct emv_tag_bit EMV_TVR[] = {
  86         { EMV_BIT(1, 8), "Offline data authentication was not performed" },
  87         { EMV_BIT(1, 7), "SDA failed" },
  88         { EMV_BIT(1, 6), "ICC data missing" },
  89         { EMV_BIT(1, 5), "Card appears on terminal exception file" },
  90         { EMV_BIT(1, 4), "DDA failed" },
  91         { EMV_BIT(1, 3), "CDA failed" },
  92         { EMV_BIT(1, 2), "SDA selected" },
  93         { EMV_BIT(2, 8), "ICC and terminal have different application versions" },
  94         { EMV_BIT(2, 7), "Expired application" },
  95         { EMV_BIT(2, 6), "Application not yet effective" },
  96         { EMV_BIT(2, 5), "Requested service not allowed for card product" },
  97         { EMV_BIT(2, 4), "New card" },
  98         { EMV_BIT(3, 8), "Cardholder verification was not successful" },
  99         { EMV_BIT(3, 7), "Unrecognised CVM" },
 100         { EMV_BIT(3, 6), "PIN Try Limit exceeded" },
 101         { EMV_BIT(3, 5), "PIN entry required and PIN pad not present or not working" },
 102         { EMV_BIT(3, 4), "PIN entry required, PIN pad present, but PIN was not entered" },
 103         { EMV_BIT(3, 3), "Online PIN entered" },
 104         { EMV_BIT(4, 8), "Transaction exceeds floor limit" },
 105         { EMV_BIT(4, 7), "Lower consecutive offline limit exceeded" },
 106         { EMV_BIT(4, 6), "Upper consecutive offline limit exceeded" },
 107         { EMV_BIT(4, 5), "Transaction selected randomly for online processing" },
 108         { EMV_BIT(4, 4), "Merchant forced transaction online" },
 109         { EMV_BIT(5, 8), "Default TDOL used" },
 110         { EMV_BIT(5, 7), "Issuer authentication failed" },
 111         { EMV_BIT(5, 6), "Script processing failed before final GENERATE AC" },
 112         { EMV_BIT(5, 5), "Script processing failed after final GENERATE AC" },
 113         { EMV_BIT(5, 4), "Reserved for use by the EMV Contactless Specifications" },
 114         { EMV_BIT(5, 3), "Reserved for use by the EMV Contactless Specifications" },
 115         { EMV_BIT(5, 2), "Reserved for use by the EMV Contactless Specifications" },
 116         { EMV_BIT(5, 1), "Reserved for use by the EMV Contactless Specifications" },
 117         EMV_BIT_FINISH,
 118 };
 119
 120 static const struct emv_tag_bit EMV_CTQ[] = {
 121         { EMV_BIT(1, 8), "Online PIN Required" },
 122         { EMV_BIT(1, 7), "Signature Required" },
 123         { EMV_BIT(1, 6), "Go Online if Offline Data Authentication Fails and Reader is online capable" },
 124         { EMV_BIT(1, 5), "Switch Interface if Offline Data Authentication fails and Reader supports VIS" },
 125         { EMV_BIT(1, 4), "Go Online if Application Expired" },
 126         { EMV_BIT(1, 3), "Switch Interface for Cash Transactions" },
 127         { EMV_BIT(1, 2), "Switch Interface for Cashback Transactions" },
 128         { EMV_BIT(2, 8), "Consumer Device CVM Performed" },
 129         { EMV_BIT(2, 7), "Card supports Issuer Update Processing at the POS" },
 130         EMV_BIT_FINISH,
 131 };
 132
 133 static const struct emv_tag_bit EMV_TTQ[] = {
 134         { EMV_BIT(1, 8), "MSD supported" },
 135         { EMV_BIT(1, 7), "VSDC supported" },
 136         { EMV_BIT(1, 6), "qVSDC supported" },
 137         { EMV_BIT(1, 5), "EMV contact chip supported" },
 138         { EMV_BIT(1, 4), "Offline-only reader" },
 139         { EMV_BIT(1, 3), "Online PIN supported" },
 140         { EMV_BIT(1, 2), "Signature supported" },
 141         { EMV_BIT(1, 1), "Offline Data Authentication (ODA) for Online Authorizations supported\nWarning!!!! Readers compliant to this specification set TTQ byte 1 bit 1 (this field) to 0b" },
 142         { EMV_BIT(2, 8), "Online cryptogram required" },
 143         { EMV_BIT(2, 7), "CVM required" },
 144         { EMV_BIT(2, 6), "(Contact Chip) Offline PIN supported" },
 145         { EMV_BIT(3, 8), "Issuer Update Processing supported" },
 146         { EMV_BIT(3, 7), "Mobile functionality supported (Consumer Device CVM)" },
 147         EMV_BIT_FINISH,
 148 };
 149
 150 static const struct emv_tag_bit EMV_CVR[] = {
 151         // mask 0F 0F F0 0F
 152         { EMV_BIT(1, 4), "CDA Performed" },
 153         { EMV_BIT(1, 3), "Offline DDA Performed" },
 154         { EMV_BIT(1, 2), "Issuer Authentication Not Performed" },
 155         { EMV_BIT(1, 1), "Issuer Authentication performed and Failed" },
 156         { EMV_BIT(2, 4), "Offline PIN Verification Performed" },
 157         { EMV_BIT(2, 3), "Offline PIN Verification Performed and PIN Not Successfully Verified" },
 158         { EMV_BIT(2, 2), "PIN Try Limit Exceeded" },
 159         { EMV_BIT(2, 1), "Last Online Transaction Not Completed" },
 160         { EMV_BIT(3, 8), "Lower Offline Transaction Count Limit Exceeded" },
 161         { EMV_BIT(3, 7), "Upper Offline Transaction Count Limit Exceeded" },
 162         { EMV_BIT(3, 6), "Lower Cumulative Offline Amount Limit Exceeded" },
 163         { EMV_BIT(3, 5), "Upper Cumulative Offline Amount Limit Exceeded" },
 164         { EMV_BIT(4, 4), "Issuer script processing failed on last transaction" },
 165         { EMV_BIT(4, 3), "Offline data authentication failed on previous transaction and transaction declined offline" },
 166         { EMV_BIT(4, 2), "Go Online on Next Transaction Was Set" },
 167         { EMV_BIT(4, 1), "Unable to go Online" },
 168         EMV_BIT_FINISH,
 169 };
 170
 171 // All Data Elements by Tags used in TLV structure (according to the EMV 4.2 Standard )
 172 // https://www.eftlab.co.uk/index.php/site-map/knowledge-base/145-emv-nfc-tags
 173 // http://dexterous-programmer.blogspot.in/2012/05/emv-tags.html
 174 static const struct emv_tag emv_tags[] = {
 175         // internal
 176         { 0x00  , "Unknown ???" },
 177         { 0x01  , "", EMV_TAG_STRING }, // string for headers
 178         { 0x02  , "Raw data", }, // data
 179         { 0x20  , "Cardholder Verification Results (CVR)", EMV_TAG_CVR }, // not standard!
 180
 181         // EMV
 182         { 0x41  , "Country code and national data" },
 183         { 0x42  , "Issuer Identification Number (IIN)" },
 184         { 0x4f  , "Application Dedicated File (ADF) Name" },
 185         { 0x50  , "Application Label", EMV_TAG_STRING },
 186         { 0x56  , "Track 1 Data" },
 187         { 0x57  , "Track 2 Equivalent Data" },
 188         { 0x5a  , "Application Primary Account Number (PAN)" },
 189         { 0x5f20, "Cardholder Name", EMV_TAG_STRING },
 190         { 0x5f24, "Application Expiration Date", EMV_TAG_YYMMDD },
 191         { 0x5f25, "Application Effective Date", EMV_TAG_YYMMDD },
 192         { 0x5f28, "Issuer Country Code", EMV_TAG_NUMERIC },
 193         { 0x5f2a, "Transaction Currency Code", EMV_TAG_NUMERIC },
 194         { 0x5f2d, "Language Preference", EMV_TAG_STRING },
 195         { 0x5f30, "Service Code", EMV_TAG_NUMERIC },
 196         { 0x5f34, "Application Primary Account Number (PAN) Sequence Number", EMV_TAG_NUMERIC },
 197         { 0x61  , "Application Template" },
 198         { 0x6f  , "File Control Information (FCI) Template" },
 199         { 0x70  , "READ RECORD Response Message Template" },
 200         { 0x77  , "Response Message Template Format 2" },
 201         { 0x80  , "Response Message Template Format 1" },
 202         { 0x82  , "Application Interchange Profile", EMV_TAG_BITMASK, &EMV_AIP },
 203         { 0x83  , "Command Template" },
 204         { 0x84  , "Dedicated File (DF) Name" },
 205         { 0x87  , "Application Priority Indicator" },
 206         { 0x88  , "Short File Identifier (SFI)" },
 207         { 0x8a  , "Authorisation Response Code" },
 208         { 0x8c  , "Card Risk Management Data Object List 1 (CDOL1)", EMV_TAG_DOL },
 209         { 0x8d  , "Card Risk Management Data Object List 2 (CDOL2)", EMV_TAG_DOL },
 210         { 0x8e  , "Cardholder Verification Method (CVM) List", EMV_TAG_CVM_LIST },
 211         { 0x8f  , "Certification Authority Public Key Index" },
 212         { 0x90  , "Issuer Public Key Certificate" },
 213         { 0x91  , "Issuer Authentication Data" },
 214         { 0x92  , "Issuer Public Key Remainder" },
 215         { 0x93  , "Signed Static Application Data" },
 216         { 0x94  , "Application File Locator (AFL)", EMV_TAG_AFL },
 217         { 0x95  , "Terminal Verification Results" },
 218         { 0x9a  , "Transaction Date", EMV_TAG_YYMMDD },
 219         { 0x9c  , "Transaction Type" },
 220         { 0x9f02, "Amount, Authorised (Numeric)", EMV_TAG_NUMERIC },
 221         { 0x9f03, "Amount, Other (Numeric)", EMV_TAG_NUMERIC, },
 222         { 0x9f06, "Application Identifier (AID), Terminal. ISO 7816-5" },
 223         { 0x9f07, "Application Usage Control", EMV_TAG_BITMASK, &EMV_AUC },
 224         { 0x9f08, "Application Version Number" },
 225         { 0x9f0d, "Issuer Action Code - Default", EMV_TAG_BITMASK, &EMV_TVR },
 226         { 0x9f0e, "Issuer Action Code - Denial", EMV_TAG_BITMASK, &EMV_TVR },
 227         { 0x9f0f, "Issuer Action Code - Online", EMV_TAG_BITMASK, &EMV_TVR },
 228         { 0x9f10, "Issuer Application Data" },
 229         { 0x9f11, "Issuer Code Table Index", EMV_TAG_NUMERIC },
 230         { 0x9f12, "Application Preferred Name", EMV_TAG_STRING },
 231         { 0x9f13, "Last Online Application Transaction Counter (ATC) Register" },
 232         { 0x9f17, "Personal Identification Number (PIN) Try Counter" },
 233         { 0x9f1a, "Terminal Country Code" },
 234         { 0x9f1f, "Track 1 Discretionary Data", EMV_TAG_STRING },
 235         { 0x9f21, "Transaction Time" },
 236         { 0x9f26, "Application Cryptogram" },
 237         { 0x9f27, "Cryptogram Information Data", EMV_TAG_CID },
 238         { 0x9f2a, "Kernel Identifier" },
 239         { 0x9f2d, "ICC PIN Encipherment Public Key Certificate" },
 240         { 0x9f2e, "ICC PIN Encipherment Public Key Exponent" },
 241         { 0x9f2f, "ICC PIN Encipherment Public Key Remainder" },
 242         { 0x9f32, "Issuer Public Key Exponent" },
 243         { 0x9f34, "Cardholder Verification Method (CVM) Results" },
 244         { 0x9f35, "Terminal Type" },
 245         { 0x9f36, "Application Transaction Counter (ATC)" },
 246         { 0x9f37, "Unpredictable Number" },
 247         { 0x9f38, "Processing Options Data Object List (PDOL)", EMV_TAG_DOL },
 248         { 0x9f42, "Application Currency Code", EMV_TAG_NUMERIC },
 249         { 0x9f44, "Application Currency Exponent", EMV_TAG_NUMERIC },
 250         { 0x9f45, "Data Authentication Code" },
 251         { 0x9f46, "ICC Public Key Certificate" },
 252         { 0x9f47, "ICC Public Key Exponent" },
 253         { 0x9f48, "ICC Public Key Remainder" },
 254         { 0x9f49, "Dynamic Data Authentication Data Object List (DDOL)", EMV_TAG_DOL },
 255         { 0x9f4a, "Static Data Authentication Tag List" },
 256         { 0x9f4b, "Signed Dynamic Application Data" },
 257         { 0x9f4c, "ICC Dynamic Number" },
 258         { 0x9f4d, "Log Entry" },
 259         { 0x9f4f, "Log Format", EMV_TAG_DOL },
 260         { 0x9f60, "CVC3 (Track1)" },
 261         { 0x9f61, "CVC3 (Track2)" },
 262         { 0x9f62, "PCVC3(Track1)" },
 263         { 0x9f63, "PUNATC(Track1)" },
 264         { 0x9f64, "NATC(Track1)" },
 265         { 0x9f65, "PCVC3(Track2)" },
 266         { 0x9f66, "PUNATC(Track2) / Terminal Transaction Qualifiers (TTQ)", EMV_TAG_BITMASK, &EMV_TTQ },
 267         { 0x9f67, "NATC(Track2) / MSD Offset" },
 268         { 0x9f69, "Card Authentication Related Data" },
 269         { 0x9f6a, "Unpredictable Number", EMV_TAG_NUMERIC },
 270         { 0x9f6b, "Track 2 Data" },
 271         { 0x9f6c, "Card Transaction Qualifiers (CTQ)", EMV_TAG_BITMASK, &EMV_CTQ },
 272         { 0xa5  , "File Control Information (FCI) Proprietary Template" },
 273         { 0xbf0c, "File Control Information (FCI) Issuer Discretionary Data" },
 274         { 0xdf20, "Issuer Proprietary Bitmap (IPB)" },
 275 };
 276
 277 static int emv_sort_tag(tlv_tag_t tag)
 278 {
 279         return (int)(tag >= 0x100 ? tag : tag << 8);
 280 }
 281
 282 static int emv_tlv_compare(const void *a, const void *b)
 283 {
 284         const struct tlv *tlv = a;
 285         const struct emv_tag *tag = b;
 286
 287         return emv_sort_tag(tlv->tag) - (emv_sort_tag(tag->tag));
 288 }
 289
 290 static const struct emv_tag *emv_get_tag(const struct tlv *tlv)
 291 {
 292         struct emv_tag *tag = bsearch(tlv, emv_tags, sizeof(emv_tags)/sizeof(emv_tags[0]),
 293                         sizeof(emv_tags[0]), emv_tlv_compare);
 294
 295         return tag ? tag : &emv_tags[0];
 296 }
 297
 298 static const char *bitstrings[] = {
 299         ".......1",
 300         "......1.",
 301         ".....1..",
 302         "....1...",
 303         "...1....",
 304         "..1.....",
 305         ".1......",
 306         "1.......",
 307 };
 308
 309 static void emv_tag_dump_bitmask(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level)
 310 {
 311         const struct emv_tag_bit *bits = tag->data;
 312         unsigned bit, byte;
 313
 314         for (byte = 1; byte <= tlv->len; byte ++) {
 315                 unsigned char val = tlv->value[byte - 1];
 316                 PRINT_INDENT(level);
 317                 fprintf(f, "\tByte %u (%02x)\n", byte, val);
 318                 for (bit = 8; bit > 0; bit--, val <<= 1) {
 319                         if (val & 0x80){
 320                                 PRINT_INDENT(level);
 321                                 fprintf(f, "\t\t%s - '%s'\n", bitstrings[bit - 1],
 322                                                 bits->bit == EMV_BIT(byte, bit) ? bits->name : "Unknown");
 323                         }
 324                         if (bits->bit == EMV_BIT(byte, bit))
 325                                 bits ++;
 326                 }
 327         }
 328 }
 329
 330 static void emv_tag_dump_dol(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level)
 331 {
 332         const unsigned char *buf = tlv->value;
 333         size_t left = tlv->len;
 334
 335         while (left) {
 336                 struct tlv doltlv;
 337                 const struct emv_tag *doltag;
 338
 339                 if (!tlv_parse_tl(&buf, &left, &doltlv)) {
 340                         PRINT_INDENT(level);
 341                         fprintf(f, "Invalid Tag-Len\n");
 342                         continue;
 343                 }
 344
 345                 doltag = emv_get_tag(&doltlv);
 346
 347                 PRINT_INDENT(level);
 348                 fprintf(f, "\tTag %4hx len %02zx ('%s')\n", doltlv.tag, doltlv.len, doltag->name);
 349         }
 350 }
 351
 352 static void emv_tag_dump_string(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level)
 353 {
 354         fprintf(f, "\tString value '");
 355         fwrite(tlv->value, 1, tlv->len, f);
 356         fprintf(f, "'\n");
 357 }
 358
 359 static unsigned long emv_value_numeric(const struct tlv *tlv, unsigned start, unsigned end)
 360 {
 361         unsigned long ret = 0;
 362         int i;
 363
 364         if (end > tlv->len * 2)
 365                 return ret;
 366         if (start >= end)
 367                 return ret;
 368
 369         if (start & 1) {
 370                 ret += tlv->value[start/2] & 0xf;
 371                 i = start + 1;
 372         } else
 373                 i = start;
 374
 375         for (; i < end - 1; i += 2) {
 376                 ret *= 10;
 377                 ret += tlv->value[i/2] >> 4;
 378                 ret *= 10;
 379                 ret += tlv->value[i/2] & 0xf;
 380         }
 381
 382         if (end & 1) {
 383                 ret *= 10;
 384                 ret += tlv->value[end/2] >> 4;
 385         }
 386
 387         return ret;
 388 }
 389
 390 static void emv_tag_dump_numeric(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level)
 391 {
 392         PRINT_INDENT(level);
 393         fprintf(f, "\tNumeric value %lu\n", emv_value_numeric(tlv, 0, tlv->len * 2));
 394 }
 395
 396 static void emv_tag_dump_yymmdd(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level)
 397 {
 398         PRINT_INDENT(level);
 399         fprintf(f, "\tDate: 20%02ld.%ld.%ld\n",
 400                         emv_value_numeric(tlv, 0, 2),
 401                         emv_value_numeric(tlv, 2, 4),
 402                         emv_value_numeric(tlv, 4, 6));
 403 }
 404
 405 static uint32_t emv_get_binary(const unsigned char *S)
 406 {
 407         return (S[0] << 24) | (S[1] << 16) | (S[2] << 8) | (S[3] << 0);
 408 }
 409
 410 // https://github.com/binaryfoo/emv-bertlv/blob/master/src/main/resources/fields/visa-cvr.txt
 411 static void emv_tag_dump_cvr(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) {
 412         if (!tlv || tlv->len < 1) {
 413                 PRINT_INDENT(level);
 414                 fprintf(f, "\tINVALID!\n");
 415                 return;
 416         }
 417
 418         if (tlv->len != tlv->value[0] + 1) {
 419                 PRINT_INDENT(level);
 420                 fprintf(f, "\tINVALID length!\n");
 421                 return;
 422         }
 423
 424         if (tlv->len >= 2) {
 425                 // AC1
 426                 PRINT_INDENT(level);
 427                 if ((tlv->value[1] & 0xC0) == 0x00)     fprintf(f, "\tAC1: AAC (Transaction declined)\n");
 428                 if ((tlv->value[1] & 0xC0) == 0x40)     fprintf(f, "\tAC1: TC (Transaction approved)\n");
 429                 if ((tlv->value[1] & 0xC0) == 0x80)     fprintf(f, "\tAC1: ARQC (Online authorisation requested)\n");
 430                 if ((tlv->value[1] & 0xC0) == 0xC0)     fprintf(f, "\tAC1: RFU\n");
 431                 // AC2
 432                 PRINT_INDENT(level);
 433                 if ((tlv->value[1] & 0x30) == 0x00)     fprintf(f, "\tAC2: AAC (Transaction declined)\n");
 434                 if ((tlv->value[1] & 0x30) == 0x10)     fprintf(f, "\tAC2: TC (Transaction approved)\n");
 435                 if ((tlv->value[1] & 0x30) == 0x20)     fprintf(f, "\tAC2: not requested (ARQC)\n");
 436                 if ((tlv->value[1] & 0x30) == 0x30)     fprintf(f, "\tAC2: RFU\n");
 437         }
 438         if (tlv->len >= 3 && (tlv->value[2] >> 4)) {
 439                 PRINT_INDENT(level);
 440                 fprintf(f, "\tPIN try: %x\n", tlv->value[2] >> 4);
 441         }
 442         if (tlv->len >= 4 && (tlv->value[3] & 0x0F)) {
 443                 PRINT_INDENT(level);
 444                 fprintf(f, "\tIssuer discretionary bits: %x\n", tlv->value[3] & 0x0F);
 445         }
 446         if (tlv->len >= 5 && (tlv->value[4] >> 4)) {
 447                 PRINT_INDENT(level);
 448                 fprintf(f, "\tSuccessfully processed issuer script commands: %x\n", tlv->value[4] >> 4);
 449         }
 450
 451         // mask 0F 0F F0 0F
 452         uint8_t data[20] = {0};
 453         memcpy(data, &tlv->value[1], tlv->len - 1);
 454         data[0] &= 0x0F;
 455         data[1] &= 0x0F;
 456         data[2] &= 0xF0;
 457         data[3] &= 0x0F;
 458         const struct tlv bit_tlv = {
 459                 .tag = tlv->tag,
 460                 .len = tlv->len - 1,
 461                 .value = data,
 462         };
 463         const struct emv_tag bit_tag = {
 464                 .tag = tag->tag,
 465                 .name = tag->name,
 466                 .type = EMV_TAG_BITMASK,
 467                 .data = EMV_CVR,
 468         };
 469
 470         if (data[0] || data[1] || data[2] || data[3])
 471                 emv_tag_dump_bitmask(&bit_tlv, &bit_tag, f, level);
 472
 473         return;
 474 }
 475
 476 // EMV Book 3
 477 static void emv_tag_dump_cid(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) {
 478         if (!tlv || tlv->len < 1) {
 479                 PRINT_INDENT(level);
 480                 fprintf(f, "\tINVALID!\n");
 481                 return;
 482         }
 483
 484         PRINT_INDENT(level);
 485         if ((tlv->value[0] & 0xC0) == 0x00)     fprintf(f, "\tAC1: AAC (Transaction declined)\n");
 486         if ((tlv->value[0] & 0xC0) == 0x40)     fprintf(f, "\tAC1: TC (Transaction approved)\n");
 487         if ((tlv->value[0] & 0xC0) == 0x80)     fprintf(f, "\tAC1: ARQC (Online authorisation requested)\n");
 488         if ((tlv->value[0] & 0xC0) == 0xC0)     fprintf(f, "\tAC1: RFU\n");
 489
 490         if ((tlv->value[0] & 0x08) != 0x00) {
 491                 PRINT_INDENT(level);
 492                 fprintf(f, "\tAdvice required!\n");
 493         }
 494
 495         if ((tlv->value[0] & 0x07) != 0x00) {
 496                 PRINT_INDENT(level);
 497                 fprintf(f, "\tReason/advice/referral code: ");
 498                 switch((tlv->value[0] & 0x07)) {
 499                         case 0:
 500                                 fprintf(f, "No information given\n");
 501                                 break;
 502                         case 1:
 503                                 fprintf(f, "Service not allowed\n");
 504                                 break;
 505                         case 2:
 506                                 fprintf(f, "PIN Try Limit exceeded\n");
 507                                 break;
 508                         case 3:
 509                                 fprintf(f, "Issuer authentication failed\n");
 510                                 break;
 511                         default:
 512                                 fprintf(f, "\tRFU: %2x\n", (tlv->value[0] & 0x07));
 513                                 break;
 514                 }
 515         }
 516
 517         return;
 518 }
 519
 520 static void emv_tag_dump_cvm_list(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level)
 521 {
 522         uint32_t X, Y;
 523         int i;
 524
 525         if (tlv->len < 10 || tlv->len % 2) {
 526                 PRINT_INDENT(level);
 527                 fprintf(f, "\tINVALID!\n");
 528                 return;
 529         }
 530
 531         X = emv_get_binary(tlv->value);
 532         Y = emv_get_binary(tlv->value + 4);
 533
 534         PRINT_INDENT(level);
 535         fprintf(f, "\tX: %d\n", X);
 536         PRINT_INDENT(level);
 537         fprintf(f, "\tY: %d\n", Y);
 538
 539         for (i = 8; i < tlv->len; i+= 2) {
 540                 const char *method;
 541                 const char *condition;
 542
 543                 switch (tlv->value[i] & 0x3f) {
 544                 case 0x0:
 545                         method = "Fail CVM processing";
 546                         break;
 547                 case 0x1:
 548                         method = "Plaintext PIN verification performed by ICC";
 549                         break;
 550                 case 0x2:
 551                         method = "Enciphered PIN verified online";
 552                         break;
 553                 case 0x3:
 554                         method = "Plaintext PIN verification performed by ICC and signature (paper)";
 555                         break;
 556                 case 0x4:
 557                         method = "Enciphered PIN verification performed by ICC";
 558                         break;
 559                 case 0x5:
 560                         method = "Enciphered PIN verification performed by ICC and signature (paper)";
 561                         break;
 562                 case 0x1e:
 563                         method = "Signature (paper)";
 564                         break;
 565                 case 0x1f:
 566                         method = "No CVM required";
 567                         break;
 568                 case 0x3f:
 569                         method = "NOT AVAILABLE!";
 570                         break;
 571                 default:
 572                         method = "Unknown";
 573                         break;
 574                 }
 575
 576                 switch (tlv->value[i+1]) {
 577                 case 0x00:
 578                         condition = "Always";
 579                         break;
 580                 case 0x01:
 581                         condition = "If unattended cash";
 582                         break;
 583                 case 0x02:
 584                         condition = "If not unattended cash and not manual cash and not purchase with cashback";
 585                         break;
 586                 case 0x03:
 587                         condition = "If terminal supports the CVM";
 588                         break;
 589                 case 0x04:
 590                         condition = "If manual cash";
 591                         break;
 592                 case 0x05:
 593                         condition = "If purchase with cashback";
 594                         break;
 595                 case 0x06:
 596                         condition = "If transaction is in the application currency and is under X value";
 597                         break;
 598                 case 0x07:
 599                         condition = "If transaction is in the application currency and is over X value";
 600                         break;
 601                 case 0x08:
 602                         condition = "If transaction is in the application currency and is under Y value";
 603                         break;
 604                 case 0x09:
 605                         condition = "If transaction is in the application currency and is over Y value";
 606                         break;
 607                 default:
 608                         condition = "Unknown";
 609                         break;
 610                 }
 611
 612                 PRINT_INDENT(level);
 613                 fprintf(f, "\t%02x %02x: '%s' '%s' and '%s' if this CVM is unsuccessful\n",
 614                                 tlv->value[i], tlv->value[i+1],
 615                                 method, condition, (tlv->value[i] & 0x40) ? "continue" : "fail");
 616         }
 617 }
 618
 619 static void emv_tag_dump_afl(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level){
 620         if (tlv->len < 4 || tlv->len % 4) {
 621                 PRINT_INDENT(level);
 622                 fprintf(f, "\tINVALID!\n");
 623                 return;
 624         }
 625
 626         for (int i = 0; i < tlv->len / 4; i++) {
 627                 PRINT_INDENT(level);
 628                 fprintf(f, "SFI[%02x] start:%02x end:%02x offline:%02x\n", tlv->value[i * 4 + 0] >> 3, tlv->value[i * 4 + 1], tlv->value[i * 4 + 2], tlv->value[i * 4 + 3]);
 629         }
 630 }
 631
 632 bool emv_tag_dump(const struct tlv *tlv, FILE *f, int level)
 633 {
 634         if (!tlv) {
 635                 fprintf(f, "NULL\n");
 636                 return false;
 637         }
 638
 639         const struct emv_tag *tag = emv_get_tag(tlv);
 640
 641         PRINT_INDENT(level);
 642         fprintf(f, "--%2hx[%02zx] '%s':", tlv->tag, tlv->len, tag->name);
 643
 644         switch (tag->type) {
 645         case EMV_TAG_GENERIC:
 646                 fprintf(f, "\n");
 647                 break;
 648         case EMV_TAG_BITMASK:
 649                 fprintf(f, "\n");
 650                 emv_tag_dump_bitmask(tlv, tag, f, level);
 651                 break;
 652         case EMV_TAG_DOL:
 653                 fprintf(f, "\n");
 654                 emv_tag_dump_dol(tlv, tag, f, level);
 655                 break;
 656         case EMV_TAG_CVM_LIST:
 657                 fprintf(f, "\n");
 658                 emv_tag_dump_cvm_list(tlv, tag, f, level);
 659                 break;
 660         case EMV_TAG_AFL:
 661                 fprintf(f, "\n");
 662                 emv_tag_dump_afl(tlv, tag, f, level);
 663                 break;
 664         case EMV_TAG_STRING:
 665                 emv_tag_dump_string(tlv, tag, f, level);
 666                 break;
 667         case EMV_TAG_NUMERIC:
 668                 emv_tag_dump_numeric(tlv, tag, f, level);
 669                 break;
 670         case EMV_TAG_YYMMDD:
 671                 emv_tag_dump_yymmdd(tlv, tag, f, level);
 672                 break;
 673         case EMV_TAG_CVR:
 674                 fprintf(f, "\n");
 675                 emv_tag_dump_cvr(tlv, tag, f, level);
 676                 break;
 677         case EMV_TAG_CID:
 678                 fprintf(f, "\n");
 679                 emv_tag_dump_cid(tlv, tag, f, level);
 680                 break;
 681         };
 682
 683         return true;
 684 }