1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2019, Joyent, Inc.
14 */
15
16 /*
17 * ATR parsing routines shared between userland (ccidadm) and the kernel (CCID
18 * driver)
19 */
20
21 #include "atr.h"
22 #include <sys/debug.h>
23 #include <sys/sysmacros.h>
24
25 #ifdef _KERNEL
26 #include <sys/inttypes.h>
27 #include <sys/sunddi.h>
28 #include <sys/kmem.h>
29 #else
30 #include <inttypes.h>
31 #include <strings.h>
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <ctype.h>
35 #endif
36
37 /*
38 * The ATR must have at least 2 bytes and then may have up to 33 bytes. The
39 * first byte is always TS and the second required byte is T0.
40 */
41 #define ATR_TS_IDX 0
42 #define ATR_T0_IDX 1
43
44 /*
45 * There are two valid values for TS. It must either be 0x3F or 0x3B. This is
46 * required per ISO/IEC 7816-3:2006 section 8.1.
47 */
48 #define ATR_TS_INVERSE 0x3F
49 #define ATR_TS_DIRECT 0x3B
50
51 /*
52 * After TS, each word is used to indicate a combination of protocol and the
53 * number of bits defined for that protocol. The lower nibble is treated as the
54 * protocol. The upper nibble is treated to indicate which of four defined words
55 * are present. These are usually referred to as TA, TB, TC, and TD. TD is
56 * always used to indicate the next protocol and the number of bytes present for
57 * that. T0 works in a similar way, except that it defines the number of
58 * historical bytes present in its protocol section and then it refers to a set
59 * of pre-defined global bytes that may be present.
60 */
61 #define ATR_TD_PROT(x) ((x) & 0x0f)
62 #define ATR_TD_NBITS(x) (((x) & 0xf0) >> 4)
63 #define ATR_TA_MASK 0x1
64 #define ATR_TB_MASK 0x2
65 #define ATR_TC_MASK 0x4
66 #define ATR_TD_MASK 0x8
67
68 #define ATR_TA1_FTABLE(x) (((x) & 0xf0) >> 4)
69 #define ATR_TA1_DITABLE(x) ((x) & 0x0f)
70
71 #define ATR_TA2_CANCHANGE(x) (((x) & 0x80) == 0)
72 #define ATR_TA2_HONORTA1(x) (((x) & 0x10) == 0)
73 #define ATR_TA2_PROTOCOL(x) ((x) & 0x0f)
74
75 /*
76 * When the checksum is required in the ATR, each byte must XOR to zero.
77 */
78 #define ATR_CKSUM_TARGET 0
79
80 /*
81 * Maximum number of historic ATR bytes. This is limited by the fact that it's a
82 * 4-bit nibble.
83 */
84 #define ATR_HISTORICAL_MAX 15
85
86 /*
87 * The maximum number of TA, TB, TC, and TD levels that can be encountered in a
88 * given structure. In the best case, there are 30 bytes available (TS, T0, and
89 * TCK use the others). Given that each one of these needs 4 bytes to be
90 * represented, the maximum number of layers that can fit is seven.
91 */
92 #define ATR_TI_MAX 7
93
94 /*
95 * Defined protocol values. See ISO/IEC 7816-3:2006 8.2.3 for this list.
96 * Reserved values are noted but not defined.
97 */
98 #define ATR_PROTOCOL_T0 0
99 #define ATR_PROTOCOL_T1 1
100
101 #define ATR_T1_TB0_CWI(x) ((x) & 0x0f)
102 #define ATR_T1_TB0_BWI(x) (((x) & 0xf0) >> 4)
103 #define ATR_T1_TC0_CRC(x) (((x) & 0x01) != 0)
104
105 /*
106 * T=2 and T=3 are reserved for future full-duplex operation.
107 * T=4 is reserved for enhanced half-duplex character transmission.
108 * T=5-13 are reserved for future use by ISO/IEC JTC 1/SC 17.
109 * T=14 is for protocols not standardized by ISO/IEC JTC 1/SC 17.
110 */
111 #define ATR_PROTOCOL_T15 15
112
113 #define ATR_T15_TA0_CLOCK(x) (((x) & 0xc0) >> 6)
114 #define ATR_T15_TA0_VOLTAGE(x) ((x) & 0x3f)
115
116 #define ATR_T15_TB0_SPU_STANDARD(x) (((x & 0x80)) != 0)
117
118 /*
119 * Various definitions for the configuration of historical data. This comes from
120 * ISO/IEC 7816-4:2013 Section 12.1.1.
121 */
122
123 /*
124 * The first historical byte is used to indicate the encoding of the data. Only
125 * values 0x00, 0x80-0x8f are defined. All others are proprietary. 0x81-0x8f are
126 * reserved for future use.
127 */
128 #define ATR_HIST_CAT_MAND_STATUS 0x00
129 #define ATR_HIST_CAT_TLV_STATUS 0x80
130 #define ATR_HIST_CAT_RFU_MIN 0x81
131 #define ATR_HIST_CAT_RFU_MAX 0x8f
132
133 /*
134 * From ISO/IEC 7816-3:2006 Section 8.3.
135 *
136 * The default value for Fi is 372 which is table entry 1. The default value for
137 * Di is 1, which is table entry 1.
138 */
139 #define ATR_FI_DEFAULT_INDEX 1
140 #define ATR_DI_DEFAULT_INDEX 1
141 #define ATR_EXTRA_GUARDTIME_DEFAULT 0
142
143 /*
144 * From ISO/IEC 7816-3:2006 Section 10.2.
145 */
146 #define ATR_T0_WI_DEFAULT 10
147
148 /*
149 * From ISO/IEC 7816-3:2006 Section 11.4.3.
150 */
151 #define ATR_T1_CWI_DEFAULT 13
152
153 /*
154 * From ISO/IEC 7816-3:2006 Section 11.4.3.
155 */
156 #define ATR_T1_BWI_DEFAULT 4
157
158 /*
159 * From ISO/IEC 7816-3:2006 Section 11.4.2.
160 */
161 #define ATR_T1_IFSC_DEFAULT 32
162
163 /*
164 * From ISO/IEC 7816-3:2006 Section 11.4.4
165 */
166 #define ATR_T1_CHECKSUM_DEFAULT ATR_T1_CHECKSUM_LRC
167
168 /*
169 * Definitions for PPS construction. These are derived from ISO/IEC 7816-3:2006
170 * section 9, Protocol and parameters selection.
171 */
172 #define PPS_LEN_MIN 3 /* PPSS, PPS0, PCK */
173 #define PPS_LEN_MAX PPS_BUFFER_MAX
174 #define PPS_PPSS_INDEX 0
175 #define PPS_PPSS_VAL 0xff
176 #define PPS_PPS0_INDEX 0x01
177 #define PPS_PPS0_PROT(x) ((x) & 0x0f)
178 #define PPS_PPS0_PPS1 (1 << 4)
179 #define PPS_PPS0_PPS2 (1 << 5)
180 #define PPS_PPS0_PPS3 (1 << 6)
181 #define PPS_PPS1_SETVAL(f, d) ((((f) & 0x0f) << 4) | ((d) & 0x0f))
182
183 /*
184 * This enum and subsequent structure is used to represent a single level of
185 * 'T'. This includes the possibility for all three values to be set and records
186 * the protocol.
187 */
188 typedef enum atr_ti_flags {
189 ATR_TI_HAVE_TA = 1 << 0,
190 ATR_TI_HAVE_TB = 1 << 1,
191 ATR_TI_HAVE_TC = 1 << 2,
192 ATR_TI_HAVE_TD = 1 << 3
193 } atr_ti_flags_t;
194
195 typedef struct atr_ti {
196 uint8_t atrti_protocol;
197 uint8_t atrti_ti_val;
198 uint8_t atrti_td_idx;
199 atr_ti_flags_t atrti_flags;
200 uint8_t atrti_ta;
201 uint8_t atrti_tb;
202 uint8_t atrti_tc;
203 uint8_t atrti_td;
204 } atr_ti_t;
205
206 typedef enum atr_flags {
207 ATR_F_USES_DIRECT = 1 << 0,
208 ATR_F_USES_INVERSE = 1 << 1,
209 ATR_F_HAS_CHECKSUM = 1 << 2,
210 ATR_F_VALID = 1 << 3
211 } atr_flags_t;
212
213
214 struct atr_data {
215 atr_flags_t atr_flags;
216 uint8_t atr_nti;
217 atr_ti_t atr_ti[ATR_TI_MAX];
218 uint8_t atr_nhistoric;
219 uint8_t atr_historic[ATR_HISTORICAL_MAX];
220 uint8_t atr_cksum;
221 uint8_t atr_raw[ATR_LEN_MAX];
222 uint8_t atr_nraw;
223 };
224
225 /*
226 * These tables maps the bit values for Fi from 7816-3:2006 section 8.3 Table 7.
227 */
228 static uint_t atr_fi_valtable[16] = {
229 372, /* 0000 */
230 372, /* 0001 */
231 558, /* 0010 */
232 744, /* 0011 */
233 1116, /* 0100 */
234 1488, /* 0101 */
235 1860, /* 0110 */
236 0, /* 0111 */
237 0, /* 1000 */
238 512, /* 1001 */
239 768, /* 1010 */
240 1024, /* 1011 */
241 1536, /* 1100 */
242 2048, /* 1101 */
243 0, /* 1110 */
244 0 /* 1111 */
245 };
246
247 static const char *atr_fi_table[16] = {
248 "372", /* 0000 */
249 "372", /* 0001 */
250 "558", /* 0010 */
251 "744", /* 0011 */
252 "1116", /* 0100 */
253 "1488", /* 0101 */
254 "1860", /* 0110 */
255 "RFU", /* 0111 */
256 "RFU", /* 1000 */
257 "512", /* 1001 */
258 "768", /* 1010 */
259 "1024", /* 1011 */
260 "1536", /* 1100 */
261 "2048", /* 1101 */
262 "RFU", /* 1110 */
263 "RFU", /* 1111 */
264 };
265
266 /*
267 * This table maps the bit values for f(max) from 7816-3:2006 section 8.3
268 * Table 7.
269 */
270 static const char *atr_fmax_table[16] = {
271 "4", /* 0000 */
272 "5", /* 0001 */
273 "6", /* 0010 */
274 "8", /* 0011 */
275 "12", /* 0100 */
276 "16", /* 0101 */
277 "20", /* 0110 */
278 "-", /* 0111 */
279 "-", /* 1000 */
280 "5", /* 1001 */
281 "7.5", /* 1010 */
282 "10", /* 1011 */
283 "15", /* 1100 */
284 "20", /* 1101 */
285 "-", /* 1110 */
286 "-", /* 1111 */
287 };
288
289 /*
290 * This table maps the bit values for Di from 7816-3:2006 section 8.3 Table 8.
291 */
292 static uint_t atr_di_valtable[16] = {
293 0, /* 0000 */
294 1, /* 0001 */
295 2, /* 0010 */
296 4, /* 0011 */
297 8, /* 0100 */
298 16, /* 0101 */
299 32, /* 0110 */
300 64, /* 0111 */
301 12, /* 1000 */
302 20, /* 1001 */
303 0, /* 1010 */
304 0, /* 1011 */
305 0, /* 1100 */
306 0, /* 1101 */
307 0, /* 1110 */
308 0 /* 1111 */
309 };
310
311 static const char *atr_di_table[16] = {
312 "RFU", /* 0000 */
313 "1", /* 0001 */
314 "2", /* 0010 */
315 "4", /* 0011 */
316 "8", /* 0100 */
317 "16", /* 0101 */
318 "32", /* 0110 */
319 "64", /* 0111 */
320 "12", /* 1000 */
321 "20", /* 1001 */
322 "RFU", /* 1010 */
323 "RFU", /* 1011 */
324 "RFU", /* 1100 */
325 "RFU", /* 1101 */
326 "RFU", /* 1110 */
327 "RFU", /* 1111 */
328 };
329
330 /*
331 * This table maps the bit values for the clock stop indicator from 7816-3:2006
332 * section 8.3 Table 9.
333 */
334 static const char *atr_clock_table[4] = {
335 "disallowed", /* 00 */
336 "signal low", /* 01 */
337 "signal high", /* 10 */
338 "signal low or high" /* 11 */
339 };
340
341 uint_t
atr_fi_index_to_value(uint8_t val)342 atr_fi_index_to_value(uint8_t val)
343 {
344 if (val >= ARRAY_SIZE(atr_fi_valtable)) {
345 return (0);
346 }
347
348 return (atr_fi_valtable[val]);
349 }
350
351 const char *
atr_fi_index_to_string(uint8_t val)352 atr_fi_index_to_string(uint8_t val)
353 {
354 if (val >= ARRAY_SIZE(atr_fi_table)) {
355 return ("<invalid>");
356 }
357
358 return (atr_fi_table[val]);
359 }
360
361 const char *
atr_fmax_index_to_string(uint8_t val)362 atr_fmax_index_to_string(uint8_t val)
363 {
364 if (val >= ARRAY_SIZE(atr_fmax_table)) {
365 return ("<invalid>");
366 }
367
368 return (atr_fmax_table[val]);
369 }
370
371 uint_t
atr_di_index_to_value(uint8_t val)372 atr_di_index_to_value(uint8_t val)
373 {
374 if (val >= ARRAY_SIZE(atr_di_valtable)) {
375 return (0);
376 }
377
378 return (atr_di_valtable[val]);
379 }
380 const char *
atr_di_index_to_string(uint8_t val)381 atr_di_index_to_string(uint8_t val)
382 {
383 if (val >= ARRAY_SIZE(atr_di_table)) {
384 return ("<invalid>");
385 }
386
387 return (atr_di_table[val]);
388 }
389
390 const char *
atr_clock_stop_to_string(atr_clock_stop_t val)391 atr_clock_stop_to_string(atr_clock_stop_t val)
392 {
393 if (val >= ARRAY_SIZE(atr_clock_table)) {
394 return ("<invalid>");
395 }
396
397 return (atr_clock_table[val]);
398 }
399
400 const char *
atr_protocol_to_string(atr_protocol_t prot)401 atr_protocol_to_string(atr_protocol_t prot)
402 {
403 if (prot == ATR_P_NONE) {
404 return ("none");
405 }
406
407 if ((prot & ATR_P_T0) == ATR_P_T0) {
408 return ("T=0");
409 } else if ((prot & ATR_P_T1) == ATR_P_T1) {
410 return ("T=1");
411 } else {
412 return ("T=0, T=1");
413 }
414 }
415
416 const char *
atr_convention_to_string(atr_convention_t conv)417 atr_convention_to_string(atr_convention_t conv)
418 {
419 if (conv == ATR_CONVENTION_DIRECT) {
420 return ("direct");
421 } else if (conv == ATR_CONVENTION_INVERSE) {
422 return ("inverse");
423 } else {
424 return ("<invalid convention>");
425 }
426 }
427
428 const char *
atr_strerror(atr_parsecode_t code)429 atr_strerror(atr_parsecode_t code)
430 {
431 switch (code) {
432 case ATR_CODE_OK:
433 return ("ATR parsed successfully");
434 case ATR_CODE_TOO_SHORT:
435 return ("Specified buffer too short");
436 case ATR_CODE_TOO_LONG:
437 return ("Specified buffer too long");
438 case ATR_CODE_INVALID_TS:
439 return ("ATR has invalid TS byte value");
440 case ATR_CODE_OVERRUN:
441 return ("ATR data requires more bytes than provided");
442 case ATR_CODE_UNDERRUN:
443 return ("ATR data did not use all provided bytes");
444 case ATR_CODE_CHECKSUM_ERROR:
445 return ("ATR data did not checksum correctly");
446 case ATR_CODE_INVALID_TD1:
447 return ("ATR data has invalid protocol in TD1");
448 default:
449 return ("Unknown Parse Code");
450 }
451 }
452
453 static uint_t
atr_count_cbits(uint8_t x)454 atr_count_cbits(uint8_t x)
455 {
456 uint_t ret = 0;
457
458 if (x & ATR_TA_MASK)
459 ret++;
460 if (x & ATR_TB_MASK)
461 ret++;
462 if (x & ATR_TC_MASK)
463 ret++;
464 if (x & ATR_TD_MASK)
465 ret++;
466 return (ret);
467 }
468
469 /*
470 * Parse out ATR values. Focus on only parsing it and not interpreting it.
471 * Interpretation should be done in other functions that can walk over the data
472 * and be more protocol-aware.
473 */
474 atr_parsecode_t
atr_parse(const uint8_t * buf,size_t len,atr_data_t * data)475 atr_parse(const uint8_t *buf, size_t len, atr_data_t *data)
476 {
477 uint_t nhist, cbits, ncbits, idx, Ti, prot;
478 uint_t ncksum = 0;
479 atr_ti_t *atp;
480
481 /*
482 * Zero out data in case someone's come back around for another loop on
483 * the same data.
484 */
485 bzero(data, sizeof (atr_data_t));
486
487 if (len < ATR_LEN_MIN) {
488 return (ATR_CODE_TOO_SHORT);
489 }
490
491 if (len > ATR_LEN_MAX) {
492 return (ATR_CODE_TOO_LONG);
493 }
494
495 if (buf[ATR_TS_IDX] != ATR_TS_INVERSE &&
496 buf[ATR_TS_IDX] != ATR_TS_DIRECT) {
497 return (ATR_CODE_INVALID_TS);
498 }
499
500 bcopy(buf, data->atr_raw, len);
501 data->atr_nraw = len;
502
503 if (buf[ATR_TS_IDX] == ATR_TS_DIRECT) {
504 data->atr_flags |= ATR_F_USES_DIRECT;
505 } else {
506 data->atr_flags |= ATR_F_USES_INVERSE;
507 }
508
509 /*
510 * The protocol of T0 is the number of historical bits present.
511 */
512 nhist = ATR_TD_PROT(buf[ATR_T0_IDX]);
513 cbits = ATR_TD_NBITS(buf[ATR_T0_IDX]);
514 idx = ATR_T0_IDX + 1;
515 ncbits = atr_count_cbits(cbits);
516
517 /*
518 * Ti is used to track the current iteration of T[A,B,C,D] that we are
519 * on, as the ISO/IEC standard suggests. The way that values are
520 * interpreted depends on the value of Ti.
521 *
522 * When Ti is one, TA, TB, and TC represent global properties. TD's
523 * protocol represents the preferred protocol.
524 *
525 * When Ti is two, TA, TB, and TC also represent global properties.
526 * However, TC only has meaning if the protocol is T=0.
527 *
528 * When Ti is 15, it indicates more global properties.
529 *
530 * For all other values of Ti, the meaning depends on the protocol in
531 * question and they are all properties specific to that protocol.
532 */
533 Ti = 1;
534 /*
535 * Initialize prot to an invalid protocol to help us deal with the
536 * normal workflow and make sure that we don't mistakenly do anything.
537 */
538 prot = UINT32_MAX;
539 for (;;) {
540 atp = &data->atr_ti[data->atr_nti];
541 data->atr_nti++;
542 ASSERT3U(data->atr_nti, <=, ATR_TI_MAX);
543
544 /*
545 * Make sure that we have enough space to read all the cbits.
546 * idx points to the first cbit, which could also potentially be
547 * over the length of the buffer. This is why we subtract one
548 * from idx when doing the calculation.
549 */
550 if (idx - 1 + ncbits >= len) {
551 return (ATR_CODE_OVERRUN);
552 }
553
554 ASSERT3U(Ti, !=, 0);
555
556 /*
557 * At the moment we opt to ignore reserved protocols.
558 */
559 atp->atrti_protocol = prot;
560 atp->atrti_ti_val = Ti;
561 atp->atrti_td_idx = idx - 1;
562
563 if (cbits & ATR_TA_MASK) {
564 atp->atrti_flags |= ATR_TI_HAVE_TA;
565 atp->atrti_ta = buf[idx];
566 idx++;
567 }
568
569 if (cbits & ATR_TB_MASK) {
570 atp->atrti_flags |= ATR_TI_HAVE_TB;
571 atp->atrti_tb = buf[idx];
572 idx++;
573 }
574
575 if (cbits & ATR_TC_MASK) {
576 atp->atrti_flags |= ATR_TI_HAVE_TC;
577 atp->atrti_tc = buf[idx];
578 idx++;
579 }
580
581 if (cbits & ATR_TD_MASK) {
582 atp->atrti_flags |= ATR_TI_HAVE_TD;
583 atp->atrti_td = buf[idx];
584 cbits = ATR_TD_NBITS(buf[idx]);
585 prot = ATR_TD_PROT(buf[idx]);
586 ncbits = atr_count_cbits(cbits);
587 if (prot != 0)
588 ncksum = 1;
589
590 /*
591 * T=15 is not allowed in TD1 per 8.2.3.
592 */
593 if (Ti == 1 && prot == 0xf)
594 return (ATR_CODE_INVALID_TD1);
595
596 idx++;
597 /*
598 * Encountering TD means that once we take the next loop
599 * and we need to increment Ti.
600 */
601 Ti++;
602 } else {
603 break;
604 }
605 }
606
607 /*
608 * We've parsed all of the cbits. At this point, we should take into
609 * account all of the historical bits and potentially the checksum.
610 */
611 if (idx - 1 + nhist + ncksum >= len) {
612 return (ATR_CODE_OVERRUN);
613 }
614
615 if (idx + nhist + ncksum != len) {
616 return (ATR_CODE_UNDERRUN);
617 }
618
619 if (nhist > 0) {
620 data->atr_nhistoric = nhist;
621 bcopy(&buf[idx], data->atr_historic, nhist);
622 }
623
624 if (ncksum > 0) {
625 size_t i;
626 uint8_t val;
627
628 /*
629 * Per ISO/IEC 7816-3:2006 Section 8.2.5 the checksum is all
630 * bytes excluding TS. Therefore, we must start at byte 1.
631 */
632 for (val = 0, i = 1; i < len; i++) {
633 val ^= buf[i];
634 }
635
636 if (val != ATR_CKSUM_TARGET) {
637 return (ATR_CODE_CHECKSUM_ERROR);
638 }
639 data->atr_flags |= ATR_F_HAS_CHECKSUM;
640 data->atr_cksum = buf[len - 1];
641 }
642
643 data->atr_flags |= ATR_F_VALID;
644 return (ATR_CODE_OK);
645 }
646
647 uint8_t
atr_fi_default_index(void)648 atr_fi_default_index(void)
649 {
650 return (ATR_FI_DEFAULT_INDEX);
651 }
652
653 uint8_t
atr_di_default_index(void)654 atr_di_default_index(void)
655 {
656 return (ATR_DI_DEFAULT_INDEX);
657 }
658
659 /*
660 * Parse the data to determine which protocols are supported in this atr data.
661 * Based on this, users can come and ask us to fill in protocol information.
662 */
663 atr_protocol_t
atr_supported_protocols(atr_data_t * data)664 atr_supported_protocols(atr_data_t *data)
665 {
666 uint_t i;
667 atr_protocol_t prot;
668
669 if ((data->atr_flags & ATR_F_VALID) == 0)
670 return (ATR_P_NONE);
671
672 /*
673 * Based on 8.2.3 of ISO/IEC 7816-3:2006, if TD1 is present, then that
674 * indicates the first protocol. However, if it is not present, then
675 * that implies that T=0 is the only supported protocol. Otherwise, all
676 * protocols are referenced in ascending order. The first entry in
677 * atr_ti refers to data from T0, so the protocol in the second entry
678 * would have the TD1 data.
679 */
680 if (data->atr_nti < 2) {
681 return (ATR_P_T0);
682 }
683
684 prot = ATR_P_NONE;
685 for (i = 0; i < data->atr_nti; i++) {
686 switch (data->atr_ti[i].atrti_protocol) {
687 case ATR_PROTOCOL_T0:
688 prot |= ATR_P_T0;
689 break;
690 case ATR_PROTOCOL_T1:
691 prot |= ATR_P_T1;
692 break;
693 default:
694 /*
695 * T=15 is not a protocol, and all other protocol values
696 * are currently reserved for future use.
697 */
698 continue;
699 }
700 }
701
702 /*
703 * It's possible we've found nothing specific in the above loop (for
704 * example, only T=15 global bits were found). In that case, the card
705 * defaults to T=0.
706 */
707 if (prot == ATR_P_NONE)
708 prot = ATR_P_T0;
709
710 return (prot);
711 }
712
713 boolean_t
atr_params_negotiable(atr_data_t * data)714 atr_params_negotiable(atr_data_t *data)
715 {
716 /* If for some reason we're called with invalid data, assume it's not */
717 if ((data->atr_flags & ATR_F_VALID) == 0)
718 return (B_FALSE);
719
720
721 /*
722 * Whether or not we're negotiable is in the second global page, so atr
723 * index 1. If TA2 is missing, then the card always is negotiable.
724 */
725 if (data->atr_nti < 2 ||
726 (data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TA) == 0) {
727 return (B_TRUE);
728 }
729
730 if (ATR_TA2_CANCHANGE(data->atr_ti[1].atrti_ta)) {
731 return (B_TRUE);
732 }
733
734 return (B_FALSE);
735 }
736
737 atr_protocol_t
atr_default_protocol(atr_data_t * data)738 atr_default_protocol(atr_data_t *data)
739 {
740 uint8_t prot;
741
742 if ((data->atr_flags & ATR_F_VALID) == 0)
743 return (ATR_P_NONE);
744 /*
745 * If we don't have an TA2 byte, then the system defaults to T=0.
746 */
747 if (data->atr_nti < 2) {
748 return (ATR_P_T0);
749 }
750
751 /*
752 * If TA2 is present, then it encodes the default protocol. Otherwise,
753 * we have to grab the protocol value from TD1, which is called the
754 * 'first offered protocol'.
755 */
756 if ((data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TA) != 0) {
757 prot = ATR_TA2_PROTOCOL(data->atr_ti[1].atrti_ta);
758 } else {
759 prot = data->atr_ti[1].atrti_protocol;
760 }
761
762 switch (prot) {
763 case ATR_PROTOCOL_T0:
764 return (ATR_P_T0);
765 case ATR_PROTOCOL_T1:
766 return (ATR_P_T1);
767 default:
768 return (ATR_P_NONE);
769 }
770 }
771
772 uint8_t
atr_fi_index(atr_data_t * data)773 atr_fi_index(atr_data_t *data)
774 {
775 if (data->atr_nti < 1) {
776 return (ATR_FI_DEFAULT_INDEX);
777 }
778
779 /*
780 * If TA is specified, it is present in TA1. TA2 may override its
781 * presence, so if it is here, check that first to determine whether or
782 * not we should check TA1.
783 */
784 if (data->atr_nti >= 2 &&
785 (data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TA) != 0) {
786 if (!ATR_TA2_HONORTA1(data->atr_ti[1].atrti_ta)) {
787 return (ATR_FI_DEFAULT_INDEX);
788 }
789 }
790
791 if ((data->atr_ti[0].atrti_flags & ATR_TI_HAVE_TA) != 0) {
792 return (ATR_TA1_FTABLE(data->atr_ti[0].atrti_ta));
793 }
794
795 return (ATR_FI_DEFAULT_INDEX);
796 }
797
798 uint8_t
atr_di_index(atr_data_t * data)799 atr_di_index(atr_data_t *data)
800 {
801 if (data->atr_nti < 1) {
802 return (ATR_DI_DEFAULT_INDEX);
803 }
804
805 /*
806 * If TA is specified, it is present in TA1. TA2 may override its
807 * presence, so if it is here, check that first to determine whether or
808 * not we should check TA1.
809 */
810 if (data->atr_nti >= 2 &&
811 (data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TA) != 0) {
812 if (!ATR_TA2_HONORTA1(data->atr_ti[1].atrti_ta)) {
813 return (ATR_DI_DEFAULT_INDEX);
814 }
815 }
816
817 if ((data->atr_ti[0].atrti_flags & ATR_TI_HAVE_TA) != 0) {
818 return (ATR_TA1_DITABLE(data->atr_ti[0].atrti_ta));
819 }
820
821 return (ATR_DI_DEFAULT_INDEX);
822 }
823
824 atr_convention_t
atr_convention(atr_data_t * data)825 atr_convention(atr_data_t *data)
826 {
827 if ((data->atr_flags & ATR_F_USES_DIRECT) != 0) {
828 return (ATR_CONVENTION_DIRECT);
829 }
830 return (ATR_CONVENTION_INVERSE);
831 }
832
833 uint8_t
atr_extra_guardtime(atr_data_t * data)834 atr_extra_guardtime(atr_data_t *data)
835 {
836 if ((data->atr_flags & ATR_F_VALID) == 0)
837 return (ATR_EXTRA_GUARDTIME_DEFAULT);
838
839 if (data->atr_nti >= 1 &&
840 (data->atr_ti[0].atrti_flags & ATR_TI_HAVE_TC) != 0) {
841 return (data->atr_ti[0].atrti_tc);
842 }
843
844 return (ATR_EXTRA_GUARDTIME_DEFAULT);
845 }
846
847 uint8_t
atr_t0_wi(atr_data_t * data)848 atr_t0_wi(atr_data_t *data)
849 {
850 if ((data->atr_flags & ATR_F_VALID) == 0)
851 return (ATR_T0_WI_DEFAULT);
852
853 /*
854 * This is stored in the optional global byte in TC2; however, it only
855 * applies to T=0.
856 */
857 if (data->atr_nti >= 2 &&
858 data->atr_ti[1].atrti_protocol == ATR_PROTOCOL_T0 &&
859 (data->atr_ti[1].atrti_flags & ATR_TI_HAVE_TC) != 0) {
860 return (data->atr_ti[1].atrti_tc);
861 }
862
863 return (ATR_T0_WI_DEFAULT);
864 }
865
866 uint8_t
atr_t1_cwi(atr_data_t * data)867 atr_t1_cwi(atr_data_t *data)
868 {
869 uint8_t i;
870
871 if (data->atr_nti <= 2) {
872 return (ATR_T1_CWI_DEFAULT);
873 }
874
875 for (i = 2; i < data->atr_nti; i++) {
876 if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T1) {
877 if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TB) !=
878 0) {
879 uint8_t tb = data->atr_ti[i].atrti_tb;
880 return (ATR_T1_TB0_CWI(tb));
881 }
882
883 return (ATR_T1_CWI_DEFAULT);
884 }
885 }
886
887 return (ATR_T1_CWI_DEFAULT);
888 }
889
890 atr_clock_stop_t
atr_clock_stop(atr_data_t * data)891 atr_clock_stop(atr_data_t *data)
892 {
893 uint8_t i;
894
895 for (i = 0; i < data->atr_nti; i++) {
896 if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T15) {
897 if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TA) !=
898 0) {
899 uint8_t ta = data->atr_ti[i].atrti_ta;
900 return (ATR_T15_TA0_CLOCK(ta));
901 }
902
903 return (ATR_CLOCK_STOP_NONE);
904 }
905 }
906
907 return (ATR_CLOCK_STOP_NONE);
908 }
909
910 atr_t1_checksum_t
atr_t1_checksum(atr_data_t * data)911 atr_t1_checksum(atr_data_t *data)
912 {
913 uint8_t i;
914
915 if (data->atr_nti <= 2) {
916 return (ATR_T1_CHECKSUM_DEFAULT);
917 }
918
919 for (i = 2; i < data->atr_nti; i++) {
920 if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T1) {
921 if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TC) !=
922 0) {
923 if (ATR_T1_TC0_CRC(data->atr_ti[i].atrti_tc)) {
924 return (ATR_T1_CHECKSUM_CRC);
925 } else {
926 return (ATR_T1_CHECKSUM_LRC);
927 }
928 }
929
930 return (ATR_T1_CHECKSUM_DEFAULT);
931 }
932 }
933
934 return (ATR_T1_CHECKSUM_DEFAULT);
935
936 }
937
938 uint8_t
atr_t1_bwi(atr_data_t * data)939 atr_t1_bwi(atr_data_t *data)
940 {
941 uint8_t i;
942
943 if (data->atr_nti <= 2) {
944 return (ATR_T1_BWI_DEFAULT);
945 }
946
947 for (i = 2; i < data->atr_nti; i++) {
948 if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T1) {
949 if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TB) !=
950 0) {
951 uint8_t tb = data->atr_ti[i].atrti_tb;
952 return (ATR_T1_TB0_BWI(tb));
953 }
954
955 return (ATR_T1_BWI_DEFAULT);
956 }
957 }
958
959 return (ATR_T1_BWI_DEFAULT);
960 }
961
962 uint8_t
atr_t1_ifsc(atr_data_t * data)963 atr_t1_ifsc(atr_data_t *data)
964 {
965 uint8_t i;
966
967 if (data->atr_nti <= 2) {
968 return (ATR_T1_IFSC_DEFAULT);
969 }
970
971 for (i = 2; i < data->atr_nti; i++) {
972 if (data->atr_ti[i].atrti_protocol == ATR_PROTOCOL_T1) {
973 if ((data->atr_ti[i].atrti_flags & ATR_TI_HAVE_TA) !=
974 0) {
975 return (data->atr_ti[i].atrti_ta);
976 }
977
978 return (ATR_T1_IFSC_DEFAULT);
979 }
980 }
981
982 return (ATR_T1_IFSC_DEFAULT);
983 }
984
985 /*
986 * Attempt to determine which set of data rates we should be able to use for a
987 * given class of protocol. Here we want to do the calculation based on the CCID
988 * specification, section 9.4.x. To use these higher rates we need:
989 *
990 * + Reader's data rate > frequency * Di / Fi.
991 *
992 * To determine which rate and frequency we use, we look at the reader's
993 * features. If the reader supports both the Automatic baud rate and automatic
994 * ICC clock frequency change, then we use the _maximum_ rate. Otherwise we will
995 * indicate that we can use the ATR's properties, but will require changing the
996 * default data rate.
997 *
998 * Now, some ICC devices are not negotiable. In those cases, we'll see if we can
999 * fit it in with either the default or maximum data rates. If not, then we'll
1000 * not be able to support this card.
1001 *
1002 * There are two wrinkles that exist in this. The first is supported frequencies
1003 * and data rates. If there are no additional data rates supported, then all of
1004 * the data rates between the default and max are supported. If not, then only
1005 * those specified in the data rates array are supported.
1006 *
1007 * The second hurdle is that we need to do this division and try and avoid the
1008 * pitfalls of floating point arithmetic, as floating point is not allowed in
1009 * the kernel (and this is shared). Importantly that means only integers are
1010 * allowed here.
1011 */
1012 atr_data_rate_choice_t
atr_data_rate(atr_data_t * data,ccid_class_descr_t * class,uint32_t * rates,uint_t nrates,uint32_t * dataratep)1013 atr_data_rate(atr_data_t *data, ccid_class_descr_t *class, uint32_t *rates,
1014 uint_t nrates, uint32_t *dataratep)
1015 {
1016 uint_t nfeats = CCID_CLASS_F_AUTO_ICC_CLOCK | CCID_CLASS_F_AUTO_BAUD;
1017 uint8_t di, fi;
1018 uint_t dival, fival;
1019 boolean_t autospeed, negotiable, exprates;
1020 uint64_t maxval, defval;
1021
1022 if ((data->atr_flags & ATR_F_VALID) == 0)
1023 return (ATR_RATE_UNSUPPORTED);
1024
1025 di = atr_di_index(data);
1026 fi = atr_fi_index(data);
1027 dival = atr_di_index_to_value(di);
1028 fival = atr_fi_index_to_value(fi);
1029 autospeed = (class->ccd_dwFeatures & nfeats) == nfeats;
1030 exprates = class->ccd_bNumDataRatesSupported != 0;
1031 negotiable = atr_params_negotiable(data);
1032
1033 /*
1034 * We don't support cards with fixed rates at this time as it's not
1035 * clear what that rate should be. If it's negotiable, we'll let them
1036 * run at the default. Otherwise, we have to fail the request until
1037 * we implement the logic to search their data rates.
1038 */
1039 if (exprates) {
1040 if (negotiable) {
1041 return (ATR_RATE_USEDEFAULT);
1042 }
1043 return (ATR_RATE_UNSUPPORTED);
1044 }
1045
1046 /*
1047 * This indicates that the card gave us values that were reserved for
1048 * future use. If we could negotiate it, then just stick with the
1049 * default paramters. Otherwise, return that we can't support this ICC.
1050 */
1051 if (dival == 0 || fival == 0) {
1052 if (negotiable)
1053 return (ATR_RATE_USEDEFAULT);
1054 return (ATR_RATE_UNSUPPORTED);
1055 }
1056
1057 /*
1058 * Calculate the maximum and default values.
1059 */
1060 maxval = class->ccd_dwMaximumClock * 1000;
1061 maxval *= dival;
1062 maxval /= fival;
1063
1064 defval = class->ccd_dwDefaultClock * 1000;
1065 defval *= dival;
1066 defval /= fival;
1067
1068 /*
1069 * We're allowed any set of data rates between the default and the
1070 * maximum. Check if the maximum data rate will work for either the
1071 * default or maximum clock. If so, then we can use the cards rates.
1072 *
1073 * To account for the fact that we may have had a fractional value,
1074 * we require a strict greater than comparison.
1075 */
1076 if ((uint64_t)class->ccd_dwMaxDataRate > maxval ||
1077 (uint64_t)class->ccd_dwMaxDataRate > defval) {
1078 if (autospeed) {
1079 return (ATR_RATE_USEATR);
1080 }
1081 }
1082
1083 /*
1084 * If the CCID reader can't handle the ICC's proposed rates, then fall
1085 * back to the defaults if we're allowed to negotiate. Otherwise, we're
1086 * not able to use this ICC.
1087 */
1088 if (negotiable) {
1089 return (ATR_RATE_USEDEFAULT);
1090 }
1091
1092 return (ATR_RATE_UNSUPPORTED);
1093 }
1094
1095 void
atr_data_reset(atr_data_t * data)1096 atr_data_reset(atr_data_t *data)
1097 {
1098 bzero(data, sizeof (*data));
1099 }
1100
1101 #ifdef _KERNEL
1102 atr_data_t *
atr_data_alloc(void)1103 atr_data_alloc(void)
1104 {
1105 return (kmem_zalloc(sizeof (atr_data_t), KM_SLEEP));
1106 }
1107
1108 void
atr_data_free(atr_data_t * data)1109 atr_data_free(atr_data_t *data)
1110 {
1111 kmem_free(data, sizeof (atr_data_t));
1112 }
1113
1114 /*
1115 * Make sure that the response we got from the ICC is valid. It must pass
1116 * checksum and have the PPSS value set correctly. The protocol must match
1117 * what we requested; however, the PPS1-3 bits are a bit different. They may
1118 * only be set in the response if we set them in the request. However, they
1119 * do not have to be set in the response.
1120 */
1121 boolean_t
atr_pps_valid(void * reqbuf,size_t reqlen,void * respbuf,size_t resplen)1122 atr_pps_valid(void *reqbuf, size_t reqlen, void *respbuf, size_t resplen)
1123 {
1124 uint8_t val, i, reqidx, respidx;
1125 uint8_t *req = reqbuf, *resp = respbuf;
1126
1127 if (resplen > PPS_LEN_MAX || resplen < PPS_LEN_MIN)
1128 return (B_FALSE);
1129
1130 /*
1131 * Before we validate the data, make sure the checksum is valid.
1132 */
1133 for (i = 0, val = 0; i < resplen; i++) {
1134 val ^= resp[i];
1135 }
1136
1137 /* Checksum failure */
1138 if (val != 0) {
1139 return (B_FALSE);
1140 }
1141
1142 /*
1143 * We should always have PPSS echoed back as we set it.
1144 */
1145 if (resp[PPS_PPSS_INDEX] != PPS_PPSS_VAL) {
1146 return (B_FALSE);
1147 }
1148
1149 /*
1150 * Go through and make sure the number of bytes present makes sense for
1151 * the number of bits set in PPS1.
1152 */
1153 val = PPS_LEN_MIN;
1154 if (resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS1)
1155 val++;
1156 if (resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS2)
1157 val++;
1158 if (resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS3)
1159 val++;
1160 if (val != resplen)
1161 return (B_FALSE);
1162
1163 /*
1164 * Now we've finally verified that the response is syntactically valid.
1165 * We must go through and make sure that it is semantically valid.
1166 */
1167 if (PPS_PPS0_PROT(req[PPS_PPS0_INDEX]) !=
1168 PPS_PPS0_PROT(resp[PPS_PPS0_INDEX])) {
1169 return (B_FALSE);
1170 }
1171
1172 /*
1173 * When checking the PPS bit and extensions, we first check in the
1174 * response as a bit in the request is allowed to not be in the
1175 * response. But not the opposite way around. We also have to keep track
1176 * of the fact that the index for values will vary.
1177 */
1178 reqidx = respidx = PPS_PPS0_INDEX + 1;
1179 if ((resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS1) != 0) {
1180 if ((req[PPS_PPS0_INDEX] & PPS_PPS0_PPS1) == 0) {
1181 return (B_FALSE);
1182 }
1183
1184 if (req[reqidx] != resp[respidx]) {
1185 return (B_FALSE);
1186 }
1187
1188 reqidx++;
1189 respidx++;
1190 } else if ((req[PPS_PPS0_INDEX] & PPS_PPS0_PPS1) != 0) {
1191 reqidx++;
1192 }
1193
1194 if ((resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS2) != 0) {
1195 if ((req[PPS_PPS0_INDEX] & PPS_PPS0_PPS2) == 0) {
1196 return (B_FALSE);
1197 }
1198
1199 if (req[reqidx] != resp[respidx]) {
1200 return (B_FALSE);
1201 }
1202
1203 reqidx++;
1204 respidx++;
1205 } else if ((req[PPS_PPS0_INDEX] & PPS_PPS0_PPS2) != 0) {
1206 reqidx++;
1207 }
1208
1209 if ((resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS3) != 0) {
1210 /*
1211 * At this time, we never specify PPS3 in a request. Therefore
1212 * if it is present in the response, treat this as an invalid
1213 * request.
1214 */
1215 return (B_FALSE);
1216 }
1217
1218 return (B_TRUE);
1219 }
1220
1221 uint_t
atr_pps_generate(uint8_t * buf,size_t buflen,atr_protocol_t prot,boolean_t pps1,uint8_t fi,uint8_t di,boolean_t pps2,uint8_t spu)1222 atr_pps_generate(uint8_t *buf, size_t buflen, atr_protocol_t prot,
1223 boolean_t pps1, uint8_t fi, uint8_t di, boolean_t pps2, uint8_t spu)
1224 {
1225 uint8_t protval, cksum, i;
1226 uint_t len = 0;
1227
1228 if (buflen < PPS_BUFFER_MAX)
1229 return (0);
1230
1231 buf[PPS_PPSS_INDEX] = PPS_PPSS_VAL;
1232 switch (prot) {
1233 case ATR_P_T0:
1234 protval = 0;
1235 break;
1236 case ATR_P_T1:
1237 protval = 1;
1238 break;
1239 default:
1240 return (0);
1241 }
1242
1243 buf[PPS_PPS0_INDEX] = PPS_PPS0_PROT(protval);
1244 len = 2;
1245 if (pps1) {
1246 buf[PPS_PPS0_INDEX] |= PPS_PPS0_PPS1;
1247 buf[len++] = PPS_PPS1_SETVAL(fi, di);
1248 }
1249
1250 if (pps2) {
1251 buf[PPS_PPS0_INDEX] |= PPS_PPS0_PPS2;
1252 buf[len++] = spu;
1253 }
1254
1255 /*
1256 * The checksum must xor to zero.
1257 */
1258 for (i = 0, cksum = 0; i < len; i++) {
1259 cksum ^= buf[i];
1260 }
1261 buf[len++] = cksum;
1262 return (len);
1263 }
1264
1265 /*
1266 * The caller of this wants to know if the Fi/Di values that they proposed were
1267 * accepted. The caller must have already called atr_pps_valid(). At this point,
1268 * we can say that the value was accepted if the PPS1 bit is set.
1269 */
1270 boolean_t
atr_pps_fidi_accepted(void * respbuf,size_t len)1271 atr_pps_fidi_accepted(void *respbuf, size_t len)
1272 {
1273 uint8_t *resp = respbuf;
1274 return ((resp[PPS_PPS0_INDEX] & PPS_PPS0_PPS1) != 0);
1275 }
1276
1277 #else /* !_KERNEL */
1278 atr_data_t *
atr_data_alloc(void)1279 atr_data_alloc(void)
1280 {
1281 return (calloc(1, sizeof (atr_data_t)));
1282 }
1283
1284 void
atr_data_free(atr_data_t * data)1285 atr_data_free(atr_data_t *data)
1286 {
1287 if (data == NULL)
1288 return;
1289 free(data);
1290 }
1291
1292 /*
1293 * This table maps the bit values for Fi from 7816-3:2006 section 8.3 Table 9.
1294 * The table is up to 6 bits wide. Entries not present are RFU. We use NULL as a
1295 * sentinel to indicate that.
1296 */
1297 static const char *atr_voltage_table[64] = {
1298 NULL, /* 00 0000 */
1299 "5V", /* 00 0001 */
1300 "3V", /* 00 0010 */
1301 "5V, 3V", /* 00 0011 */
1302 "1.5V", /* 00 0100 */
1303 NULL, /* 00 0101 */
1304 "3V, 1.5V", /* 00 0110 */
1305 "5V, 3V, 1.5V" /* 00 0111 */
1306 };
1307
1308 static void
atr_data_dump_ta(atr_ti_t * atp,FILE * out,uint_t level)1309 atr_data_dump_ta(atr_ti_t *atp, FILE *out, uint_t level)
1310 {
1311 uint8_t ta;
1312
1313 if (!(atp->atrti_flags & ATR_TI_HAVE_TA)) {
1314 return;
1315 }
1316
1317 ta = atp->atrti_ta;
1318 (void) fprintf(out, " %c%c%c+-> TA%u 0x%02x",
1319 atp->atrti_flags & ATR_TI_HAVE_TD ? '|' : ' ',
1320 atp->atrti_flags & ATR_TI_HAVE_TC ? '|' : ' ',
1321 atp->atrti_flags & ATR_TI_HAVE_TB ? '|' : ' ',
1322 atp->atrti_ti_val, ta);
1323 switch (atp->atrti_ti_val) {
1324 case 1:
1325 (void) fprintf(out, "; Fi: %s, F(max): %s MHz, Di: %s",
1326 atr_fi_table[ATR_TA1_FTABLE(ta)],
1327 atr_fmax_table[ATR_TA1_FTABLE(ta)],
1328 atr_di_table[ATR_TA1_DITABLE(ta)]);
1329 break;
1330 case 2:
1331 (void) fprintf(out, "; ICC in %s mode; %shonoring TA1; default "
1332 "T=%u",
1333 ATR_TA2_CANCHANGE(ta) ? "negotiable" : "specific",
1334 ATR_TA2_HONORTA1(ta) ? "" : "not ",
1335 ATR_TA2_PROTOCOL(ta));
1336 break;
1337 default:
1338 switch (atp->atrti_protocol) {
1339 case ATR_PROTOCOL_T1:
1340 if (level != 0)
1341 break;
1342 if (ta == 0 || ta == 0xff) {
1343 (void) fprintf(out, "; IFSC: RFU");
1344 } else {
1345 (void) fprintf(out, "; IFSC: %u", ta);
1346 }
1347 break;
1348 case ATR_PROTOCOL_T15:
1349 if (level != 0)
1350 break;
1351 (void) fprintf(out, "; Clock stop: %s, Supported "
1352 "Voltage: %s",
1353 atr_clock_table[ATR_T15_TA0_CLOCK(ta)],
1354 atr_voltage_table[ATR_T15_TA0_VOLTAGE(ta)] != NULL ?
1355 atr_voltage_table[ATR_T15_TA0_VOLTAGE(ta)] : "RFU");
1356 break;
1357 default:
1358 break;
1359 }
1360 }
1361 (void) fprintf(out, "\n");
1362 }
1363
1364 static void
atr_data_dump_tb(atr_ti_t * atp,FILE * out,uint_t level)1365 atr_data_dump_tb(atr_ti_t *atp, FILE *out, uint_t level)
1366 {
1367 uint8_t tb;
1368
1369 if (!(atp->atrti_flags & ATR_TI_HAVE_TB)) {
1370 return;
1371 }
1372
1373 tb = atp->atrti_tb;
1374 (void) fprintf(out, " %c%c+--> TB%u 0x%02x",
1375 atp->atrti_flags & ATR_TI_HAVE_TD ? '|' : ' ',
1376 atp->atrti_flags & ATR_TI_HAVE_TC ? '|' : ' ',
1377 atp->atrti_ti_val, tb);
1378 switch (atp->atrti_ti_val) {
1379 case 1:
1380 case 2:
1381 (void) fprintf(out, "; deprecated");
1382 break;
1383 default:
1384 switch (atp->atrti_protocol) {
1385 case ATR_PROTOCOL_T1:
1386 if (level != 0)
1387 break;
1388 (void) fprintf(out, "; CWI: %u, BWI: %u\n",
1389 ATR_T1_TB0_CWI(tb),
1390 ATR_T1_TB0_BWI(tb));
1391 break;
1392 case ATR_PROTOCOL_T15:
1393 if (level != 0)
1394 break;
1395 (void) fprintf(out, "; SPU: %s", tb == 0 ? "not used" :
1396 ATR_T15_TB0_SPU_STANDARD(tb) ? "standard" :
1397 "proprietary");
1398 break;
1399 default:
1400 break;
1401 }
1402 }
1403 (void) fprintf(out, "\n");
1404 }
1405
1406 static void
atr_data_dump_tc(atr_ti_t * atp,FILE * out,uint_t level)1407 atr_data_dump_tc(atr_ti_t *atp, FILE *out, uint_t level)
1408 {
1409 uint8_t tc;
1410
1411 if (!(atp->atrti_flags & ATR_TI_HAVE_TC)) {
1412 return;
1413 }
1414
1415 tc = atp->atrti_tc;
1416 (void) fprintf(out, " %c+---> TC%u 0x%02x",
1417 atp->atrti_flags & ATR_TI_HAVE_TD ? '|' : ' ',
1418 atp->atrti_ti_val, tc);
1419
1420 switch (atp->atrti_ti_val) {
1421 case 1:
1422 (void) fprintf(out, "; Extra Guard Time Integer: %u", tc);
1423 break;
1424 case 2:
1425 if (atp->atrti_protocol != ATR_PROTOCOL_T0) {
1426 (void) fprintf(out, "; illegal value -- only valid for "
1427 "T=0");
1428 } else {
1429 (void) fprintf(out, "; Waiting Time Integer: %u", tc);
1430 }
1431 break;
1432 default:
1433 switch (atp->atrti_protocol) {
1434 case ATR_PROTOCOL_T1:
1435 if (level != 0)
1436 break;
1437 (void) fprintf(out, "; Error Detection Code: %s",
1438 ATR_T1_TC0_CRC(tc) ? "CRC" : "LRC");
1439 break;
1440 default:
1441 break;
1442 }
1443 }
1444 (void) fprintf(out, "\n");
1445 }
1446
1447 void
atr_data_hexdump(const uint8_t * buf,size_t nbytes,FILE * out)1448 atr_data_hexdump(const uint8_t *buf, size_t nbytes, FILE *out)
1449 {
1450 size_t i, j;
1451
1452 /* Print out the header */
1453 (void) fprintf(out, "%*s 0", 4, "");
1454 for (i = 1; i < 16; i++) {
1455 if (i % 4 == 0 && i % 16 != 0) {
1456 (void) fprintf(out, " ");
1457 }
1458
1459 (void) fprintf(out, "%2x", i);
1460 }
1461 (void) fprintf(out, " 0123456789abcdef\n");
1462
1463 /* Print out data */
1464 for (i = 0; i < nbytes; i++) {
1465
1466 if (i % 16 == 0) {
1467 (void) fprintf(out, "%04x: ", i);
1468 }
1469
1470 if (i % 4 == 0 && i % 16 != 0) {
1471 (void) fprintf(out, " ");
1472 }
1473
1474 (void) fprintf(out, "%02x", buf[i]);
1475
1476 if (i % 16 == 15 || i + 1 == nbytes) {
1477 for (j = (i % 16) + 1; j < 16; j++) {
1478 if (j % 4 == 0 && j % 16 != 0) {
1479 (void) fprintf(out, " ");
1480 }
1481
1482 (void) fprintf(out, " ");
1483 }
1484
1485 (void) fprintf(out, " ");
1486 for (j = i - (i % 16); j <= i; j++) {
1487 (void) fprintf(out, "%c",
1488 isprint(buf[j]) ? buf[j] : '.');
1489 }
1490 (void) printf("\n");
1491 }
1492 }
1493 }
1494
1495 static void
atr_data_hexdump_historical(atr_data_t * data,FILE * out)1496 atr_data_hexdump_historical(atr_data_t *data, FILE *out)
1497 {
1498 (void) fprintf(out, "Dumping raw historical bytes\n");
1499
1500 atr_data_hexdump(data->atr_historic, data->atr_nhistoric, out);
1501 }
1502
1503 static void
atr_data_dump_historical(atr_data_t * data,FILE * out)1504 atr_data_dump_historical(atr_data_t *data, FILE *out)
1505 {
1506 uint8_t cat;
1507
1508 (void) fprintf(out, "Historic Data: %u bytes", data->atr_nhistoric);
1509 if (data->atr_nhistoric == 0) {
1510 (void) fprintf(out, "\n");
1511 return;
1512 }
1513
1514 cat = data->atr_historic[0];
1515 (void) fprintf(out, "; format (0x%02x) ", cat);
1516 if (cat == ATR_HIST_CAT_MAND_STATUS) {
1517 (void) fprintf(out, "card status, not shown");
1518 } else if (cat == ATR_HIST_CAT_TLV_STATUS) {
1519 (void) fprintf(out, "COMPACT-TLV, not shown");
1520 } else if (cat >= ATR_HIST_CAT_RFU_MIN && cat <= ATR_HIST_CAT_RFU_MAX) {
1521 (void) fprintf(out, "reserved\n");
1522 atr_data_hexdump_historical(data, out);
1523 return;
1524 } else {
1525 (void) fprintf(out, "proprietary\n");
1526 atr_data_hexdump_historical(data, out);
1527 return;
1528 }
1529 }
1530
1531 void
atr_data_dump(atr_data_t * data,FILE * out)1532 atr_data_dump(atr_data_t *data, FILE *out)
1533 {
1534 uint8_t i, level;
1535 if ((data->atr_flags & ATR_F_VALID) == 0)
1536 return;
1537
1538 (void) fprintf(out, "TS 0x%02u - ", data->atr_raw[0]);
1539 if (data->atr_flags & ATR_F_USES_DIRECT) {
1540 (void) fprintf(out, "direct convention\n");
1541 } else {
1542 (void) fprintf(out, "inverse convention\n");
1543 }
1544
1545 level = 0;
1546 for (i = 0; i < data->atr_nti; i++) {
1547 atr_ti_t *atp = &data->atr_ti[i];
1548
1549 /*
1550 * Various protocols may appear multiple times, indicating
1551 * different sets of bits each time. When dealing with T0 and
1552 * TD1, the protocol doesn't matter. Otherwise if we have the
1553 * same value, we should increment this.
1554 */
1555 if (i <= 2) {
1556 level = 0;
1557 } else if (atp->atrti_protocol ==
1558 data->atr_ti[i - 1].atrti_protocol) {
1559 level++;
1560 } else {
1561 level = 0;
1562 }
1563
1564 if (i == 0) {
1565 (void) fprintf(out, "T0 ");
1566 } else {
1567 (void) fprintf(out, "TD%u ", i);
1568 }
1569 (void) fprintf(out, "0x%02x\n",
1570 data->atr_raw[atp->atrti_td_idx]);
1571 (void) fprintf(out, " |+-> ");
1572 if (i == 0) {
1573 (void) fprintf(out, "%u historical bytes\n",
1574 data->atr_nhistoric);
1575 } else {
1576 (void) fprintf(out, "protocol T=%u\n",
1577 atp->atrti_protocol);
1578 }
1579 (void) fprintf(out, " v\n");
1580 (void) fprintf(out, " 0r%u%u%u%u\n",
1581 atp->atrti_flags & ATR_TI_HAVE_TD ? 1 : 0,
1582 atp->atrti_flags & ATR_TI_HAVE_TC ? 1 : 0,
1583 atp->atrti_flags & ATR_TI_HAVE_TB ? 1 : 0,
1584 atp->atrti_flags & ATR_TI_HAVE_TA ? 1 : 0);
1585
1586 atr_data_dump_ta(atp, out, level);
1587 atr_data_dump_tb(atp, out, level);
1588 atr_data_dump_tc(atp, out, level);
1589 if (atp->atrti_flags & ATR_TI_HAVE_TD) {
1590 (void) fprintf(out, " v\n");
1591 }
1592 }
1593
1594 atr_data_dump_historical(data, out);
1595
1596 if (data->atr_flags & ATR_F_HAS_CHECKSUM) {
1597 (void) fprintf(out, "TCK 0x%02x\n", data->atr_cksum);
1598 } else {
1599 (void) fprintf(out, "TCK ----; Checksum not present\n");
1600 }
1601
1602 }
1603 #endif /* _KERNEL */
1604