9206d3b0 |
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, ¤tcard->SAK1, false); |
1566 | DUMP(currentcard->SAK2); |
1567 | Dbhexdump(1, ¤tcard->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 | |