scd/atr.c

   1 /* atr.c - ISO 7816 ATR fucntions
   2  *      Copyright (C) 2003 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21 #include <errno.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <assert.h>
  26
  27 #include "scdaemon.h"
  28 #include "apdu.h"
  29 #include "atr.h"
  30 #include "dynload.h"
  31
  32 static int const fi_table[16] = { 0, 372, 558, 744, 1116,1488, 1860, -1,
  33                                   -1, 512, 768, 1024, 1536, 2048, -1, -1 };
  34 static int const di_table[16] = { -1, 1, 2, 4, 8, 16, -1, -1,
  35                                   0, -1, -2, -4, -8, -16, -32, -64};
  36
  37
  38 /* Dump the ATR of the card at SLOT in a human readable format to
  39    stream FP.  */
  40 int
  41 atr_dump (int slot, FILE *fp)
  42 {
  43   unsigned char *atrbuffer, *atr;
  44   size_t atrlen;
  45   int have_ta, have_tb, have_tc, have_td;
  46   int n_historical;
  47   int idx, val;
  48   unsigned char chksum;
  49
  50   atr = atrbuffer = apdu_get_atr (slot, &atrlen);
  51   if (!atr)
  52     return gpg_error (GPG_ERR_GENERAL);
  53
  54   fprintf (fp, "Info on ATR of length %u at slot %d\n",
  55            (unsigned int)atrlen, slot);
  56   if (!atrlen)
  57     {
  58       fprintf (fp, "error: empty ATR\n");
  59       goto bailout;
  60     }
  61
  62
  63   if (*atr == 0x3b)
  64     fputs ("direct convention\n", fp);
  65   else if (*atr == 0x3f)
  66     fputs ("inverse convention\n", fp);
  67   else
  68     fprintf (fp,"error: invalid TS character 0x%02x\n", *atr);
  69   if (!--atrlen)
  70     goto bailout;
  71   atr++;
  72
  73   chksum = *atr;
  74   for (idx=1; idx < atrlen-1; idx++)
  75     chksum ^= atr[idx];
  76
  77   have_ta = !!(*atr & 0x10);
  78   have_tb = !!(*atr & 0x20);
  79   have_tc = !!(*atr & 0x40);
  80   have_td = !!(*atr & 0x80);
  81   n_historical = (*atr & 0x0f);
  82   fprintf (fp, "%d historical characters indicated\n", n_historical);
  83
  84   if (have_ta + have_tb + have_tc + have_td + n_historical > atrlen)
  85     fputs ("error: ATR shorter than indicated by format character\n", fp);
  86   if (!--atrlen)
  87     goto bailout;
  88   atr++;
  89
  90   if (have_ta)
  91     {
  92       fputs ("TA1: F=", fp);
  93       val = fi_table[(*atr >> 4) & 0x0f];
  94       if (!val)
  95         fputs ("internal clock", fp);
  96       else if (val == -1)
  97         fputs ("RFU", fp);
  98       else
  99         fprintf (fp, "%d", val);
 100       fputs (" D=", fp);
 101       val = di_table[*atr & 0x0f];
 102       if (!val)
 103         fputs ("[impossible value]\n", fp);
 104       else if (val == -1)
 105         fputs ("RFU\n", fp);
 106       else if (val < 0 )
 107         fprintf (fp, "1/%d\n", val);
 108       else
 109         fprintf (fp, "%d\n", val);
 110
 111       if (!--atrlen)
 112         goto bailout;
 113       atr++;
 114     }
 115
 116   if (have_tb)
 117     {
 118       fprintf (fp, "TB1: II=%d PI1=%d%s\n", (*atr >> 5) & 3, *atr & 0x1f,
 119                (*atr & 0x80)? " [high bit not cleared]":"");
 120       if (!--atrlen)
 121         goto bailout;
 122       atr++;
 123     }
 124
 125   if (have_tc)
 126     {
 127       if (*atr == 255)
 128         fputs ("TC1: guard time shortened to 1 etu\n", fp);
 129       else
 130         fprintf (fp, "TC1: (extra guard time) N=%d\n", *atr);
 131
 132       if (!--atrlen)
 133         goto bailout;
 134       atr++;
 135     }
 136
 137   if (have_td)
 138     {
 139       have_ta = !!(*atr & 0x10);
 140       have_tb = !!(*atr & 0x20);
 141       have_tc = !!(*atr & 0x40);
 142       have_td = !!(*atr & 0x80);
 143       fprintf (fp, "TD1: protocol T%d supported\n", *atr & 0x0f);
 144
 145       if (have_ta + have_tb + have_tc + have_td + n_historical > atrlen)
 146         fputs ("error: ATR shorter than indicated by format character\n", fp);
 147
 148       if (!--atrlen)
 149         goto bailout;
 150       atr++;
 151     }
 152   else
 153     have_ta = have_tb = have_tc = have_td = 0;
 154
 155   if (have_ta)
 156     {
 157       fprintf (fp, "TA2: (PTS) %stoggle, %splicit, T=%02X\n",
 158                (*atr & 0x80)? "no-":"",
 159                (*atr & 0x10)? "im": "ex",
 160                (*atr & 0x0f));
 161       if ((*atr & 0x60))
 162         fprintf (fp, "note: reserved bits are set (TA2=0x%02X)\n", *atr);
 163       if (!--atrlen)
 164         goto bailout;
 165       atr++;
 166     }
 167
 168   if (have_tb)
 169     {
 170       fprintf (fp, "TB2: PI2=%d\n", *atr);
 171       if (!--atrlen)
 172         goto bailout;
 173       atr++;
 174     }
 175
 176   if (have_tc)
 177     {
 178       fprintf (fp, "TC2: PWI=%d\n", *atr);
 179       if (!--atrlen)
 180         goto bailout;
 181       atr++;
 182     }
 183
 184   if (have_td)
 185     {
 186       have_ta = !!(*atr & 0x10);
 187       have_tb = !!(*atr & 0x20);
 188       have_tc = !!(*atr & 0x40);
 189       have_td = !!(*atr & 0x80);
 190       fprintf (fp, "TD2: protocol T%d supported\n", *atr & 0x0f);
 191
 192       if (have_ta + have_tb + have_tc + have_td + n_historical > atrlen)
 193         fputs ("error: ATR shorter than indicated by format character\n", fp);
 194
 195       if (!--atrlen)
 196         goto bailout;
 197       atr++;
 198     }
 199   else
 200     have_ta = have_tb = have_tc = have_td = 0;
 201
 202   for (idx = 3; have_ta || have_tb || have_tc || have_td; idx++)
 203     {
 204       if (have_ta)
 205         {
 206           fprintf (fp, "TA%d: IFSC=%d\n", idx, *atr);
 207           if (!--atrlen)
 208             goto bailout;
 209           atr++;
 210         }
 211
 212       if (have_tb)
 213         {
 214           fprintf (fp, "TB%d: BWI=%d CWI=%d\n",
 215                    idx, (*atr >> 4) & 0x0f, *atr & 0x0f);
 216           if (!--atrlen)
 217             goto bailout;
 218           atr++;
 219         }
 220
 221       if (have_tc)
 222         {
 223           fprintf (fp, "TC%d: 0x%02X\n", idx, *atr);
 224           if (!--atrlen)
 225             goto bailout;
 226           atr++;
 227         }
 228
 229       if (have_td)
 230         {
 231           have_ta = !!(*atr & 0x10);
 232           have_tb = !!(*atr & 0x20);
 233           have_tc = !!(*atr & 0x40);
 234           have_td = !!(*atr & 0x80);
 235           fprintf (fp, "TD%d: protocol T%d supported\n", idx, *atr & 0x0f);
 236
 237           if (have_ta + have_tb + have_tc + have_td + n_historical > atrlen)
 238             fputs ("error: ATR shorter than indicated by format character\n",
 239                    fp);
 240
 241           if (!--atrlen)
 242             goto bailout;
 243           atr++;
 244         }
 245       else
 246         have_ta = have_tb = have_tc = have_td = 0;
 247     }
 248
 249   if (n_historical + 1 > atrlen)
 250     fputs ("error: ATR shorter than required for historical bytes "
 251            "and checksum\n", fp);
 252
 253   if (n_historical)
 254     {
 255       fputs ("Historical:", fp);
 256       for (; n_historical && atrlen ; n_historical--, atrlen--, atr++)
 257         fprintf (fp, " %02X", *atr);
 258       putchar ('\n');
 259     }
 260
 261   if (!atrlen)
 262     fputs ("error: checksum missing\n", fp);
 263   else if (*atr == chksum)
 264     fprintf (fp, "TCK: %02X (good)\n", *atr);
 265   else
 266     fprintf (fp, "TCK: %02X (bad; calculated %02X)\n", *atr, chksum);
 267
 268   atrlen--;
 269   if (atrlen)
 270     fprintf (fp, "error: %u bytes garbage at end of ATR\n",
 271              (unsigned int)atrlen );
 272
 273  bailout:
 274   xfree (atrbuffer);
 275
 276   return 0;
 277 }
 278
 279
 280 /* Note: This code has not yet been tested!  It shall return -1 on
 281    error or the number of historical bytes and store them at
 282    HISTORICAL.  */
 283 int
 284 atr_get_historical (int slot, unsigned char historical[])
 285 {
 286   int result = -1;
 287   unsigned char *atrbuffer = NULL;
 288   unsigned char *atr;
 289   size_t atrlen;
 290   int have_ta, have_tb, have_tc, have_td;
 291   int n_historical;
 292   int idx;
 293   unsigned char chksum;
 294
 295   atr = atrbuffer = apdu_get_atr (slot, &atrlen);
 296   if (!atr || atrlen < 2)
 297     goto leave;
 298   atrlen--;
 299   atr++;
 300
 301   chksum = *atr;
 302   for (idx=1; idx < atrlen-1; idx++)
 303     chksum ^= atr[idx];
 304
 305   have_ta = !!(*atr & 0x10);
 306   have_tb = !!(*atr & 0x20);
 307   have_tc = !!(*atr & 0x40);
 308   have_td = !!(*atr & 0x80);
 309   n_historical = (*atr & 0x0f);
 310
 311   if (have_ta + have_tb + have_tc + have_td + n_historical >= atrlen)
 312     goto leave; /* ATR shorter than indicated by format character.  */
 313   atrlen--;
 314   atr++;
 315
 316   if (have_ta + have_tb + have_tc >= atrlen)
 317     goto leave;
 318   atrlen -= have_ta + have_tb + have_tc;
 319   atr    += have_ta + have_tb + have_tc;
 320
 321   if (have_td)
 322     {
 323       have_ta = !!(*atr & 0x10);
 324       have_tb = !!(*atr & 0x20);
 325       have_tc = !!(*atr & 0x40);
 326       have_td = !!(*atr & 0x80);
 327       if (have_ta + have_tb + have_tc + have_td + n_historical >= atrlen)
 328         goto leave; /* ATR shorter than indicated by format character.  */
 329       atrlen--;
 330       atr++;
 331     }
 332   else
 333     have_ta = have_tb = have_tc = have_td = 0;
 334
 335   if (have_ta + have_tb + have_tc >= atrlen)
 336     goto leave;
 337   atrlen -= have_ta + have_tb + have_tc;
 338   atr    += have_ta + have_tb + have_tc;
 339
 340   if (have_td)
 341     {
 342       have_ta = !!(*atr & 0x10);
 343       have_tb = !!(*atr & 0x20);
 344       have_tc = !!(*atr & 0x40);
 345       have_td = !!(*atr & 0x80);
 346       if (have_ta + have_tb + have_tc + have_td + n_historical >= atrlen)
 347         goto leave; /* ATR shorter than indicated by format character.  */
 348       atrlen--;
 349       atr++;
 350     }
 351   else
 352     have_ta = have_tb = have_tc = have_td = 0;
 353
 354   for (idx = 3; have_ta || have_tb || have_tc || have_td; idx++)
 355     {
 356       if (have_ta + have_tb + have_tc >= atrlen)
 357         goto leave;
 358       atrlen -= have_ta + have_tb + have_tc;
 359       atr    += have_ta + have_tb + have_tc;
 360
 361       if (have_td)
 362         {
 363           have_ta = !!(*atr & 0x10);
 364           have_tb = !!(*atr & 0x20);
 365           have_tc = !!(*atr & 0x40);
 366           have_td = !!(*atr & 0x80);
 367           if (have_ta + have_tb + have_tc + have_td + n_historical >= atrlen)
 368             goto leave; /* ATR shorter than indicated by format character.  */
 369           atrlen--;
 370           atr++;
 371         }
 372       else
 373         have_ta = have_tb = have_tc = have_td = 0;
 374     }
 375
 376   if (n_historical >= atrlen)
 377     goto leave; /* ATR shorter than required for historical bytes. */
 378
 379   if (n_historical)
 380     {
 381       for (idx=0; n_historical && atrlen; n_historical--, atrlen--, atr++)
 382         historical[idx] = *atr;
 383     }
 384
 385   if (!atrlen || *atr != chksum)
 386     goto leave;
 387
 388   /* Don't care about garbage at the end of the ATR.  */
 389
 390   result = n_historical;
 391
 392  leave:
 393   xfree (atrbuffer);
 394
 395   return result;
 396 }
 397