scd/app-geldkarte.c

   1 /* app-geldkarte.c - The German Geldkarte application
   2  * Copyright (C) 2004 g10 Code GmbH
   3  * Copyright (C) 2009 Free Software Foundation, Inc.
   4  *
   5  * This file is part of GnuPG.
   6  *
   7  * GnuPG is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * GnuPG is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 /* This is a read-only application to quickly dump information of a
  23    German Geldkarte (debit card for small amounts).  We only support
  24    newer Geldkarte (with the AID DF_BOERSE_NEU) issued since 2000 or
  25    even earlier.
  26 */
  27
  28
  29 #include <config.h>
  30 #include <errno.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <assert.h>
  35 #include <time.h>
  36 #include <ctype.h>
  37
  38 #include "scdaemon.h"
  39
  40 #include "i18n.h"
  41 #include "iso7816.h"
  42 #include "app-common.h"
  43 #include "tlv.h"
  44
  45
  46
  47 /* Object with application (i.e. Geldkarte) specific data.  */
  48 struct app_local_s
  49 {
  50   char kblz[2+1+4+1];
  51   const char *banktype;
  52   char *cardno;
  53   char expires[7+1];
  54   char validfrom[10+1];
  55   char *country;
  56   char currency[3+1];
  57   unsigned int currency_mult100;
  58   unsigned char chipid;
  59   unsigned char osvers;
  60   int balance;
  61   int maxamount;
  62   int maxamount1;
  63 };
  64
  65
  66
  67 \f
  68 /* Deconstructor. */
  69 static void
  70 do_deinit (app_t app)
  71 {
  72   if (app && app->app_local)
  73     {
  74       xfree (app->app_local->cardno);
  75       xfree (app->app_local->country);
  76       xfree (app->app_local);
  77       app->app_local = NULL;
  78     }
  79 }
  80
  81
  82 static gpg_error_t
  83 send_one_string (ctrl_t ctrl, const char *name, const char *string)
  84 {
  85   if (!name || !string)
  86     return 0;
  87   send_status_info (ctrl, name, string, strlen (string), NULL, 0);
  88   return 0;
  89 }
  90
  91 /* Implement the GETATTR command.  This is similar to the LEARN
  92    command but returns just one value via the status interface. */
  93 static gpg_error_t
  94 do_getattr (app_t app, ctrl_t ctrl, const char *name)
  95 {
  96   gpg_error_t err;
  97   struct app_local_s *ld = app->app_local;
  98   char numbuf[100];
  99
 100   if (!strcmp (name, "X-KBLZ"))
 101     err = send_one_string (ctrl, name, ld->kblz);
 102   else if (!strcmp (name, "X-BANKINFO"))
 103     err = send_one_string (ctrl, name, ld->banktype);
 104   else if (!strcmp (name, "X-CARDNO"))
 105     err = send_one_string (ctrl, name, ld->cardno);
 106   else if (!strcmp (name, "X-EXPIRES"))
 107     err = send_one_string (ctrl, name, ld->expires);
 108   else if (!strcmp (name, "X-VALIDFROM"))
 109     err = send_one_string (ctrl, name, ld->validfrom);
 110   else if (!strcmp (name, "X-COUNTRY"))
 111     err = send_one_string (ctrl, name, ld->country);
 112   else if (!strcmp (name, "X-CURRENCY"))
 113     err = send_one_string (ctrl, name, ld->currency);
 114   else if (!strcmp (name, "X-ZKACHIPID"))
 115     {
 116       snprintf (numbuf, sizeof numbuf, "0x%02X", ld->chipid);
 117       err = send_one_string (ctrl, name, numbuf);
 118     }
 119   else if (!strcmp (name, "X-OSVERSION"))
 120     {
 121       snprintf (numbuf, sizeof numbuf, "0x%02X", ld->osvers);
 122       err = send_one_string (ctrl, name, numbuf);
 123     }
 124   else if (!strcmp (name, "X-BALANCE"))
 125     {
 126       snprintf (numbuf, sizeof numbuf, "%.2f",
 127                 (double)ld->balance / 100 * ld->currency_mult100);
 128       err = send_one_string (ctrl, name, numbuf);
 129     }
 130   else if (!strcmp (name, "X-MAXAMOUNT"))
 131     {
 132       snprintf (numbuf, sizeof numbuf, "%.2f",
 133                 (double)ld->maxamount / 100 * ld->currency_mult100);
 134       err = send_one_string (ctrl, name, numbuf);
 135     }
 136   else if (!strcmp (name, "X-MAXAMOUNT1"))
 137     {
 138       snprintf (numbuf, sizeof numbuf, "%.2f",
 139                 (double)ld->maxamount1 / 100 * ld->currency_mult100);
 140       err = send_one_string (ctrl, name, numbuf);
 141     }
 142   else
 143     err = gpg_error (GPG_ERR_INV_NAME);
 144
 145   return err;
 146 }
 147
 148
 149 static gpg_error_t
 150 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
 151 {
 152   static const char *names[] = {
 153     "X-KBLZ",
 154     "X-BANKINFO",
 155     "X-CARDNO",
 156     "X-EXPIRES",
 157     "X-VALIDFROM",
 158     "X-COUNTRY",
 159     "X-CURRENCY",
 160     "X-ZKACHIPID",
 161     "X-OSVERSION",
 162     "X-BALANCE",
 163     "X-MAXAMOUNT",
 164     "X-MAXAMOUNT1",
 165     NULL
 166   };
 167   gpg_error_t err = 0;
 168   int idx;
 169
 170   (void)flags;
 171
 172   for (idx=0; names[idx] && !err; idx++)
 173     err = do_getattr (app, ctrl, names[idx]);
 174   return err;
 175 }
 176
 177
 178 static char *
 179 copy_bcd (const unsigned char *string, size_t length)
 180 {
 181   const unsigned char *s;
 182   size_t n;
 183   size_t needed;
 184   char *buffer, *dst;
 185
 186   if (!length)
 187     return xtrystrdup ("");
 188
 189   /* Skip leading zeroes. */
 190   for (; length && !*string; length--, string++)
 191     ;
 192   s = string;
 193   n = length;
 194   needed = 0;
 195   for (; n ; n--, s++)
 196     {
 197       if (!needed && !(*s & 0xf0))
 198         ; /* Skip the leading zero in the first nibble.  */
 199       else
 200         {
 201           if ( ((*s >> 4) & 0x0f) > 9 )
 202             {
 203               errno = EINVAL;
 204               return NULL;
 205             }
 206           needed++;
 207         }
 208       if ( n == 1 && (*s & 0x0f) > 9 )
 209         ; /* Ignore the last digit if it has the sign.  */
 210       else
 211         {
 212           needed++;
 213           if ( (*s & 0x0f) > 9 )
 214             {
 215               errno = EINVAL;
 216               return NULL;
 217             }
 218         }
 219
 220     }
 221   if (!needed) /* If it is all zero, print a "0". */
 222     needed++;
 223
 224   buffer = dst = xtrymalloc (needed+1);
 225   if (!buffer)
 226     return NULL;
 227
 228   s = string;
 229   n = length;
 230   needed = 0;
 231   for (; n ; n--, s++)
 232     {
 233       if (!needed && !(*s & 0xf0))
 234         ; /* Skip the leading zero in the first nibble.  */
 235       else
 236         {
 237           *dst++ = '0' + ((*s >> 4) & 0x0f);
 238           needed++;
 239         }
 240
 241       if ( n == 1 && (*s & 0x0f) > 9 )
 242         ; /* Ignore the last digit if it has the sign.  */
 243       else
 244         {
 245           *dst++ = '0' + (*s & 0x0f);
 246           needed++;
 247         }
 248     }
 249   if (!needed)
 250     *dst++ = '0';
 251   *dst = 0;
 252
 253   return buffer;
 254 }
 255
 256
 257 /* Convert the BCD number at STING of LENGTH into an integer and store
 258    that at RESULT.  Return 0 on success.  */
 259 static gpg_error_t
 260 bcd_to_int (const unsigned char *string, size_t length, int *result)
 261 {
 262   char *tmp;
 263
 264   tmp = copy_bcd (string, length);
 265   if (!tmp)
 266     return gpg_error (GPG_ERR_BAD_DATA);
 267   *result = strtol (tmp, NULL, 10);
 268   xfree (tmp);
 269   return 0;
 270 }
 271
 272
 273 /* Select the Geldkarte application.  */
 274 gpg_error_t
 275 app_select_geldkarte (app_t app)
 276 {
 277   static char const aid[] =
 278     { 0xD2, 0x76, 0x00, 0x00, 0x25, 0x45, 0x50, 0x02, 0x00 };
 279   gpg_error_t err;
 280   int slot = app->slot;
 281   unsigned char *result = NULL;
 282   size_t resultlen;
 283   struct app_local_s *ld;
 284   const char *banktype;
 285
 286   err = iso7816_select_application (slot, aid, sizeof aid, 0);
 287   if (err)
 288     goto leave;
 289
 290   /* Read the first record of EF_ID (SFI=0x17).  We require this
 291      record to be at least 24 bytes with the the first byte 0x67 and a
 292      correct filler byte. */
 293   err = iso7816_read_record (slot, 1, 1, ((0x17 << 3)|4), &result, &resultlen);
 294   if (err)
 295     goto leave;  /* Oops - not a Geldkarte.  */
 296   if (resultlen < 24 || *result != 0x67 || result[22])
 297     {
 298       err = gpg_error (GPG_ERR_NOT_FOUND);
 299       goto leave;
 300     }
 301
 302   /* The short Bankleitzahl consists of 3 bytes at offset 1.  */
 303   switch (result[1])
 304     {
 305     case 0x21: banktype = "Oeffentlich-rechtliche oder private Bank"; break;
 306     case 0x22: banktype = "Privat- oder Geschaeftsbank"; break;
 307     case 0x25: banktype = "Sparkasse"; break;
 308     case 0x26:
 309     case 0x29: banktype = "Genossenschaftsbank"; break;
 310     default:
 311       err = gpg_error (GPG_ERR_NOT_FOUND);
 312       goto leave; /* Probably not a Geldkarte. */
 313     }
 314
 315   app->apptype = "GELDKARTE";
 316   app->fnc.deinit = do_deinit;
 317
 318   /* If we don't have a serialno yet construct it from the EF_ID.  */
 319   if (!app->serialno)
 320     {
 321       app->serialno = xtrymalloc (10);
 322       if (!app->serialno)
 323         {
 324           err = gpg_error_from_syserror ();
 325           goto leave;
 326         }
 327       memcpy (app->serialno, result, 10);
 328       app->serialnolen = 10;
 329       err = app_munge_serialno (app);
 330       if (err)
 331         goto leave;
 332     }
 333
 334
 335   app->app_local = ld = xtrycalloc (1, sizeof *app->app_local);
 336   if (!app->app_local)
 337     {
 338       err = gpg_err_code_from_syserror ();
 339       goto leave;
 340     }
 341
 342   snprintf (ld->kblz, sizeof ld->kblz, "%02X-%02X%02X",
 343             result[1], result[2], result[3]);
 344   ld->banktype = banktype;
 345   ld->cardno = copy_bcd (result+4, 5);
 346   if (!ld->cardno)
 347     {
 348       err = gpg_err_code_from_syserror ();
 349       goto leave;
 350     }
 351
 352   snprintf (ld->expires, sizeof ld->expires, "20%02X-%02X",
 353             result[10], result[11]);
 354   snprintf (ld->validfrom, sizeof ld->validfrom, "20%02X-%02X-%02X",
 355             result[12], result[13], result[14]);
 356
 357   ld->country = copy_bcd (result+15, 2);
 358   if (!ld->country)
 359     {
 360       err = gpg_err_code_from_syserror ();
 361       goto leave;
 362     }
 363
 364   snprintf (ld->currency, sizeof ld->currency, "%c%c%c",
 365             isascii (result[17])? result[17]:' ',
 366             isascii (result[18])? result[18]:' ',
 367             isascii (result[19])? result[19]:' ');
 368
 369   ld->currency_mult100 = (result[20] == 0x01? 1:
 370                           result[20] == 0x02? 10:
 371                           result[20] == 0x04? 100:
 372                           result[20] == 0x08? 1000:
 373                           result[20] == 0x10? 10000:
 374                           result[20] == 0x20? 100000:0);
 375
 376   ld->chipid = result[21];
 377   ld->osvers = result[23];
 378
 379   /* Read the first record of EF_BETRAG (SFI=0x18). */
 380   xfree (result);
 381   err = iso7816_read_record (slot, 1, 1, ((0x18 << 3)|4), &result, &resultlen);
 382   if (err)
 383     goto leave;  /* It does not make sense to continue.  */
 384   if (resultlen < 12)
 385     {
 386       err = gpg_error (GPG_ERR_NOT_FOUND);
 387       goto leave;
 388     }
 389   err = bcd_to_int (result+0, 3, &ld->balance);
 390   if (!err)
 391     err = bcd_to_int (result+3, 3, &ld->maxamount);
 392   if (!err)
 393     err = bcd_to_int (result+6, 3, &ld->maxamount1);
 394   /* The next 3 bytes are the maximum amount chargable without using a
 395      MAC.  This is usually 0.  */
 396   if (err)
 397     goto leave;
 398
 399   /* Setup the rest of the methods.  */
 400   app->fnc.learn_status = do_learn_status;
 401   app->fnc.getattr = do_getattr;
 402
 403
 404  leave:
 405   xfree (result);
 406   if (err)
 407     do_deinit (app);
 408   return err;
 409 }