]>
Commit | Line | Data |
---|---|---|
a2bb2735 | 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> | |
66efdc1f | 24 | #include <string.h> |
a2bb2735 | 25 | |
43912d63 | 26 | #define PRINT_INDENT(level) {for (int i = 0; i < (level); i++) fprintf(f, "\t");} |
27 | ||
a2bb2735 | 28 | enum emv_tag_t { |
29 | EMV_TAG_GENERIC, | |
30 | EMV_TAG_BITMASK, | |
31 | EMV_TAG_DOL, | |
32 | EMV_TAG_CVM_LIST, | |
3c5fce2b | 33 | EMV_TAG_AFL, |
a2bb2735 | 34 | EMV_TAG_STRING, |
35 | EMV_TAG_NUMERIC, | |
36 | EMV_TAG_YYMMDD, | |
66efdc1f | 37 | EMV_TAG_CVR, |
10d4f823 | 38 | EMV_TAG_CID, |
a2bb2735 | 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" }, | |
10d4f823 | 63 | { EMV_BIT(1, 1), "CDA supported (Combined Dynamic Data Authentication / Application Cryptogram Generation)" }, |
3c5fce2b | 64 | { EMV_BIT(2, 8), "MSD is supported (Magnetic Stripe Data)" }, |
a2bb2735 | 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 | ||
3c5fce2b OM |
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 | ||
66efdc1f | 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 | ||
3c5fce2b OM |
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 | |
a2bb2735 | 174 | static const struct emv_tag emv_tags[] = { |
66efdc1f | 175 | // internal |
a2bb2735 | 176 | { 0x00 , "Unknown ???" }, |
3c5fce2b | 177 | { 0x01 , "", EMV_TAG_STRING }, // string for headers |
66efdc1f | 178 | { 0x02 , "Raw data", }, // data |
179 | { 0x20 , "Cardholder Verification Results (CVR)", EMV_TAG_CVR }, // not standard! | |
180 | ||
181 | // EMV | |
3c5fce2b OM |
182 | { 0x41 , "Country code and national data" }, |
183 | { 0x42 , "Issuer Identification Number (IIN)" }, | |
a2bb2735 | 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" }, | |
23207d74 | 198 | { 0x6f , "File Control Information (FCI) Template" }, |
a2bb2735 | 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" }, | |
3c5fce2b | 216 | { 0x94 , "Application File Locator (AFL)", EMV_TAG_AFL }, |
a2bb2735 | 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, }, | |
3c5fce2b | 222 | { 0x9f06, "Application Identifier (AID), Terminal. ISO 7816-5" }, |
a2bb2735 | 223 | { 0x9f07, "Application Usage Control", EMV_TAG_BITMASK, &EMV_AUC }, |
224 | { 0x9f08, "Application Version Number" }, | |
5a1b25ac | 225 | { 0x9f0a, "Application Selection Registered Proprietary Data" }, // https://blog.ul-ts.com/posts/electronic-card-identifier-one-more-step-for-mif-compliance/ |
a2bb2735 | 226 | { 0x9f0d, "Issuer Action Code - Default", EMV_TAG_BITMASK, &EMV_TVR }, |
227 | { 0x9f0e, "Issuer Action Code - Denial", EMV_TAG_BITMASK, &EMV_TVR }, | |
228 | { 0x9f0f, "Issuer Action Code - Online", EMV_TAG_BITMASK, &EMV_TVR }, | |
229 | { 0x9f10, "Issuer Application Data" }, | |
230 | { 0x9f11, "Issuer Code Table Index", EMV_TAG_NUMERIC }, | |
231 | { 0x9f12, "Application Preferred Name", EMV_TAG_STRING }, | |
232 | { 0x9f13, "Last Online Application Transaction Counter (ATC) Register" }, | |
233 | { 0x9f17, "Personal Identification Number (PIN) Try Counter" }, | |
234 | { 0x9f1a, "Terminal Country Code" }, | |
235 | { 0x9f1f, "Track 1 Discretionary Data", EMV_TAG_STRING }, | |
236 | { 0x9f21, "Transaction Time" }, | |
237 | { 0x9f26, "Application Cryptogram" }, | |
10d4f823 | 238 | { 0x9f27, "Cryptogram Information Data", EMV_TAG_CID }, |
3c5fce2b | 239 | { 0x9f2a, "Kernel Identifier" }, |
a2bb2735 | 240 | { 0x9f2d, "ICC PIN Encipherment Public Key Certificate" }, |
241 | { 0x9f2e, "ICC PIN Encipherment Public Key Exponent" }, | |
242 | { 0x9f2f, "ICC PIN Encipherment Public Key Remainder" }, | |
243 | { 0x9f32, "Issuer Public Key Exponent" }, | |
244 | { 0x9f34, "Cardholder Verification Method (CVM) Results" }, | |
245 | { 0x9f35, "Terminal Type" }, | |
246 | { 0x9f36, "Application Transaction Counter (ATC)" }, | |
247 | { 0x9f37, "Unpredictable Number" }, | |
248 | { 0x9f38, "Processing Options Data Object List (PDOL)", EMV_TAG_DOL }, | |
249 | { 0x9f42, "Application Currency Code", EMV_TAG_NUMERIC }, | |
250 | { 0x9f44, "Application Currency Exponent", EMV_TAG_NUMERIC }, | |
251 | { 0x9f45, "Data Authentication Code" }, | |
252 | { 0x9f46, "ICC Public Key Certificate" }, | |
253 | { 0x9f47, "ICC Public Key Exponent" }, | |
254 | { 0x9f48, "ICC Public Key Remainder" }, | |
255 | { 0x9f49, "Dynamic Data Authentication Data Object List (DDOL)", EMV_TAG_DOL }, | |
256 | { 0x9f4a, "Static Data Authentication Tag List" }, | |
257 | { 0x9f4b, "Signed Dynamic Application Data" }, | |
258 | { 0x9f4c, "ICC Dynamic Number" }, | |
259 | { 0x9f4d, "Log Entry" }, | |
260 | { 0x9f4f, "Log Format", EMV_TAG_DOL }, | |
66efdc1f | 261 | { 0x9f60, "CVC3 (Track1)" }, |
262 | { 0x9f61, "CVC3 (Track2)" }, | |
a2bb2735 | 263 | { 0x9f62, "PCVC3(Track1)" }, |
264 | { 0x9f63, "PUNATC(Track1)" }, | |
265 | { 0x9f64, "NATC(Track1)" }, | |
266 | { 0x9f65, "PCVC3(Track2)" }, | |
3c5fce2b OM |
267 | { 0x9f66, "PUNATC(Track2) / Terminal Transaction Qualifiers (TTQ)", EMV_TAG_BITMASK, &EMV_TTQ }, |
268 | { 0x9f67, "NATC(Track2) / MSD Offset" }, | |
269 | { 0x9f69, "Card Authentication Related Data" }, | |
270 | { 0x9f6a, "Unpredictable Number", EMV_TAG_NUMERIC }, | |
a2bb2735 | 271 | { 0x9f6b, "Track 2 Data" }, |
3c5fce2b | 272 | { 0x9f6c, "Card Transaction Qualifiers (CTQ)", EMV_TAG_BITMASK, &EMV_CTQ }, |
a2bb2735 | 273 | { 0xa5 , "File Control Information (FCI) Proprietary Template" }, |
274 | { 0xbf0c, "File Control Information (FCI) Issuer Discretionary Data" }, | |
f7ec230e | 275 | { 0xdf20, "Issuer Proprietary Bitmap (IPB)" }, |
a2bb2735 | 276 | }; |
277 | ||
278 | static int emv_sort_tag(tlv_tag_t tag) | |
279 | { | |
280 | return (int)(tag >= 0x100 ? tag : tag << 8); | |
281 | } | |
282 | ||
283 | static int emv_tlv_compare(const void *a, const void *b) | |
284 | { | |
285 | const struct tlv *tlv = a; | |
286 | const struct emv_tag *tag = b; | |
287 | ||
288 | return emv_sort_tag(tlv->tag) - (emv_sort_tag(tag->tag)); | |
289 | } | |
290 | ||
291 | static const struct emv_tag *emv_get_tag(const struct tlv *tlv) | |
292 | { | |
293 | struct emv_tag *tag = bsearch(tlv, emv_tags, sizeof(emv_tags)/sizeof(emv_tags[0]), | |
294 | sizeof(emv_tags[0]), emv_tlv_compare); | |
295 | ||
296 | return tag ? tag : &emv_tags[0]; | |
297 | } | |
298 | ||
299 | static const char *bitstrings[] = { | |
300 | ".......1", | |
301 | "......1.", | |
302 | ".....1..", | |
303 | "....1...", | |
304 | "...1....", | |
305 | "..1.....", | |
306 | ".1......", | |
307 | "1.......", | |
308 | }; | |
309 | ||
43912d63 | 310 | static void emv_tag_dump_bitmask(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) |
a2bb2735 | 311 | { |
312 | const struct emv_tag_bit *bits = tag->data; | |
313 | unsigned bit, byte; | |
314 | ||
315 | for (byte = 1; byte <= tlv->len; byte ++) { | |
316 | unsigned char val = tlv->value[byte - 1]; | |
43912d63 | 317 | PRINT_INDENT(level); |
a2bb2735 | 318 | fprintf(f, "\tByte %u (%02x)\n", byte, val); |
319 | for (bit = 8; bit > 0; bit--, val <<= 1) { | |
3c5fce2b | 320 | if (val & 0x80){ |
43912d63 | 321 | PRINT_INDENT(level); |
a2bb2735 | 322 | fprintf(f, "\t\t%s - '%s'\n", bitstrings[bit - 1], |
323 | bits->bit == EMV_BIT(byte, bit) ? bits->name : "Unknown"); | |
3c5fce2b | 324 | } |
a2bb2735 | 325 | if (bits->bit == EMV_BIT(byte, bit)) |
326 | bits ++; | |
327 | } | |
328 | } | |
329 | } | |
330 | ||
43912d63 | 331 | static void emv_tag_dump_dol(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) |
a2bb2735 | 332 | { |
333 | const unsigned char *buf = tlv->value; | |
334 | size_t left = tlv->len; | |
335 | ||
336 | while (left) { | |
337 | struct tlv doltlv; | |
338 | const struct emv_tag *doltag; | |
339 | ||
340 | if (!tlv_parse_tl(&buf, &left, &doltlv)) { | |
43912d63 | 341 | PRINT_INDENT(level); |
a2bb2735 | 342 | fprintf(f, "Invalid Tag-Len\n"); |
343 | continue; | |
344 | } | |
345 | ||
346 | doltag = emv_get_tag(&doltlv); | |
347 | ||
43912d63 | 348 | PRINT_INDENT(level); |
a2bb2735 | 349 | fprintf(f, "\tTag %4hx len %02zx ('%s')\n", doltlv.tag, doltlv.len, doltag->name); |
350 | } | |
351 | } | |
352 | ||
43912d63 | 353 | static void emv_tag_dump_string(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) |
a2bb2735 | 354 | { |
355 | fprintf(f, "\tString value '"); | |
356 | fwrite(tlv->value, 1, tlv->len, f); | |
357 | fprintf(f, "'\n"); | |
358 | } | |
359 | ||
360 | static unsigned long emv_value_numeric(const struct tlv *tlv, unsigned start, unsigned end) | |
361 | { | |
362 | unsigned long ret = 0; | |
363 | int i; | |
364 | ||
365 | if (end > tlv->len * 2) | |
366 | return ret; | |
367 | if (start >= end) | |
368 | return ret; | |
369 | ||
370 | if (start & 1) { | |
371 | ret += tlv->value[start/2] & 0xf; | |
372 | i = start + 1; | |
373 | } else | |
374 | i = start; | |
375 | ||
376 | for (; i < end - 1; i += 2) { | |
377 | ret *= 10; | |
378 | ret += tlv->value[i/2] >> 4; | |
379 | ret *= 10; | |
380 | ret += tlv->value[i/2] & 0xf; | |
381 | } | |
382 | ||
383 | if (end & 1) { | |
384 | ret *= 10; | |
385 | ret += tlv->value[end/2] >> 4; | |
386 | } | |
387 | ||
388 | return ret; | |
389 | } | |
390 | ||
43912d63 | 391 | static void emv_tag_dump_numeric(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) |
a2bb2735 | 392 | { |
43912d63 | 393 | PRINT_INDENT(level); |
a2bb2735 | 394 | fprintf(f, "\tNumeric value %lu\n", emv_value_numeric(tlv, 0, tlv->len * 2)); |
395 | } | |
396 | ||
43912d63 | 397 | static void emv_tag_dump_yymmdd(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) |
a2bb2735 | 398 | { |
43912d63 | 399 | PRINT_INDENT(level); |
a2bb2735 | 400 | fprintf(f, "\tDate: 20%02ld.%ld.%ld\n", |
401 | emv_value_numeric(tlv, 0, 2), | |
402 | emv_value_numeric(tlv, 2, 4), | |
403 | emv_value_numeric(tlv, 4, 6)); | |
404 | } | |
405 | ||
406 | static uint32_t emv_get_binary(const unsigned char *S) | |
407 | { | |
408 | return (S[0] << 24) | (S[1] << 16) | (S[2] << 8) | (S[3] << 0); | |
409 | } | |
410 | ||
66efdc1f | 411 | // https://github.com/binaryfoo/emv-bertlv/blob/master/src/main/resources/fields/visa-cvr.txt |
412 | static void emv_tag_dump_cvr(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) { | |
413 | if (!tlv || tlv->len < 1) { | |
414 | PRINT_INDENT(level); | |
415 | fprintf(f, "\tINVALID!\n"); | |
416 | return; | |
417 | } | |
418 | ||
419 | if (tlv->len != tlv->value[0] + 1) { | |
420 | PRINT_INDENT(level); | |
421 | fprintf(f, "\tINVALID length!\n"); | |
422 | return; | |
423 | } | |
424 | ||
425 | if (tlv->len >= 2) { | |
426 | // AC1 | |
427 | PRINT_INDENT(level); | |
428 | if ((tlv->value[1] & 0xC0) == 0x00) fprintf(f, "\tAC1: AAC (Transaction declined)\n"); | |
429 | if ((tlv->value[1] & 0xC0) == 0x40) fprintf(f, "\tAC1: TC (Transaction approved)\n"); | |
430 | if ((tlv->value[1] & 0xC0) == 0x80) fprintf(f, "\tAC1: ARQC (Online authorisation requested)\n"); | |
431 | if ((tlv->value[1] & 0xC0) == 0xC0) fprintf(f, "\tAC1: RFU\n"); | |
432 | // AC2 | |
433 | PRINT_INDENT(level); | |
434 | if ((tlv->value[1] & 0x30) == 0x00) fprintf(f, "\tAC2: AAC (Transaction declined)\n"); | |
435 | if ((tlv->value[1] & 0x30) == 0x10) fprintf(f, "\tAC2: TC (Transaction approved)\n"); | |
436 | if ((tlv->value[1] & 0x30) == 0x20) fprintf(f, "\tAC2: not requested (ARQC)\n"); | |
437 | if ((tlv->value[1] & 0x30) == 0x30) fprintf(f, "\tAC2: RFU\n"); | |
438 | } | |
439 | if (tlv->len >= 3 && (tlv->value[2] >> 4)) { | |
440 | PRINT_INDENT(level); | |
441 | fprintf(f, "\tPIN try: %x\n", tlv->value[2] >> 4); | |
442 | } | |
443 | if (tlv->len >= 4 && (tlv->value[3] & 0x0F)) { | |
444 | PRINT_INDENT(level); | |
445 | fprintf(f, "\tIssuer discretionary bits: %x\n", tlv->value[3] & 0x0F); | |
446 | } | |
447 | if (tlv->len >= 5 && (tlv->value[4] >> 4)) { | |
448 | PRINT_INDENT(level); | |
449 | fprintf(f, "\tSuccessfully processed issuer script commands: %x\n", tlv->value[4] >> 4); | |
450 | } | |
451 | ||
452 | // mask 0F 0F F0 0F | |
453 | uint8_t data[20] = {0}; | |
454 | memcpy(data, &tlv->value[1], tlv->len - 1); | |
455 | data[0] &= 0x0F; | |
456 | data[1] &= 0x0F; | |
457 | data[2] &= 0xF0; | |
458 | data[3] &= 0x0F; | |
459 | const struct tlv bit_tlv = { | |
460 | .tag = tlv->tag, | |
461 | .len = tlv->len - 1, | |
462 | .value = data, | |
463 | }; | |
464 | const struct emv_tag bit_tag = { | |
465 | .tag = tag->tag, | |
466 | .name = tag->name, | |
467 | .type = EMV_TAG_BITMASK, | |
468 | .data = EMV_CVR, | |
469 | }; | |
470 | ||
471 | if (data[0] || data[1] || data[2] || data[3]) | |
472 | emv_tag_dump_bitmask(&bit_tlv, &bit_tag, f, level); | |
473 | ||
474 | return; | |
475 | } | |
476 | ||
10d4f823 | 477 | // EMV Book 3 |
478 | static void emv_tag_dump_cid(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) { | |
479 | if (!tlv || tlv->len < 1) { | |
480 | PRINT_INDENT(level); | |
481 | fprintf(f, "\tINVALID!\n"); | |
482 | return; | |
483 | } | |
484 | ||
485 | PRINT_INDENT(level); | |
7a7afeba | 486 | if ((tlv->value[0] & EMVAC_AC_MASK) == EMVAC_AAC) fprintf(f, "\tAC1: AAC (Transaction declined)\n"); |
487 | if ((tlv->value[0] & EMVAC_AC_MASK) == EMVAC_TC) fprintf(f, "\tAC1: TC (Transaction approved)\n"); | |
488 | if ((tlv->value[0] & EMVAC_AC_MASK) == EMVAC_ARQC) fprintf(f, "\tAC1: ARQC (Online authorisation requested)\n"); | |
489 | if ((tlv->value[0] & EMVAC_AC_MASK) == EMVAC_AC_MASK) fprintf(f, "\tAC1: RFU\n"); | |
10d4f823 | 490 | |
7a7afeba | 491 | if (tlv->value[0] & EMVCID_ADVICE) { |
10d4f823 | 492 | PRINT_INDENT(level); |
493 | fprintf(f, "\tAdvice required!\n"); | |
494 | } | |
495 | ||
7a7afeba | 496 | if (tlv->value[0] & EMVCID_REASON_MASK) { |
10d4f823 | 497 | PRINT_INDENT(level); |
498 | fprintf(f, "\tReason/advice/referral code: "); | |
7a7afeba | 499 | switch((tlv->value[0] & EMVCID_REASON_MASK)) { |
10d4f823 | 500 | case 0: |
501 | fprintf(f, "No information given\n"); | |
502 | break; | |
503 | case 1: | |
504 | fprintf(f, "Service not allowed\n"); | |
505 | break; | |
506 | case 2: | |
507 | fprintf(f, "PIN Try Limit exceeded\n"); | |
508 | break; | |
509 | case 3: | |
510 | fprintf(f, "Issuer authentication failed\n"); | |
511 | break; | |
512 | default: | |
7a7afeba | 513 | fprintf(f, "\tRFU: %2x\n", (tlv->value[0] & EMVCID_REASON_MASK)); |
10d4f823 | 514 | break; |
515 | } | |
516 | } | |
517 | ||
518 | return; | |
519 | } | |
520 | ||
43912d63 | 521 | static void emv_tag_dump_cvm_list(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level) |
a2bb2735 | 522 | { |
523 | uint32_t X, Y; | |
524 | int i; | |
525 | ||
526 | if (tlv->len < 10 || tlv->len % 2) { | |
43912d63 | 527 | PRINT_INDENT(level); |
a2bb2735 | 528 | fprintf(f, "\tINVALID!\n"); |
529 | return; | |
530 | } | |
531 | ||
532 | X = emv_get_binary(tlv->value); | |
533 | Y = emv_get_binary(tlv->value + 4); | |
534 | ||
43912d63 | 535 | PRINT_INDENT(level); |
a2bb2735 | 536 | fprintf(f, "\tX: %d\n", X); |
43912d63 | 537 | PRINT_INDENT(level); |
a2bb2735 | 538 | fprintf(f, "\tY: %d\n", Y); |
539 | ||
540 | for (i = 8; i < tlv->len; i+= 2) { | |
541 | const char *method; | |
542 | const char *condition; | |
543 | ||
544 | switch (tlv->value[i] & 0x3f) { | |
545 | case 0x0: | |
546 | method = "Fail CVM processing"; | |
547 | break; | |
548 | case 0x1: | |
549 | method = "Plaintext PIN verification performed by ICC"; | |
550 | break; | |
551 | case 0x2: | |
552 | method = "Enciphered PIN verified online"; | |
553 | break; | |
554 | case 0x3: | |
555 | method = "Plaintext PIN verification performed by ICC and signature (paper)"; | |
556 | break; | |
557 | case 0x4: | |
558 | method = "Enciphered PIN verification performed by ICC"; | |
559 | break; | |
560 | case 0x5: | |
561 | method = "Enciphered PIN verification performed by ICC and signature (paper)"; | |
562 | break; | |
563 | case 0x1e: | |
564 | method = "Signature (paper)"; | |
565 | break; | |
566 | case 0x1f: | |
567 | method = "No CVM required"; | |
568 | break; | |
569 | case 0x3f: | |
570 | method = "NOT AVAILABLE!"; | |
571 | break; | |
572 | default: | |
573 | method = "Unknown"; | |
574 | break; | |
575 | } | |
576 | ||
577 | switch (tlv->value[i+1]) { | |
578 | case 0x00: | |
579 | condition = "Always"; | |
580 | break; | |
581 | case 0x01: | |
582 | condition = "If unattended cash"; | |
583 | break; | |
584 | case 0x02: | |
585 | condition = "If not unattended cash and not manual cash and not purchase with cashback"; | |
586 | break; | |
587 | case 0x03: | |
588 | condition = "If terminal supports the CVM"; | |
589 | break; | |
590 | case 0x04: | |
591 | condition = "If manual cash"; | |
592 | break; | |
593 | case 0x05: | |
594 | condition = "If purchase with cashback"; | |
595 | break; | |
596 | case 0x06: | |
597 | condition = "If transaction is in the application currency and is under X value"; | |
598 | break; | |
599 | case 0x07: | |
600 | condition = "If transaction is in the application currency and is over X value"; | |
601 | break; | |
602 | case 0x08: | |
603 | condition = "If transaction is in the application currency and is under Y value"; | |
604 | break; | |
605 | case 0x09: | |
606 | condition = "If transaction is in the application currency and is over Y value"; | |
607 | break; | |
608 | default: | |
609 | condition = "Unknown"; | |
610 | break; | |
611 | } | |
612 | ||
43912d63 | 613 | PRINT_INDENT(level); |
a2bb2735 | 614 | fprintf(f, "\t%02x %02x: '%s' '%s' and '%s' if this CVM is unsuccessful\n", |
615 | tlv->value[i], tlv->value[i+1], | |
616 | method, condition, (tlv->value[i] & 0x40) ? "continue" : "fail"); | |
617 | } | |
618 | } | |
619 | ||
3c5fce2b OM |
620 | static void emv_tag_dump_afl(const struct tlv *tlv, const struct emv_tag *tag, FILE *f, int level){ |
621 | if (tlv->len < 4 || tlv->len % 4) { | |
622 | PRINT_INDENT(level); | |
623 | fprintf(f, "\tINVALID!\n"); | |
624 | return; | |
625 | } | |
626 | ||
627 | for (int i = 0; i < tlv->len / 4; i++) { | |
628 | PRINT_INDENT(level); | |
629 | 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]); | |
630 | } | |
631 | } | |
632 | ||
43912d63 | 633 | bool emv_tag_dump(const struct tlv *tlv, FILE *f, int level) |
a2bb2735 | 634 | { |
635 | if (!tlv) { | |
636 | fprintf(f, "NULL\n"); | |
637 | return false; | |
638 | } | |
639 | ||
640 | const struct emv_tag *tag = emv_get_tag(tlv); | |
641 | ||
43912d63 | 642 | PRINT_INDENT(level); |
3c5fce2b | 643 | fprintf(f, "--%2hx[%02zx] '%s':", tlv->tag, tlv->len, tag->name); |
a2bb2735 | 644 | |
645 | switch (tag->type) { | |
646 | case EMV_TAG_GENERIC: | |
3c5fce2b | 647 | fprintf(f, "\n"); |
a2bb2735 | 648 | break; |
649 | case EMV_TAG_BITMASK: | |
3c5fce2b | 650 | fprintf(f, "\n"); |
43912d63 | 651 | emv_tag_dump_bitmask(tlv, tag, f, level); |
a2bb2735 | 652 | break; |
653 | case EMV_TAG_DOL: | |
3c5fce2b | 654 | fprintf(f, "\n"); |
43912d63 | 655 | emv_tag_dump_dol(tlv, tag, f, level); |
a2bb2735 | 656 | break; |
657 | case EMV_TAG_CVM_LIST: | |
3c5fce2b | 658 | fprintf(f, "\n"); |
43912d63 | 659 | emv_tag_dump_cvm_list(tlv, tag, f, level); |
a2bb2735 | 660 | break; |
3c5fce2b OM |
661 | case EMV_TAG_AFL: |
662 | fprintf(f, "\n"); | |
663 | emv_tag_dump_afl(tlv, tag, f, level); | |
664 | break; | |
a2bb2735 | 665 | case EMV_TAG_STRING: |
43912d63 | 666 | emv_tag_dump_string(tlv, tag, f, level); |
a2bb2735 | 667 | break; |
668 | case EMV_TAG_NUMERIC: | |
43912d63 | 669 | emv_tag_dump_numeric(tlv, tag, f, level); |
a2bb2735 | 670 | break; |
671 | case EMV_TAG_YYMMDD: | |
43912d63 | 672 | emv_tag_dump_yymmdd(tlv, tag, f, level); |
a2bb2735 | 673 | break; |
66efdc1f | 674 | case EMV_TAG_CVR: |
675 | fprintf(f, "\n"); | |
676 | emv_tag_dump_cvr(tlv, tag, f, level); | |
677 | break; | |
10d4f823 | 678 | case EMV_TAG_CID: |
679 | fprintf(f, "\n"); | |
680 | emv_tag_dump_cid(tlv, tag, f, level); | |
681 | break; | |
a2bb2735 | 682 | }; |
683 | ||
684 | return true; | |
685 | } |