scd/app-openpgp.c

   1 /* app-openpgp.c - The OpenPGP card application.
   2  * Copyright (C) 2003, 2004, 2005, 2007, 2008,
   3  *               2009, 2013 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 /* Some notes:
  22
  23    CHV means Card Holder Verification and is nothing else than a PIN
  24    or password.  That term seems to have been used originally with GSM
  25    cards.  Version v2 of the specs changes the term to the clearer
  26    term PW for password.  We use the terms here interchangeable
  27    because we do not want to change existing strings i18n wise.
  28
  29    Version 2 of the specs also drops the separate PW2 which was
  30    required in v1 due to ISO requirements.  It is now possible to have
  31    one physical PW but two reference to it so that they can be
  32    individually be verified (e.g. to implement a forced verification
  33    for one key).  Thus you will noticed the use of PW2 with the verify
  34    command but not with change_reference_data because the latter
  35    operates directly on the physical PW.
  36
  37    The Reset Code (RC) as implemented by v2 cards uses the same error
  38    counter as the PW2 of v1 cards.  By default no RC is set and thus
  39    that error counter is set to 0.  After setting the RC the error
  40    counter will be initialized to 3.
  41
  42  */
  43
  44 #include <config.h>
  45 #include <errno.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <assert.h>
  50 #include <time.h>
  51
  52 #if GNUPG_MAJOR_VERSION == 1
  53 /* This is used with GnuPG version < 1.9.  The code has been source
  54    copied from the current GnuPG >= 1.9  and is maintained over
  55    there. */
  56 #include "options.h"
  57 #include "errors.h"
  58 #include "memory.h"
  59 #include "util.h"
  60 #include "cardglue.h"
  61 #else /* GNUPG_MAJOR_VERSION != 1 */
  62 #include "scdaemon.h"
  63 #endif /* GNUPG_MAJOR_VERSION != 1 */
  64
  65 #include "i18n.h"
  66 #include "iso7816.h"
  67 #include "app-common.h"
  68 #include "tlv.h"
  69 #include "host2net.h"
  70 #include "cipher.h"
  71
  72
  73 /* A table describing the DOs of the card.  */
  74 static struct {
  75   int tag;
  76   int constructed;
  77   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
  78   int binary:1;
  79   int dont_cache:1;
  80   int flush_on_error:1;
  81   int get_immediate_in_v11:1; /* Enable a hack to bypass the cache of
  82                                  this data object if it is used in 1.1
  83                                  and later versions of the card.  This
  84                                  does not work with composite DO and
  85                                  is currently only useful for the CHV
  86                                  status bytes. */
  87   int try_extlen:1;           /* Large object; try to use an extended
  88                                  length APDU.  */
  89   char *desc;
  90 } data_objects[] = {
  91   { 0x005E, 0,    0, 1, 0, 0, 0, 0, "Login Data" },
  92   { 0x5F50, 0,    0, 0, 0, 0, 0, 0, "URL" },
  93   { 0x5F52, 0,    0, 1, 0, 0, 0, 0, "Historical Bytes" },
  94   { 0x0065, 1,    0, 1, 0, 0, 0, 0, "Cardholder Related Data"},
  95   { 0x005B, 0, 0x65, 0, 0, 0, 0, 0, "Name" },
  96   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, 0, "Language preferences" },
  97   { 0x5F35, 0, 0x65, 0, 0, 0, 0, 0, "Sex" },
  98   { 0x006E, 1,    0, 1, 0, 0, 0, 0, "Application Related Data" },
  99   { 0x004F, 0, 0x6E, 1, 0, 0, 0, 0, "AID" },
 100   { 0x0073, 1,    0, 1, 0, 0, 0, 0, "Discretionary Data Objects" },
 101   { 0x0047, 0, 0x6E, 1, 1, 0, 0, 0, "Card Capabilities" },
 102   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, 0, "Extended Card Capabilities" },
 103   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Signature" },
 104   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Decryption" },
 105   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Authentication" },
 106   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, 0, "CHV Status Bytes" },
 107   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, 0, "Fingerprints" },
 108   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, 0, "CA Fingerprints" },
 109   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, 0, "Generation time" },
 110   { 0x007A, 1,    0, 1, 0, 0, 0, 0, "Security Support Template" },
 111   { 0x0093, 0, 0x7A, 1, 1, 0, 0, 0, "Digital Signature Counter" },
 112   { 0x0101, 0,    0, 0, 0, 0, 0, 0, "Private DO 1"},
 113   { 0x0102, 0,    0, 0, 0, 0, 0, 0, "Private DO 2"},
 114   { 0x0103, 0,    0, 0, 0, 0, 0, 0, "Private DO 3"},
 115   { 0x0104, 0,    0, 0, 0, 0, 0, 0, "Private DO 4"},
 116   { 0x7F21, 1,    0, 1, 0, 0, 0, 1, "Cardholder certificate"},
 117   { 0 }
 118 };
 119
 120
 121 /* The format of RSA private keys.  */
 122 typedef enum
 123   {
 124     RSA_UNKNOWN_FMT,
 125     RSA_STD,
 126     RSA_STD_N,
 127     RSA_CRT,
 128     RSA_CRT_N
 129   }
 130 rsa_key_format_t;
 131
 132
 133 /* One cache item for DOs.  */
 134 struct cache_s {
 135   struct cache_s *next;
 136   int tag;
 137   size_t length;
 138   unsigned char data[1];
 139 };
 140
 141
 142 /* Object with application (i.e. OpenPGP card) specific data.  */
 143 struct app_local_s {
 144   /* A linked list with cached DOs.  */
 145   struct cache_s *cache;
 146
 147   /* Keep track of the public keys.  */
 148   struct
 149   {
 150     int read_done;   /* True if we have at least tried to read them.  */
 151     unsigned char *key; /* This is a malloced buffer with a canonical
 152                            encoded S-expression encoding a public
 153                            key. Might be NULL if key is not
 154                            available.  */
 155     size_t keylen;      /* The length of the above S-expression.  This
 156                            is usually only required for cross checks
 157                            because the length of an S-expression is
 158                            implicitly available.  */
 159   } pk[3];
 160
 161   unsigned char status_indicator; /* The card status indicator.  */
 162
 163   unsigned int manufacturer:16;   /* Manufacturer ID from the s/n.  */
 164
 165   /* Keep track of the ISO card capabilities.  */
 166   struct
 167   {
 168     unsigned int cmd_chaining:1;  /* Command chaining is supported.  */
 169     unsigned int ext_lc_le:1;     /* Extended Lc and Le are supported.  */
 170   } cardcap;
 171
 172   /* Keep track of extended card capabilities.  */
 173   struct
 174   {
 175     unsigned int is_v2:1;              /* This is a v2.0 compatible card.  */
 176     unsigned int get_challenge:1;
 177     unsigned int key_import:1;
 178     unsigned int change_force_chv:1;
 179     unsigned int private_dos:1;
 180     unsigned int algo_attr_change:1;   /* Algorithm attributes changeable.  */
 181     unsigned int sm_supported:1;       /* Secure Messaging is supported.  */
 182     unsigned int sm_aes128:1;          /* Use AES-128 for SM.  */
 183     unsigned int max_certlen_3:16;
 184     unsigned int max_get_challenge:16; /* Maximum size for get_challenge.  */
 185   } extcap;
 186
 187   /* Flags used to control the application.  */
 188   struct
 189   {
 190     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
 191     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
 192   } flags;
 193
 194   /* Pinpad request specified on card.  */
 195   struct
 196   {
 197     unsigned int specified:1;
 198     int fixedlen_user;
 199     int fixedlen_admin;
 200   } pinpad;
 201
 202   struct
 203   {
 204     unsigned int n_bits;     /* Size of the modulus in bits.  The rest
 205                                 of this strucuire is only valid if
 206                                 this is not 0.  */
 207     unsigned int e_bits;     /* Size of the public exponent in bits.  */
 208     rsa_key_format_t format;
 209   } keyattr[3];
 210
 211 };
 212
 213
 214
 215 /***** Local prototypes  *****/
 216 static unsigned long convert_sig_counter_value (const unsigned char *value,
 217                                                 size_t valuelen);
 218 static unsigned long get_sig_counter (app_t app);
 219 static gpg_error_t do_auth (app_t app, const char *keyidstr,
 220                             gpg_error_t (*pincb)(void*, const char *, char **),
 221                             void *pincb_arg,
 222                             const void *indata, size_t indatalen,
 223                             unsigned char **outdata, size_t *outdatalen);
 224 static void parse_algorithm_attribute (app_t app, int keyno);
 225 static gpg_error_t change_keyattr_from_string
 226                            (app_t app,
 227                             gpg_error_t (*pincb)(void*, const char *, char **),
 228                             void *pincb_arg,
 229                             const void *value, size_t valuelen);
 230
 231
 232
 233
 234 \f
 235 /* Deconstructor. */
 236 static void
 237 do_deinit (app_t app)
 238 {
 239   if (app && app->app_local)
 240     {
 241       struct cache_s *c, *c2;
 242       int i;
 243
 244       for (c = app->app_local->cache; c; c = c2)
 245         {
 246           c2 = c->next;
 247           xfree (c);
 248         }
 249
 250       for (i=0; i < DIM (app->app_local->pk); i++)
 251         {
 252           xfree (app->app_local->pk[i].key);
 253           app->app_local->pk[i].read_done = 0;
 254         }
 255       xfree (app->app_local);
 256       app->app_local = NULL;
 257     }
 258 }
 259
 260
 261 /* Wrapper around iso7816_get_data which first tries to get the data
 262    from the cache.  With GET_IMMEDIATE passed as true, the cache is
 263    bypassed.  With TRY_EXTLEN extended lengths APDUs are use if
 264    supported by the card.  */
 265 static gpg_error_t
 266 get_cached_data (app_t app, int tag,
 267                  unsigned char **result, size_t *resultlen,
 268                  int get_immediate, int try_extlen)
 269 {
 270   gpg_error_t err;
 271   int i;
 272   unsigned char *p;
 273   size_t len;
 274   struct cache_s *c;
 275   int exmode;
 276
 277   *result = NULL;
 278   *resultlen = 0;
 279
 280   if (!get_immediate)
 281     {
 282       for (c=app->app_local->cache; c; c = c->next)
 283         if (c->tag == tag)
 284           {
 285             if(c->length)
 286               {
 287                 p = xtrymalloc (c->length);
 288                 if (!p)
 289                   return gpg_error (gpg_err_code_from_errno (errno));
 290                 memcpy (p, c->data, c->length);
 291                 *result = p;
 292               }
 293
 294             *resultlen = c->length;
 295
 296             return 0;
 297           }
 298     }
 299
 300   if (try_extlen && app->app_local->cardcap.ext_lc_le)
 301     exmode = app->app_local->extcap.max_certlen_3;
 302   else
 303     exmode = 0;
 304
 305   err = iso7816_get_data (app->slot, exmode, tag, &p, &len);
 306   if (err)
 307     return err;
 308   *result = p;
 309   *resultlen = len;
 310
 311   /* Check whether we should cache this object. */
 312   if (get_immediate)
 313     return 0;
 314
 315   for (i=0; data_objects[i].tag; i++)
 316     if (data_objects[i].tag == tag)
 317       {
 318         if (data_objects[i].dont_cache)
 319           return 0;
 320         break;
 321       }
 322
 323   /* Okay, cache it. */
 324   for (c=app->app_local->cache; c; c = c->next)
 325     assert (c->tag != tag);
 326
 327   c = xtrymalloc (sizeof *c + len);
 328   if (c)
 329     {
 330       memcpy (c->data, p, len);
 331       c->length = len;
 332       c->tag = tag;
 333       c->next = app->app_local->cache;
 334       app->app_local->cache = c;
 335     }
 336
 337   return 0;
 338 }
 339
 340 /* Remove DO at TAG from the cache. */
 341 static void
 342 flush_cache_item (app_t app, int tag)
 343 {
 344   struct cache_s *c, *cprev;
 345   int i;
 346
 347   if (!app->app_local)
 348     return;
 349
 350   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
 351     if (c->tag == tag)
 352       {
 353         if (cprev)
 354           cprev->next = c->next;
 355         else
 356           app->app_local->cache = c->next;
 357         xfree (c);
 358
 359         for (c=app->app_local->cache; c ; c = c->next)
 360           {
 361             assert (c->tag != tag); /* Oops: duplicated entry. */
 362           }
 363         return;
 364       }
 365
 366   /* Try again if we have an outer tag. */
 367   for (i=0; data_objects[i].tag; i++)
 368     if (data_objects[i].tag == tag && data_objects[i].get_from
 369         && data_objects[i].get_from != tag)
 370       flush_cache_item (app, data_objects[i].get_from);
 371 }
 372
 373 /* Flush all entries from the cache which might be out of sync after
 374    an error. */
 375 static void
 376 flush_cache_after_error (app_t app)
 377 {
 378   int i;
 379
 380   for (i=0; data_objects[i].tag; i++)
 381     if (data_objects[i].flush_on_error)
 382       flush_cache_item (app, data_objects[i].tag);
 383 }
 384
 385
 386 /* Flush the entire cache. */
 387 static void
 388 flush_cache (app_t app)
 389 {
 390   if (app && app->app_local)
 391     {
 392       struct cache_s *c, *c2;
 393
 394       for (c = app->app_local->cache; c; c = c2)
 395         {
 396           c2 = c->next;
 397           xfree (c);
 398         }
 399       app->app_local->cache = NULL;
 400     }
 401 }
 402
 403
 404 /* Get the DO identified by TAG from the card in SLOT and return a
 405    buffer with its content in RESULT and NBYTES.  The return value is
 406    NULL if not found or a pointer which must be used to release the
 407    buffer holding value. */
 408 static void *
 409 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
 410             int *r_rc)
 411 {
 412   int rc, i;
 413   unsigned char *buffer;
 414   size_t buflen;
 415   unsigned char *value;
 416   size_t valuelen;
 417   int dummyrc;
 418   int exmode;
 419
 420   if (!r_rc)
 421     r_rc = &dummyrc;
 422
 423   *result = NULL;
 424   *nbytes = 0;
 425   *r_rc = 0;
 426   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
 427     ;
 428
 429   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
 430     {
 431       exmode = 0;
 432       rc = iso7816_get_data (app->slot, exmode, tag, &buffer, &buflen);
 433       if (rc)
 434         {
 435           *r_rc = rc;
 436           return NULL;
 437         }
 438       *result = buffer;
 439       *nbytes = buflen;
 440       return buffer;
 441     }
 442
 443   value = NULL;
 444   rc = -1;
 445   if (data_objects[i].tag && data_objects[i].get_from)
 446     {
 447       rc = get_cached_data (app, data_objects[i].get_from,
 448                             &buffer, &buflen,
 449                             (data_objects[i].dont_cache
 450                              || data_objects[i].get_immediate_in_v11),
 451                             data_objects[i].try_extlen);
 452       if (!rc)
 453         {
 454           const unsigned char *s;
 455
 456           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
 457           if (!s)
 458             value = NULL; /* not found */
 459           else if (valuelen > buflen - (s - buffer))
 460             {
 461               log_error ("warning: constructed DO too short\n");
 462               value = NULL;
 463               xfree (buffer); buffer = NULL;
 464             }
 465           else
 466             value = buffer + (s - buffer);
 467         }
 468     }
 469
 470   if (!value) /* Not in a constructed DO, try simple. */
 471     {
 472       rc = get_cached_data (app, tag, &buffer, &buflen,
 473                             (data_objects[i].dont_cache
 474                              || data_objects[i].get_immediate_in_v11),
 475                             data_objects[i].try_extlen);
 476       if (!rc)
 477         {
 478           value = buffer;
 479           valuelen = buflen;
 480         }
 481     }
 482
 483   if (!rc)
 484     {
 485       *nbytes = valuelen;
 486       *result = value;
 487       return buffer;
 488     }
 489   *r_rc = rc;
 490   return NULL;
 491 }
 492
 493
 494 static void
 495 dump_all_do (int slot)
 496 {
 497   int rc, i, j;
 498   unsigned char *buffer;
 499   size_t buflen;
 500
 501   for (i=0; data_objects[i].tag; i++)
 502     {
 503       if (data_objects[i].get_from)
 504         continue;
 505
 506       /* We don't try extended length APDU because such large DO would
 507          be pretty useless in a log file.  */
 508       rc = iso7816_get_data (slot, 0, data_objects[i].tag, &buffer, &buflen);
 509       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
 510         ;
 511       else if (rc)
 512         log_info ("DO `%s' not available: %s\n",
 513                   data_objects[i].desc, gpg_strerror (rc));
 514       else
 515         {
 516           if (data_objects[i].binary)
 517             {
 518               log_info ("DO `%s': ", data_objects[i].desc);
 519               log_printhex ("", buffer, buflen);
 520             }
 521           else
 522             log_info ("DO `%s': `%.*s'\n",
 523                       data_objects[i].desc,
 524                       (int)buflen, buffer); /* FIXME: sanitize */
 525
 526           if (data_objects[i].constructed)
 527             {
 528               for (j=0; data_objects[j].tag; j++)
 529                 {
 530                   const unsigned char *value;
 531                   size_t valuelen;
 532
 533                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
 534                     continue;
 535                   value = find_tlv_unchecked (buffer, buflen,
 536                                               data_objects[j].tag, &valuelen);
 537                   if (!value)
 538                     ; /* not found */
 539                   else if (valuelen > buflen - (value - buffer))
 540                     log_error ("warning: constructed DO too short\n");
 541                   else
 542                     {
 543                       if (data_objects[j].binary)
 544                         {
 545                           log_info ("DO `%s': ", data_objects[j].desc);
 546                           if (valuelen > 200)
 547                             log_info ("[%u]\n", (unsigned int)valuelen);
 548                           else
 549                             log_printhex ("", value, valuelen);
 550                         }
 551                       else
 552                         log_info ("DO `%s': `%.*s'\n",
 553                                   data_objects[j].desc,
 554                                   (int)valuelen, value); /* FIXME: sanitize */
 555                     }
 556                 }
 557             }
 558         }
 559       xfree (buffer); buffer = NULL;
 560     }
 561 }
 562
 563
 564 /* Count the number of bits, assuming the A represents an unsigned big
 565    integer of length LEN bytes. */
 566 static unsigned int
 567 count_bits (const unsigned char *a, size_t len)
 568 {
 569   unsigned int n = len * 8;
 570   int i;
 571
 572   for (; len && !*a; len--, a++, n -=8)
 573     ;
 574   if (len)
 575     {
 576       for (i=7; i && !(*a & (1<<i)); i--)
 577         n--;
 578     }
 579   return n;
 580 }
 581
 582 /* GnuPG makes special use of the login-data DO, this function parses
 583    the login data to store the flags for later use.  It may be called
 584    at any time and should be called after changing the login-data DO.
 585
 586    Everything up to a LF is considered a mailbox or account name.  If
 587    the first LF is followed by DC4 (0x14) control sequence are
 588    expected up to the next LF.  Control sequences are separated by FS
 589    (0x18) and consist of key=value pairs.  There are two keys defined:
 590
 591     F=<flags>
 592
 593     Where FLAGS is a plain hexadecimal number representing flag values.
 594     The lsb is here the rightmost bit.  Defined flags bits are:
 595
 596       Bit 0 = CHV1 and CHV2 are not syncronized
 597       Bit 1 = CHV2 has been been set to the default PIN of "123456"
 598               (this implies that bit 0 is also set).
 599
 600     P=<pinpad-request>
 601
 602     Where PINPAD_REQUEST is in the format of: <n> or <n>,<m>.
 603     N for user PIN, M for admin PIN.  If M is missing it means M=N.
 604     0 means to force not to use pinpad.
 605
 606 */
 607 static void
 608 parse_login_data (app_t app)
 609 {
 610   unsigned char *buffer, *p;
 611   size_t buflen, len;
 612   void *relptr;
 613
 614   /* Set defaults.  */
 615   app->app_local->flags.no_sync = 0;
 616   app->app_local->flags.def_chv2 = 0;
 617   app->app_local->pinpad.specified = 0;
 618   app->app_local->pinpad.fixedlen_user = -1;
 619   app->app_local->pinpad.fixedlen_admin = -1;
 620
 621   /* Read the DO.  */
 622   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
 623   if (!relptr)
 624     return; /* Ooops. */
 625   for (; buflen; buflen--, buffer++)
 626     if (*buffer == '\n')
 627       break;
 628   if (buflen < 2 || buffer[1] != '\x14')
 629     {
 630       xfree (relptr);
 631       return; /* No control sequences.  */
 632     }
 633
 634   buflen--;
 635   buffer++;
 636   do
 637     {
 638       buflen--;
 639       buffer++;
 640       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
 641         {
 642           /* Flags control sequence found.  */
 643           int lastdig = 0;
 644
 645           /* For now we are only interested in the last digit, so skip
 646              any leading digits but bail out on invalid characters. */
 647           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
 648             lastdig = xtoi_1 (p);
 649           buffer = p;
 650           buflen = len;
 651           if (len && !(*p == '\n' || *p == '\x18'))
 652             goto next;  /* Invalid characters in field.  */
 653           app->app_local->flags.no_sync = !!(lastdig & 1);
 654           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
 655         }
 656       else if (buflen > 1 && *buffer == 'P' && buffer[1] == '=')
 657         {
 658           /* Pinpad request control sequence found.  */
 659           buffer += 2;
 660           buflen -= 2;
 661
 662           if (buflen)
 663             {
 664               if (digitp (buffer))
 665                 {
 666                   char *q;
 667                   int n, m;
 668
 669                   n = strtol (buffer, &q, 10);
 670                   if (q >= (char *)buffer + buflen
 671                       || *q == '\x18' || *q == '\n')
 672                     m = n;
 673                   else
 674                     {
 675                       if (*q++ != ',' || !digitp (q))
 676                         goto next;
 677                       m = strtol (q, &q, 10);
 678                     }
 679
 680                   if (buflen < ((unsigned char *)q - buffer))
 681                     break;
 682
 683                   buflen -= ((unsigned char *)q - buffer);
 684                   buffer = q;
 685
 686                   if (buflen && !(*buffer == '\n' || *buffer == '\x18'))
 687                     goto next;
 688                   app->app_local->pinpad.specified = 1;
 689                   app->app_local->pinpad.fixedlen_user = n;
 690                   app->app_local->pinpad.fixedlen_admin = m;
 691                 }
 692             }
 693         }
 694     next:
 695       /* Skip to FS (0x18) or LF (\n).  */
 696       for (; buflen && *buffer != '\x18' && *buffer != '\n'; buflen--)
 697         buffer++;
 698     }
 699   while (buflen && *buffer != '\n');
 700
 701   xfree (relptr);
 702 }
 703
 704 /* Note, that FPR must be at least 20 bytes. */
 705 static gpg_error_t
 706 store_fpr (app_t app, int keynumber, u32 timestamp,
 707            const unsigned char *m, size_t mlen,
 708            const unsigned char *e, size_t elen,
 709            unsigned char *fpr, unsigned int card_version)
 710 {
 711   unsigned int n, nbits;
 712   unsigned char *buffer, *p;
 713   int tag, tag2;
 714   int rc;
 715
 716   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
 717     ;
 718   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
 719     ;
 720
 721   n = 6 + 2 + mlen + 2 + elen;
 722   p = buffer = xtrymalloc (3 + n);
 723   if (!buffer)
 724     return gpg_error_from_syserror ();
 725
 726   *p++ = 0x99;     /* ctb */
 727   *p++ = n >> 8;   /* 2 byte length header */
 728   *p++ = n;
 729   *p++ = 4;        /* key packet version */
 730   *p++ = timestamp >> 24;
 731   *p++ = timestamp >> 16;
 732   *p++ = timestamp >>  8;
 733   *p++ = timestamp;
 734   *p++ = 1; /* RSA */
 735   nbits = count_bits (m, mlen);
 736   *p++ = nbits >> 8;
 737   *p++ = nbits;
 738   memcpy (p, m, mlen); p += mlen;
 739   nbits = count_bits (e, elen);
 740   *p++ = nbits >> 8;
 741   *p++ = nbits;
 742   memcpy (p, e, elen); p += elen;
 743
 744   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
 745
 746   xfree (buffer);
 747
 748   tag = (card_version > 0x0007? 0xC7 : 0xC6) + keynumber;
 749   flush_cache_item (app, 0xC5);
 750   tag2 = 0xCE + keynumber;
 751   flush_cache_item (app, 0xCD);
 752
 753   rc = iso7816_put_data (app->slot, 0, tag, fpr, 20);
 754   if (rc)
 755     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
 756
 757   if (!rc && card_version > 0x0100)
 758     {
 759       unsigned char buf[4];
 760
 761       buf[0] = timestamp >> 24;
 762       buf[1] = timestamp >> 16;
 763       buf[2] = timestamp >>  8;
 764       buf[3] = timestamp;
 765
 766       rc = iso7816_put_data (app->slot, 0, tag2, buf, 4);
 767       if (rc)
 768         log_error (_("failed to store the creation date: %s\n"),
 769                    gpg_strerror (rc));
 770     }
 771
 772   return rc;
 773 }
 774
 775
 776 static void
 777 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
 778                       int number, const unsigned char *fpr)
 779 {
 780   int i;
 781   char buf[41];
 782   char numbuf[25];
 783
 784   for (i=0; i < 20 && !fpr[i]; i++)
 785     ;
 786   if (i==20)
 787     return; /* All zero. */
 788   bin2hex (fpr, 20, buf);
 789   if (number == -1)
 790     *numbuf = 0; /* Don't print the key number */
 791   else
 792     sprintf (numbuf, "%d", number);
 793   send_status_info (ctrl, keyword,
 794                     numbuf, (size_t)strlen(numbuf),
 795                     buf, (size_t)strlen (buf), NULL, 0);
 796 }
 797
 798 static void
 799 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
 800                           int number, const unsigned char *stamp)
 801 {
 802   char numbuf1[50], numbuf2[50];
 803   unsigned long value;
 804
 805   value = buf32_to_ulong (stamp);
 806   if (!value)
 807     return;
 808   sprintf (numbuf1, "%d", number);
 809   sprintf (numbuf2, "%lu", value);
 810   send_status_info (ctrl, keyword,
 811                     numbuf1, (size_t)strlen(numbuf1),
 812                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
 813 }
 814
 815 static void
 816 send_key_data (ctrl_t ctrl, const char *name,
 817                const unsigned char *a, size_t alen)
 818 {
 819   char *buffer, *buf;
 820   size_t buflen;
 821
 822   buffer = buf = bin2hex (a, alen, NULL);
 823   if (!buffer)
 824     {
 825       log_error ("memory allocation error in send_key_data\n");
 826       return;
 827     }
 828   buflen = strlen (buffer);
 829
 830   /* 768 is the hexified size for the modulus of an 3072 bit key.  We
 831      use extra chunks to transmit larger data (i.e for 4096 bit).  */
 832   for ( ;buflen > 768; buflen -= 768, buf += 768)
 833     send_status_info (ctrl, "KEY-DATA",
 834                       "-", 1,
 835                       buf, 768,
 836                       NULL, 0);
 837   send_status_info (ctrl, "KEY-DATA",
 838                     name, (size_t)strlen(name),
 839                     buf, buflen,
 840                     NULL, 0);
 841   xfree (buffer);
 842 }
 843
 844
 845 static void
 846 send_key_attr (ctrl_t ctrl, app_t app, const char *keyword, int number)
 847 {
 848   char buffer[200];
 849
 850   assert (number >=0 && number < DIM(app->app_local->keyattr));
 851
 852   /* We only support RSA thus the algo identifier is fixed to 1.  */
 853   /* Note that PUBKEY_ALGO_RSA == 1 */
 854   snprintf (buffer, sizeof buffer, "%d 1 %u %u %d",
 855             number+1,
 856             app->app_local->keyattr[number].n_bits,
 857             app->app_local->keyattr[number].e_bits,
 858             app->app_local->keyattr[number].format);
 859   send_status_direct (ctrl, keyword, buffer);
 860 }
 861
 862
 863 #define RSA_SMALL_SIZE_KEY 1952
 864 #define RSA_SMALL_SIZE_OP  2048
 865
 866 static int
 867 determine_rsa_response (app_t app, int keyno)
 868 {
 869   int size;
 870
 871   size = 2 + 3 /* header */
 872     + 4 /* tag+len */ + app->app_local->keyattr[keyno].n_bits/8
 873     + 2 /* tag+len */ + app->app_local->keyattr[keyno].e_bits/8;
 874
 875   return size;
 876 }
 877
 878
 879 /* Implement the GETATTR command.  This is similar to the LEARN
 880    command but returns just one value via the status interface. */
 881 static gpg_error_t
 882 do_getattr (app_t app, ctrl_t ctrl, const char *name)
 883 {
 884   static struct {
 885     const char *name;
 886     int tag;
 887     int special;
 888   } table[] = {
 889     { "DISP-NAME",    0x005B },
 890     { "LOGIN-DATA",   0x005E },
 891     { "DISP-LANG",    0x5F2D },
 892     { "DISP-SEX",     0x5F35 },
 893     { "PUBKEY-URL",   0x5F50 },
 894     { "KEY-FPR",      0x00C5, 3 },
 895     { "KEY-TIME",     0x00CD, 4 },
 896     { "KEY-ATTR",     0x0000, -5 },
 897     { "CA-FPR",       0x00C6, 3 },
 898     { "CHV-STATUS",   0x00C4, 1 },
 899     { "SIG-COUNTER",  0x0093, 2 },
 900     { "SERIALNO",     0x004F, -1 },
 901     { "AID",          0x004F },
 902     { "EXTCAP",       0x0000, -2 },
 903     { "PRIVATE-DO-1", 0x0101 },
 904     { "PRIVATE-DO-2", 0x0102 },
 905     { "PRIVATE-DO-3", 0x0103 },
 906     { "PRIVATE-DO-4", 0x0104 },
 907     { "$AUTHKEYID",   0x0000, -3 },
 908     { "$DISPSERIALNO",0x0000, -4 },
 909     { NULL, 0 }
 910   };
 911   int idx, i, rc;
 912   void *relptr;
 913   unsigned char *value;
 914   size_t valuelen;
 915
 916   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
 917     ;
 918   if (!table[idx].name)
 919     return gpg_error (GPG_ERR_INV_NAME);
 920
 921   if (table[idx].special == -1)
 922     {
 923       /* The serial number is very special.  We could have used the
 924          AID DO to retrieve it, but we have it already in the app
 925          context and the stamp argument is required anyway which we
 926          can't by other means. The AID DO is available anyway but not
 927          hex formatted. */
 928       char *serial;
 929       time_t stamp;
 930       char tmp[50];
 931
 932       if (!app_get_serial_and_stamp (app, &serial, &stamp))
 933         {
 934           sprintf (tmp, "%lu", (unsigned long)stamp);
 935           send_status_info (ctrl, "SERIALNO",
 936                             serial, strlen (serial),
 937                             tmp, strlen (tmp),
 938                             NULL, 0);
 939           xfree (serial);
 940         }
 941       return 0;
 942     }
 943   if (table[idx].special == -2)
 944     {
 945       char tmp[100];
 946
 947       snprintf (tmp, sizeof tmp,
 948                 "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d sm=%d",
 949                 app->app_local->extcap.get_challenge,
 950                 app->app_local->extcap.key_import,
 951                 app->app_local->extcap.change_force_chv,
 952                 app->app_local->extcap.private_dos,
 953                 app->app_local->extcap.max_certlen_3,
 954                 app->app_local->extcap.algo_attr_change,
 955                 (app->app_local->extcap.sm_supported
 956                  ? (app->app_local->extcap.sm_aes128? CIPHER_ALGO_AES : CIPHER_ALGO_3DES)
 957                  : 0));
 958       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
 959       return 0;
 960     }
 961   if (table[idx].special == -3)
 962     {
 963       char const tmp[] = "OPENPGP.3";
 964       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
 965       return 0;
 966     }
 967   if (table[idx].special == -4)
 968     {
 969       char *serial;
 970       time_t stamp;
 971
 972       if (!app_get_serial_and_stamp (app, &serial, &stamp))
 973         {
 974           if (strlen (serial) > 16+12)
 975             {
 976               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
 977               xfree (serial);
 978               return 0;
 979             }
 980           xfree (serial);
 981         }
 982       return gpg_error (GPG_ERR_INV_NAME);
 983     }
 984   if (table[idx].special == -5)
 985     {
 986       for (i=0; i < 3; i++)
 987         send_key_attr (ctrl, app, table[idx].name, i);
 988       return 0;
 989     }
 990
 991   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
 992   if (relptr)
 993     {
 994       if (table[idx].special == 1)
 995         {
 996           char numbuf[7*23];
 997
 998           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
 999             sprintf (numbuf+strlen (numbuf), " %d", value[i]);
1000           send_status_info (ctrl, table[idx].name,
1001                             numbuf, strlen (numbuf), NULL, 0);
1002         }
1003       else if (table[idx].special == 2)
1004         {
1005           char numbuf[50];
1006
1007           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
1008           send_status_info (ctrl, table[idx].name,
1009                             numbuf, strlen (numbuf), NULL, 0);
1010         }
1011       else if (table[idx].special == 3)
1012         {
1013           if (valuelen >= 60)
1014             for (i=0; i < 3; i++)
1015               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
1016         }
1017       else if (table[idx].special == 4)
1018         {
1019           if (valuelen >= 12)
1020             for (i=0; i < 3; i++)
1021               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
1022         }
1023       else
1024         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
1025
1026       xfree (relptr);
1027     }
1028   return rc;
1029 }
1030
1031 /* Retrieve the fingerprint from the card inserted in SLOT and write
1032    the according hex representation to FPR.  Caller must have provide
1033    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
1034    error code. */
1035 #if GNUPG_MAJOR_VERSION > 1
1036 static gpg_error_t
1037 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
1038 {
1039   gpg_error_t err = 0;
1040   void *relptr;
1041   unsigned char *value;
1042   size_t valuelen;
1043
1044   assert (keyno >=0 && keyno <= 2);
1045
1046   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
1047   if (relptr && valuelen >= 60)
1048     bin2hex (value+keyno*20, 20, fpr);
1049   else
1050     err = gpg_error (GPG_ERR_NOT_FOUND);
1051   xfree (relptr);
1052   return err;
1053 }
1054 #endif /*GNUPG_MAJOR_VERSION > 1*/
1055
1056
1057 /* Retrieve the public key material for the RSA key, whose fingerprint
1058    is FPR, from gpg output, which can be read through the stream FP.
1059    The RSA modulus will be stored at the address of M and MLEN, the
1060    public exponent at E and ELEN.  Returns zero on success, an error
1061    code on failure.  Caller must release the allocated buffers at M
1062    and E if the function returns success.  */
1063 #if GNUPG_MAJOR_VERSION > 1
1064 static gpg_error_t
1065 retrieve_key_material (FILE *fp, const char *hexkeyid,
1066                        const unsigned char **m, size_t *mlen,
1067                        const unsigned char **e, size_t *elen)
1068 {
1069   gcry_error_t err = 0;
1070   char *line = NULL;    /* read_line() buffer. */
1071   size_t line_size = 0; /* Helper for for read_line. */
1072   int found_key = 0;    /* Helper to find a matching key. */
1073   unsigned char *m_new = NULL;
1074   unsigned char *e_new = NULL;
1075   size_t m_new_n = 0;
1076   size_t e_new_n = 0;
1077
1078   /* Loop over all records until we have found the subkey
1079      corresponding to the fingerprint. Inm general the first record
1080      should be the pub record, but we don't rely on that.  Given that
1081      we only need to look at one key, it is sufficient to compare the
1082      keyid so that we don't need to look at "fpr" records. */
1083   for (;;)
1084     {
1085       char *p;
1086       char *fields[6];
1087       int nfields;
1088       size_t max_length;
1089       gcry_mpi_t mpi;
1090       int i;
1091
1092       max_length = 4096;
1093       i = read_line (fp, &line, &line_size, &max_length);
1094       if (!i)
1095         break; /* EOF. */
1096       if (i < 0)
1097         {
1098           err = gpg_error_from_syserror ();
1099           goto leave; /* Error. */
1100         }
1101       if (!max_length)
1102         {
1103           err = gpg_error (GPG_ERR_TRUNCATED);
1104           goto leave;  /* Line truncated - we better stop processing.  */
1105         }
1106
1107       /* Parse the line into fields. */
1108       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
1109         {
1110           fields[nfields] = p;
1111           p = strchr (p, ':');
1112           if (p)
1113             *(p++) = 0;
1114         }
1115       if (!nfields)
1116         continue; /* No fields at all - skip line.  */
1117
1118       if (!found_key)
1119         {
1120           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1121                && nfields > 4 && !strcmp (fields[4], hexkeyid))
1122             found_key = 1;
1123           continue;
1124         }
1125
1126       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1127         break; /* Next key - stop.  */
1128
1129       if ( strcmp (fields[0], "pkd") )
1130         continue; /* Not a key data record.  */
1131       i = 0; /* Avoid erroneous compiler warning. */
1132       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1133            || (!i && m_new) || (i && e_new))
1134         {
1135           err = gpg_error (GPG_ERR_GENERAL);
1136           goto leave; /* Error: Invalid key data record or not an RSA key.  */
1137         }
1138
1139       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1140       if (err)
1141         mpi = NULL;
1142       else if (!i)
1143         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1144       else
1145         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1146       gcry_mpi_release (mpi);
1147       if (err)
1148         goto leave;
1149     }
1150
1151   if (m_new && e_new)
1152     {
1153       *m = m_new;
1154       *mlen = m_new_n;
1155       m_new = NULL;
1156       *e = e_new;
1157       *elen = e_new_n;
1158       e_new = NULL;
1159     }
1160   else
1161     err = gpg_error (GPG_ERR_GENERAL);
1162
1163  leave:
1164   xfree (m_new);
1165   xfree (e_new);
1166   xfree (line);
1167   return err;
1168 }
1169 #endif /*GNUPG_MAJOR_VERSION > 1*/
1170
1171
1172 /* Get the public key for KEYNO and store it as an S-expresion with
1173    the APP handle.  On error that field gets cleared.  If we already
1174    know about the public key we will just return.  Note that this does
1175    not mean a key is available; this is soley indicated by the
1176    presence of the app->app_local->pk[KEYNO].key field.
1177
1178    Note that GnuPG 1.x does not need this and it would be too time
1179    consuming to send it just for the fun of it. However, given that we
1180    use the same code in gpg 1.4, we can't use the gcry S-expresion
1181    here but need to open encode it. */
1182 #if GNUPG_MAJOR_VERSION > 1
1183 static gpg_error_t
1184 get_public_key (app_t app, int keyno)
1185 {
1186   gpg_error_t err = 0;
1187   unsigned char *buffer;
1188   const unsigned char *keydata, *m, *e;
1189   size_t buflen, keydatalen, mlen, elen;
1190   unsigned char *mbuf = NULL;
1191   unsigned char *ebuf = NULL;
1192   char *keybuf = NULL;
1193   char *keybuf_p;
1194
1195   if (keyno < 0 || keyno > 2)
1196     return gpg_error (GPG_ERR_INV_ID);
1197
1198   /* Already cached? */
1199   if (app->app_local->pk[keyno].read_done)
1200     return 0;
1201
1202   xfree (app->app_local->pk[keyno].key);
1203   app->app_local->pk[keyno].key = NULL;
1204   app->app_local->pk[keyno].keylen = 0;
1205
1206   m = e = NULL; /* (avoid cc warning) */
1207
1208   if (app->card_version > 0x0100)
1209     {
1210       int exmode, le_value;
1211
1212       /* We may simply read the public key out of these cards.  */
1213       if (app->app_local->cardcap.ext_lc_le
1214           && app->app_local->keyattr[keyno].n_bits > RSA_SMALL_SIZE_KEY)
1215         {
1216           exmode = 1;    /* Use extended length.  */
1217           le_value = determine_rsa_response (app, keyno);
1218         }
1219       else
1220         {
1221           exmode = 0;
1222           le_value = 256; /* Use legacy value. */
1223         }
1224
1225       err = iso7816_read_public_key (app->slot, exmode,
1226                                      (keyno == 0? "\xB6" :
1227                                       keyno == 1? "\xB8" : "\xA4"),
1228                                      2, le_value, &buffer, &buflen);
1229       if (err)
1230         {
1231           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1232           goto leave;
1233         }
1234
1235       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1236       if (!keydata)
1237         {
1238           err = gpg_error (GPG_ERR_CARD);
1239           log_error (_("response does not contain the public key data\n"));
1240           goto leave;
1241         }
1242
1243       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1244       if (!m)
1245         {
1246           err = gpg_error (GPG_ERR_CARD);
1247           log_error (_("response does not contain the RSA modulus\n"));
1248           goto leave;
1249         }
1250
1251
1252       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1253       if (!e)
1254         {
1255           err = gpg_error (GPG_ERR_CARD);
1256           log_error (_("response does not contain the RSA public exponent\n"));
1257           goto leave;
1258         }
1259
1260       /* Prepend numbers with a 0 if needed.  */
1261       if (mlen && (*m & 0x80))
1262         {
1263           mbuf = xtrymalloc ( mlen + 1);
1264           if (!mbuf)
1265             {
1266               err = gpg_error_from_syserror ();
1267               goto leave;
1268             }
1269           *mbuf = 0;
1270           memcpy (mbuf+1, m, mlen);
1271           mlen++;
1272           m = mbuf;
1273         }
1274       if (elen && (*e & 0x80))
1275         {
1276           ebuf = xtrymalloc ( elen + 1);
1277           if (!ebuf)
1278             {
1279               err = gpg_error_from_syserror ();
1280               goto leave;
1281             }
1282           *ebuf = 0;
1283           memcpy (ebuf+1, e, elen);
1284           elen++;
1285           e = ebuf;
1286         }
1287
1288     }
1289   else
1290     {
1291       /* Due to a design problem in v1.0 cards we can't get the public
1292          key out of these cards without doing a verify on CHV3.
1293          Clearly that is not an option and thus we try to locate the
1294          key using an external helper.
1295
1296          The helper we use here is gpg itself, which should know about
1297          the key in any case.  */
1298
1299       char fpr[41];
1300       char *hexkeyid;
1301       char *command = NULL;
1302       FILE *fp;
1303       int ret;
1304
1305       buffer = NULL; /* We don't need buffer.  */
1306
1307       err = retrieve_fpr_from_card (app, keyno, fpr);
1308       if (err)
1309         {
1310           log_error ("error while retrieving fpr from card: %s\n",
1311                      gpg_strerror (err));
1312           goto leave;
1313         }
1314       hexkeyid = fpr + 24;
1315
1316       ret = estream_asprintf (&command,
1317                               "gpg --list-keys --with-colons --with-key-data '%s'",
1318                               fpr);
1319       if (ret < 0)
1320         {
1321           err = gpg_error_from_syserror ();
1322           goto leave;
1323         }
1324
1325       fp = popen (command, "r");
1326       xfree (command);
1327       if (!fp)
1328         {
1329           err = gpg_error_from_syserror ();
1330           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1331           goto leave;
1332         }
1333
1334       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1335       pclose (fp);
1336       if (err)
1337         {
1338           log_error ("error while retrieving key material through pipe: %s\n",
1339                      gpg_strerror (err));
1340           goto leave;
1341         }
1342     }
1343
1344   /* Allocate a buffer to construct the S-expression.  */
1345   /* FIXME: We should provide a generalized S-expression creation
1346      mechanism. */
1347   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1348   if (!keybuf)
1349     {
1350       err = gpg_error_from_syserror ();
1351       goto leave;
1352     }
1353
1354   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1355   keybuf_p = keybuf + strlen (keybuf);
1356   memcpy (keybuf_p, m, mlen);
1357   keybuf_p += mlen;
1358   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1359   keybuf_p += strlen (keybuf_p);
1360   memcpy (keybuf_p, e, elen);
1361   keybuf_p += elen;
1362   strcpy (keybuf_p, ")))");
1363   keybuf_p += strlen (keybuf_p);
1364
1365   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1366   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1367
1368  leave:
1369   /* Set a flag to indicate that we tried to read the key.  */
1370   app->app_local->pk[keyno].read_done = 1;
1371
1372   xfree (buffer);
1373   xfree (mbuf);
1374   xfree (ebuf);
1375   return err;
1376 }
1377 #endif /* GNUPG_MAJOR_VERSION > 1 */
1378
1379
1380
1381 /* Send the KEYPAIRINFO back. KEY needs to be in the range [1,3].
1382    This is used by the LEARN command. */
1383 static gpg_error_t
1384 send_keypair_info (app_t app, ctrl_t ctrl, int key)
1385 {
1386   int keyno = key - 1;
1387   gpg_error_t err = 0;
1388   /* Note that GnuPG 1.x does not need this and it would be too time
1389      consuming to send it just for the fun of it. */
1390 #if GNUPG_MAJOR_VERSION > 1
1391   unsigned char grip[20];
1392   char gripstr[41];
1393   char idbuf[50];
1394
1395   err = get_public_key (app, keyno);
1396   if (err)
1397     goto leave;
1398
1399   assert (keyno >= 0 && keyno <= 2);
1400   if (!app->app_local->pk[keyno].key)
1401     goto leave; /* No such key - ignore. */
1402
1403   err = keygrip_from_canon_sexp (app->app_local->pk[keyno].key,
1404                                  app->app_local->pk[keyno].keylen,
1405                                  grip);
1406   if (err)
1407     goto leave;
1408
1409   bin2hex (grip, 20, gripstr);
1410
1411   sprintf (idbuf, "OPENPGP.%d", keyno+1);
1412   send_status_info (ctrl, "KEYPAIRINFO",
1413                     gripstr, 40,
1414                     idbuf, strlen (idbuf),
1415                     NULL, (size_t)0);
1416
1417  leave:
1418 #endif /* GNUPG_MAJOR_VERSION > 1 */
1419
1420   return err;
1421 }
1422
1423
1424 /* Handle the LEARN command for OpenPGP.  */
1425 static gpg_error_t
1426 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1427 {
1428   (void)flags;
1429
1430   do_getattr (app, ctrl, "EXTCAP");
1431   do_getattr (app, ctrl, "DISP-NAME");
1432   do_getattr (app, ctrl, "DISP-LANG");
1433   do_getattr (app, ctrl, "DISP-SEX");
1434   do_getattr (app, ctrl, "PUBKEY-URL");
1435   do_getattr (app, ctrl, "LOGIN-DATA");
1436   do_getattr (app, ctrl, "KEY-FPR");
1437   if (app->card_version > 0x0100)
1438     do_getattr (app, ctrl, "KEY-TIME");
1439   do_getattr (app, ctrl, "CA-FPR");
1440   do_getattr (app, ctrl, "CHV-STATUS");
1441   do_getattr (app, ctrl, "SIG-COUNTER");
1442   if (app->app_local->extcap.private_dos)
1443     {
1444       do_getattr (app, ctrl, "PRIVATE-DO-1");
1445       do_getattr (app, ctrl, "PRIVATE-DO-2");
1446       if (app->did_chv2)
1447         do_getattr (app, ctrl, "PRIVATE-DO-3");
1448       if (app->did_chv3)
1449         do_getattr (app, ctrl, "PRIVATE-DO-4");
1450     }
1451   send_keypair_info (app, ctrl, 1);
1452   send_keypair_info (app, ctrl, 2);
1453   send_keypair_info (app, ctrl, 3);
1454   /* Note: We do not send the Cardholder Certificate, because that is
1455      relativly long and for OpenPGP applications not really needed.  */
1456   return 0;
1457 }
1458
1459
1460 /* Handle the READKEY command for OpenPGP.  On success a canonical
1461    encoded S-expression with the public key will get stored at PK and
1462    its length (for assertions) at PKLEN; the caller must release that
1463    buffer. On error PK and PKLEN are not changed and an error code is
1464    returned.  */
1465 static gpg_error_t
1466 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1467 {
1468 #if GNUPG_MAJOR_VERSION > 1
1469   gpg_error_t err;
1470   int keyno;
1471   unsigned char *buf;
1472
1473   if (!strcmp (keyid, "OPENPGP.1"))
1474     keyno = 0;
1475   else if (!strcmp (keyid, "OPENPGP.2"))
1476     keyno = 1;
1477   else if (!strcmp (keyid, "OPENPGP.3"))
1478     keyno = 2;
1479   else
1480     return gpg_error (GPG_ERR_INV_ID);
1481
1482   err = get_public_key (app, keyno);
1483   if (err)
1484     return err;
1485
1486   buf = app->app_local->pk[keyno].key;
1487   if (!buf)
1488     return gpg_error (GPG_ERR_NO_PUBKEY);
1489   *pklen = app->app_local->pk[keyno].keylen;;
1490   *pk = xtrymalloc (*pklen);
1491   if (!*pk)
1492     {
1493       err = gpg_error_from_syserror ();
1494       *pklen = 0;
1495       return err;
1496     }
1497   memcpy (*pk, buf, *pklen);
1498   return 0;
1499 #else
1500   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1501 #endif
1502 }
1503
1504 /* Read the standard certificate of an OpenPGP v2 card.  It is
1505    returned in a freshly allocated buffer with that address stored at
1506    CERT and the length of the certificate stored at CERTLEN.  CERTID
1507    needs to be set to "OPENPGP.3".  */
1508 static gpg_error_t
1509 do_readcert (app_t app, const char *certid,
1510              unsigned char **cert, size_t *certlen)
1511 {
1512 #if GNUPG_MAJOR_VERSION > 1
1513   gpg_error_t err;
1514   unsigned char *buffer;
1515   size_t buflen;
1516   void *relptr;
1517
1518   *cert = NULL;
1519   *certlen = 0;
1520   if (strcmp (certid, "OPENPGP.3"))
1521     return gpg_error (GPG_ERR_INV_ID);
1522   if (!app->app_local->extcap.is_v2)
1523     return gpg_error (GPG_ERR_NOT_FOUND);
1524
1525   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1526   if (!relptr)
1527     return gpg_error (GPG_ERR_NOT_FOUND);
1528
1529   if (!buflen)
1530     err = gpg_error (GPG_ERR_NOT_FOUND);
1531   else if (!(*cert = xtrymalloc (buflen)))
1532     err = gpg_error_from_syserror ();
1533   else
1534     {
1535       memcpy (*cert, buffer, buflen);
1536       *certlen = buflen;
1537       err  = 0;
1538     }
1539   xfree (relptr);
1540   return err;
1541 #else
1542   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1543 #endif
1544 }
1545
1546
1547 /* Decide if we use the pinpad of the reader for PIN input according
1548    to the user preference on the card, and the capability of the
1549    reader.  This routine is only called when the reader has pinpad.
1550    Returns 0 if we use pinpad, 1 otherwise.  */
1551 static int
1552 check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1553 {
1554   if (app->app_local->pinpad.specified == 0) /* No preference on card.  */
1555     {
1556       if (pininfo->fixedlen == 0) /* Reader has varlen capability.  */
1557         return 0;                 /* Then, use pinpad.  */
1558       else
1559         /*
1560          * Reader has limited capability, and it may not match PIN of
1561          * the card.
1562          */
1563         return 1;
1564     }
1565
1566   if (admin_pin)
1567     pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
1568   else
1569     pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
1570
1571   if (pininfo->fixedlen == 0    /* User requests disable pinpad.  */
1572       || pininfo->fixedlen < pininfo->minlen
1573       || pininfo->fixedlen > pininfo->maxlen
1574       /* Reader doesn't have the capability to input a PIN which
1575        * length is FIXEDLEN.  */)
1576     return 1;
1577
1578   return 0;
1579 }
1580
1581
1582 /* Verify a CHV either using using the pinentry or if possibile by
1583    using a pinpad.  PINCB and PINCB_ARG describe the usual callback
1584    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1585    used with CHV1.  PINVALUE is the address of a pointer which will
1586    receive a newly allocated block with the actual PIN (this is useful
1587    in case that PIN shall be used for another verify operation).  The
1588    caller needs to free this value.  If the function returns with
1589    success and NULL is stored at PINVALUE, the caller should take this
1590    as an indication that the pinpad has been used.
1591    */
1592 static gpg_error_t
1593 verify_a_chv (app_t app,
1594               gpg_error_t (*pincb)(void*, const char *, char **),
1595               void *pincb_arg,
1596               int chvno, unsigned long sigcount, char **pinvalue)
1597 {
1598   int rc = 0;
1599   char *prompt_buffer = NULL;
1600   const char *prompt;
1601   pininfo_t pininfo;
1602   int minlen = 6;
1603
1604   assert (chvno == 1 || chvno == 2);
1605
1606   *pinvalue = NULL;
1607
1608   if (chvno == 2 && app->app_local->flags.def_chv2)
1609     {
1610       /* Special case for def_chv2 mechanism. */
1611       if (opt.verbose)
1612         log_info (_("using default PIN as %s\n"), "CHV2");
1613       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1614       if (rc)
1615         {
1616           /* Verification of CHV2 with the default PIN failed,
1617              although the card pretends to have the default PIN set as
1618              CHV2.  We better disable the def_chv2 flag now. */
1619           log_info (_("failed to use default PIN as %s: %s"
1620                       " - disabling further default use\n"),
1621                     "CHV2", gpg_strerror (rc));
1622           app->app_local->flags.def_chv2 = 0;
1623         }
1624       return rc;
1625     }
1626
1627   memset (&pininfo, 0, sizeof pininfo);
1628   pininfo.fixedlen = -1;
1629   pininfo.minlen = minlen;
1630
1631
1632   if (chvno == 1)
1633     {
1634 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1635       size_t promptsize = strlen (PROMPTSTRING) + 50;
1636
1637       prompt_buffer = xtrymalloc (promptsize);
1638       if (!prompt_buffer)
1639         return gpg_error_from_syserror ();
1640       snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, sigcount);
1641       prompt = prompt_buffer;
1642 #undef PROMPTSTRING
1643     }
1644   else
1645     prompt = _("||Please enter the PIN");
1646
1647
1648   if (!opt.disable_pinpad
1649       && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
1650       && !check_pinpad_request (app, &pininfo, 0))
1651     {
1652       /* The reader supports the verify command through the pinpad.
1653          Note that the pincb appends a text to the prompt telling the
1654          user to use the pinpad. */
1655       rc = pincb (pincb_arg, prompt, NULL);
1656       prompt = NULL;
1657       xfree (prompt_buffer);
1658       prompt_buffer = NULL;
1659       if (rc)
1660         {
1661           log_info (_("PIN callback returned error: %s\n"),
1662                     gpg_strerror (rc));
1663           return rc;
1664         }
1665       rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
1666       /* Dismiss the prompt. */
1667       pincb (pincb_arg, NULL, NULL);
1668
1669       assert (!*pinvalue);
1670     }
1671   else
1672     {
1673       /* The reader has no pinpad or we don't want to use it. */
1674       rc = pincb (pincb_arg, prompt, pinvalue);
1675       prompt = NULL;
1676       xfree (prompt_buffer);
1677       prompt_buffer = NULL;
1678       if (rc)
1679         {
1680           log_info (_("PIN callback returned error: %s\n"),
1681                     gpg_strerror (rc));
1682           return rc;
1683         }
1684
1685       if (strlen (*pinvalue) < minlen)
1686         {
1687           log_error (_("PIN for CHV%d is too short;"
1688                        " minimum length is %d\n"), chvno, minlen);
1689           xfree (*pinvalue);
1690           *pinvalue = NULL;
1691           return gpg_error (GPG_ERR_BAD_PIN);
1692         }
1693
1694       rc = iso7816_verify (app->slot, 0x80+chvno,
1695                            *pinvalue, strlen (*pinvalue));
1696     }
1697
1698   if (rc)
1699     {
1700       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1701       xfree (*pinvalue);
1702       *pinvalue = NULL;
1703       flush_cache_after_error (app);
1704     }
1705
1706   return rc;
1707 }
1708
1709
1710 /* Verify CHV2 if required.  Depending on the configuration of the
1711    card CHV1 will also be verified. */
1712 static gpg_error_t
1713 verify_chv2 (app_t app,
1714              gpg_error_t (*pincb)(void*, const char *, char **),
1715              void *pincb_arg)
1716 {
1717   int rc;
1718   char *pinvalue;
1719
1720   if (app->did_chv2)
1721     return 0;  /* We already verified CHV2.  */
1722
1723   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1724   if (rc)
1725     return rc;
1726   app->did_chv2 = 1;
1727
1728   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1729     {
1730       /* For convenience we verify CHV1 here too.  We do this only if
1731          the card is not configured to require a verification before
1732          each CHV1 controlled operation (force_chv1) and if we are not
1733          using the pinpad (PINVALUE == NULL). */
1734       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1735       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1736         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1737       if (rc)
1738         {
1739           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1740           flush_cache_after_error (app);
1741         }
1742       else
1743         app->did_chv1 = 1;
1744     }
1745
1746   xfree (pinvalue);
1747
1748   return rc;
1749 }
1750
1751
1752 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
1753    current sdtate of the card.  */
1754 static gpg_error_t
1755 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
1756 {
1757   void *relptr;
1758   unsigned char *value;
1759   size_t valuelen;
1760   int remaining;
1761   char *prompt;
1762
1763   *r_prompt = NULL;
1764
1765   relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1766   if (!relptr || valuelen < 7)
1767     {
1768       log_error (_("error retrieving CHV status from card\n"));
1769       xfree (relptr);
1770       return gpg_error (GPG_ERR_CARD);
1771     }
1772   if (value[6] == 0)
1773     {
1774       log_info (_("card is permanently locked!\n"));
1775       xfree (relptr);
1776       return gpg_error (GPG_ERR_BAD_PIN);
1777     }
1778   remaining = value[6];
1779   xfree (relptr);
1780
1781   log_info(_("%d Admin PIN attempts remaining before card"
1782              " is permanently locked\n"), remaining);
1783
1784   if (remaining < 3)
1785     {
1786       /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
1787          the start of the string.  Use %%0A to force a linefeed.  */
1788       prompt = xtryasprintf (_("|A|Please enter the Admin PIN%%0A"
1789                                "[remaining attempts: %d]"), remaining);
1790     }
1791   else
1792     prompt = xtrystrdup (_("|A|Please enter the Admin PIN"));
1793
1794   if (!prompt)
1795     return gpg_error_from_syserror ();
1796
1797   *r_prompt = prompt;
1798   return 0;
1799 }
1800
1801
1802 /* Verify CHV3 if required. */
1803 static gpg_error_t
1804 verify_chv3 (app_t app,
1805              gpg_error_t (*pincb)(void*, const char *, char **),
1806              void *pincb_arg)
1807 {
1808   int rc = 0;
1809
1810 #if GNUPG_MAJOR_VERSION != 1
1811   if (!opt.allow_admin)
1812     {
1813       log_info (_("access to admin commands is not configured\n"));
1814       return gpg_error (GPG_ERR_EACCES);
1815     }
1816 #endif
1817
1818   if (!app->did_chv3)
1819     {
1820       pininfo_t pininfo;
1821       int minlen = 8;
1822       char *prompt;
1823
1824       memset (&pininfo, 0, sizeof pininfo);
1825       pininfo.fixedlen = -1;
1826       pininfo.minlen = minlen;
1827
1828       rc = build_enter_admin_pin_prompt (app, &prompt);
1829       if (rc)
1830         return rc;
1831
1832       if (!opt.disable_pinpad
1833           && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
1834           && !check_pinpad_request (app, &pininfo, 1))
1835         {
1836           /* The reader supports the verify command through the pinpad. */
1837           rc = pincb (pincb_arg, prompt, NULL);
1838           xfree (prompt);
1839           prompt = NULL;
1840           if (rc)
1841             {
1842               log_info (_("PIN callback returned error: %s\n"),
1843                         gpg_strerror (rc));
1844               return rc;
1845             }
1846           rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
1847           /* Dismiss the prompt. */
1848           pincb (pincb_arg, NULL, NULL);
1849         }
1850       else
1851         {
1852           char *pinvalue;
1853
1854           rc = pincb (pincb_arg, prompt, &pinvalue);
1855           xfree (prompt);
1856           prompt = NULL;
1857           if (rc)
1858             {
1859               log_info (_("PIN callback returned error: %s\n"),
1860                         gpg_strerror (rc));
1861               return rc;
1862             }
1863
1864           if (strlen (pinvalue) < minlen)
1865             {
1866               log_error (_("PIN for CHV%d is too short;"
1867                            " minimum length is %d\n"), 3, minlen);
1868               xfree (pinvalue);
1869               return gpg_error (GPG_ERR_BAD_PIN);
1870             }
1871
1872           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1873           xfree (pinvalue);
1874         }
1875
1876       if (rc)
1877         {
1878           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1879           flush_cache_after_error (app);
1880           return rc;
1881         }
1882       app->did_chv3 = 1;
1883     }
1884   return rc;
1885 }
1886
1887
1888 /* Handle the SETATTR operation. All arguments are already basically
1889    checked. */
1890 static gpg_error_t
1891 do_setattr (app_t app, const char *name,
1892             gpg_error_t (*pincb)(void*, const char *, char **),
1893             void *pincb_arg,
1894             const unsigned char *value, size_t valuelen)
1895 {
1896   gpg_error_t rc;
1897   int idx;
1898   static struct {
1899     const char *name;
1900     int tag;
1901     int need_chv;
1902     int special;
1903     unsigned int need_v2:1;
1904   } table[] = {
1905     { "DISP-NAME",    0x005B, 3 },
1906     { "LOGIN-DATA",   0x005E, 3, 2 },
1907     { "DISP-LANG",    0x5F2D, 3 },
1908     { "DISP-SEX",     0x5F35, 3 },
1909     { "PUBKEY-URL",   0x5F50, 3 },
1910     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1911     { "CA-FPR-1",     0x00CA, 3 },
1912     { "CA-FPR-2",     0x00CB, 3 },
1913     { "CA-FPR-3",     0x00CC, 3 },
1914     { "PRIVATE-DO-1", 0x0101, 2 },
1915     { "PRIVATE-DO-2", 0x0102, 3 },
1916     { "PRIVATE-DO-3", 0x0103, 2 },
1917     { "PRIVATE-DO-4", 0x0104, 3 },
1918     { "CERT-3",       0x7F21, 3, 0, 1 },
1919     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
1920     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
1921     { "KEY-ATTR",     0,      0, 3, 1 },
1922     { NULL, 0 }
1923   };
1924   int exmode;
1925
1926   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1927     ;
1928   if (!table[idx].name)
1929     return gpg_error (GPG_ERR_INV_NAME);
1930   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
1931     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
1932
1933   if (table[idx].special == 3)
1934     return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
1935
1936   switch (table[idx].need_chv)
1937     {
1938     case 2:
1939       rc = verify_chv2 (app, pincb, pincb_arg);
1940       break;
1941     case 3:
1942       rc = verify_chv3 (app, pincb, pincb_arg);
1943       break;
1944     default:
1945       rc = 0;
1946     }
1947   if (rc)
1948     return rc;
1949
1950   /* Flush the cache before writing it, so that the next get operation
1951      will reread the data from the card and thus get synced in case of
1952      errors (e.g. data truncated by the card). */
1953   flush_cache_item (app, table[idx].tag);
1954
1955   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
1956     exmode = 1;    /* Use extended length w/o a limit.  */
1957   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
1958     exmode = -254; /* Command chaining with max. 254 bytes.  */
1959   else
1960     exmode = 0;
1961   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
1962   if (rc)
1963     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1964
1965   if (table[idx].special == 1)
1966     app->force_chv1 = (valuelen && *value == 0);
1967   else if (table[idx].special == 2)
1968     parse_login_data (app);
1969
1970   return rc;
1971 }
1972
1973
1974 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
1975    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
1976    PINCB and PINCB_ARG are the usual arguments for the pinentry
1977    callback.  */
1978 static gpg_error_t
1979 do_writecert (app_t app, ctrl_t ctrl,
1980               const char *certidstr,
1981               gpg_error_t (*pincb)(void*, const char *, char **),
1982               void *pincb_arg,
1983               const unsigned char *certdata, size_t certdatalen)
1984 {
1985   (void)ctrl;
1986 #if GNUPG_MAJOR_VERSION > 1
1987   if (strcmp (certidstr, "OPENPGP.3"))
1988     return gpg_error (GPG_ERR_INV_ID);
1989   if (!certdata || !certdatalen)
1990     return gpg_error (GPG_ERR_INV_ARG);
1991   if (!app->app_local->extcap.is_v2)
1992     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1993   if (certdatalen > app->app_local->extcap.max_certlen_3)
1994     return gpg_error (GPG_ERR_TOO_LARGE);
1995   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1996 #else
1997   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1998 #endif
1999 }
2000
2001
2002
2003 /* Handle the PASSWD command.  The following combinations are
2004    possible:
2005
2006     Flags  CHVNO Vers.  Description
2007     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
2008     RESET    1   2      Verify PW3 and set a new PW1.
2009     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
2010     RESET    2   2      Verify PW3 and set a new Reset Code.
2011     RESET    3   any    Returns GPG_ERR_INV_ID.
2012      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
2013      -       1   2      Verify PW1 and set a new PW1.
2014      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
2015      -       2   2      Verify Reset Code and set a new PW1.
2016      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
2017  */
2018 static gpg_error_t
2019 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
2020                unsigned int flags,
2021                gpg_error_t (*pincb)(void*, const char *, char **),
2022                void *pincb_arg)
2023 {
2024   int rc = 0;
2025   int chvno = atoi (chvnostr);
2026   char *resetcode = NULL;
2027   char *oldpinvalue = NULL;
2028   char *pinvalue = NULL;
2029   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2030   int set_resetcode = 0;
2031   pininfo_t pininfo;
2032   int use_pinpad = 0;
2033   int minlen = 6;
2034
2035   (void)ctrl;
2036   memset (&pininfo, 0, sizeof pininfo);
2037   pininfo.fixedlen = -1;
2038   pininfo.minlen = minlen;
2039
2040   if (reset_mode && chvno == 3)
2041     {
2042       rc = gpg_error (GPG_ERR_INV_ID);
2043       goto leave;
2044     }
2045
2046   if (!app->app_local->extcap.is_v2)
2047     {
2048       /* Version 1 cards.  */
2049
2050       if (reset_mode || chvno == 3)
2051         {
2052           /* We always require that the PIN is entered. */
2053           app->did_chv3 = 0;
2054           rc = verify_chv3 (app, pincb, pincb_arg);
2055           if (rc)
2056             goto leave;
2057         }
2058       else if (chvno == 1 || chvno == 2)
2059         {
2060           /* On a v1.x card CHV1 and CVH2 should always have the same
2061              value, thus we enforce it here.  */
2062           int save_force = app->force_chv1;
2063
2064           app->force_chv1 = 0;
2065           app->did_chv1 = 0;
2066           app->did_chv2 = 0;
2067           rc = verify_chv2 (app, pincb, pincb_arg);
2068           app->force_chv1 = save_force;
2069           if (rc)
2070             goto leave;
2071         }
2072       else
2073         {
2074           rc = gpg_error (GPG_ERR_INV_ID);
2075           goto leave;
2076         }
2077     }
2078   else
2079     {
2080       /* Version 2 cards.  */
2081
2082       if (!opt.disable_pinpad
2083           && !iso7816_check_pinpad (app->slot,
2084                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2085           && !check_pinpad_request (app, &pininfo, chvno == 3))
2086         use_pinpad = 1;
2087
2088       if (reset_mode)
2089         {
2090           /* To reset a PIN the Admin PIN is required. */
2091           use_pinpad = 0;
2092           app->did_chv3 = 0;
2093           rc = verify_chv3 (app, pincb, pincb_arg);
2094           if (rc)
2095             goto leave;
2096
2097           if (chvno == 2)
2098             set_resetcode = 1;
2099         }
2100       else if (chvno == 1 || chvno == 3)
2101         {
2102           if (!use_pinpad)
2103             {
2104               char *promptbuf = NULL;
2105               const char *prompt;
2106
2107               if (chvno == 3)
2108                 {
2109                   minlen = 8;
2110                   rc = build_enter_admin_pin_prompt (app, &promptbuf);
2111                   if (rc)
2112                     goto leave;
2113                   prompt = promptbuf;
2114                 }
2115               else
2116                 prompt = _("||Please enter the PIN");
2117               rc = pincb (pincb_arg, prompt, &oldpinvalue);
2118               xfree (promptbuf);
2119               promptbuf = NULL;
2120               if (rc)
2121                 {
2122                   log_info (_("PIN callback returned error: %s\n"),
2123                             gpg_strerror (rc));
2124                   goto leave;
2125                 }
2126
2127               if (strlen (oldpinvalue) < minlen)
2128                 {
2129                   log_info (_("PIN for CHV%d is too short;"
2130                               " minimum length is %d\n"), chvno, minlen);
2131                   rc = gpg_error (GPG_ERR_BAD_PIN);
2132                   goto leave;
2133                 }
2134             }
2135         }
2136       else if (chvno == 2)
2137         {
2138           /* There is no PW2 for v2 cards.  We use this condition to
2139              allow a PW reset using the Reset Code.  */
2140           void *relptr;
2141           unsigned char *value;
2142           size_t valuelen;
2143           int remaining;
2144
2145           use_pinpad = 0;
2146           minlen = 8;
2147           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2148           if (!relptr || valuelen < 7)
2149             {
2150               log_error (_("error retrieving CHV status from card\n"));
2151               xfree (relptr);
2152               rc = gpg_error (GPG_ERR_CARD);
2153               goto leave;
2154             }
2155           remaining = value[5];
2156           xfree (relptr);
2157           if (!remaining)
2158             {
2159               log_error (_("Reset Code not or not anymore available\n"));
2160               rc = gpg_error (GPG_ERR_BAD_PIN);
2161               goto leave;
2162             }
2163
2164           rc = pincb (pincb_arg,
2165                       _("||Please enter the Reset Code for the card"),
2166                       &resetcode);
2167           if (rc)
2168             {
2169               log_info (_("PIN callback returned error: %s\n"),
2170                         gpg_strerror (rc));
2171               goto leave;
2172             }
2173           if (strlen (resetcode) < minlen)
2174             {
2175               log_info (_("Reset Code is too short; minimum length is %d\n"),
2176                         minlen);
2177               rc = gpg_error (GPG_ERR_BAD_PIN);
2178               goto leave;
2179             }
2180         }
2181       else
2182         {
2183           rc = gpg_error (GPG_ERR_INV_ID);
2184           goto leave;
2185         }
2186     }
2187
2188   if (chvno == 3)
2189     app->did_chv3 = 0;
2190   else
2191     app->did_chv1 = app->did_chv2 = 0;
2192
2193   if (!use_pinpad)
2194     {
2195       /* TRANSLATORS: Do not translate the "|*|" prefixes but
2196          keep it at the start of the string.  We need this elsewhere
2197          to get some infos on the string. */
2198       rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2199                   chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2200                   &pinvalue);
2201       if (rc)
2202         {
2203           log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2204           goto leave;
2205         }
2206     }
2207
2208
2209   if (resetcode)
2210     {
2211       char *buffer;
2212
2213       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2214       if (!buffer)
2215         rc = gpg_error_from_syserror ();
2216       else
2217         {
2218           strcpy (stpcpy (buffer, resetcode), pinvalue);
2219           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2220                                                     buffer, strlen (buffer));
2221           wipememory (buffer, strlen (buffer));
2222           xfree (buffer);
2223         }
2224     }
2225   else if (set_resetcode)
2226     {
2227       if (strlen (pinvalue) < 8)
2228         {
2229           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2230           rc = gpg_error (GPG_ERR_BAD_PIN);
2231         }
2232       else
2233         rc = iso7816_put_data (app->slot, 0, 0xD3,
2234                                pinvalue, strlen (pinvalue));
2235     }
2236   else if (reset_mode)
2237     {
2238       rc = iso7816_reset_retry_counter (app->slot, 0x81,
2239                                         pinvalue, strlen (pinvalue));
2240       if (!rc && !app->app_local->extcap.is_v2)
2241         rc = iso7816_reset_retry_counter (app->slot, 0x82,
2242                                           pinvalue, strlen (pinvalue));
2243     }
2244   else if (!app->app_local->extcap.is_v2)
2245     {
2246       /* Version 1 cards.  */
2247       if (chvno == 1 || chvno == 2)
2248         {
2249           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2250                                               pinvalue, strlen (pinvalue));
2251           if (!rc)
2252             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2253                                                 pinvalue, strlen (pinvalue));
2254         }
2255       else /* CHVNO == 3 */
2256         {
2257           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2258                                               pinvalue, strlen (pinvalue));
2259         }
2260     }
2261   else
2262     {
2263       /* Version 2 cards.  */
2264       assert (chvno == 1 || chvno == 3);
2265
2266       if (use_pinpad)
2267         {
2268           rc = pincb (pincb_arg,
2269                       chvno == 3 ?
2270                       _("||Please enter the Admin PIN and New Admin PIN") :
2271                       _("||Please enter the PIN and New PIN"), NULL);
2272           if (rc)
2273             {
2274               log_info (_("PIN callback returned error: %s\n"),
2275                         gpg_strerror (rc));
2276               goto leave;
2277             }
2278           rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
2279                                                  &pininfo);
2280           /* Dismiss the prompt. */
2281           pincb (pincb_arg, NULL, NULL);
2282         }
2283       else
2284         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2285                                             oldpinvalue, strlen (oldpinvalue),
2286                                             pinvalue, strlen (pinvalue));
2287     }
2288
2289   if (pinvalue)
2290     {
2291       wipememory (pinvalue, strlen (pinvalue));
2292       xfree (pinvalue);
2293     }
2294   if (rc)
2295     flush_cache_after_error (app);
2296
2297  leave:
2298   if (resetcode)
2299     {
2300       wipememory (resetcode, strlen (resetcode));
2301       xfree (resetcode);
2302     }
2303   if (oldpinvalue)
2304     {
2305       wipememory (oldpinvalue, strlen (oldpinvalue));
2306       xfree (oldpinvalue);
2307     }
2308   return rc;
2309 }
2310
2311
2312 /* Check whether a key already exists.  KEYIDX is the index of the key
2313    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2314    error returned if the key already exists.  The flag GENERATING is
2315    only used to print correct messages. */
2316 static gpg_error_t
2317 does_key_exist (app_t app, int keyidx, int generating, int force)
2318 {
2319   const unsigned char *fpr;
2320   unsigned char *buffer;
2321   size_t buflen, n;
2322   int i;
2323
2324   assert (keyidx >=0 && keyidx <= 2);
2325
2326   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2327     {
2328       log_error (_("error reading application data\n"));
2329       return gpg_error (GPG_ERR_GENERAL);
2330     }
2331   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2332   if (!fpr || n < 60)
2333     {
2334       log_error (_("error reading fingerprint DO\n"));
2335       xfree (buffer);
2336       return gpg_error (GPG_ERR_GENERAL);
2337     }
2338   fpr += 20*keyidx;
2339   for (i=0; i < 20 && !fpr[i]; i++)
2340     ;
2341   xfree (buffer);
2342   if (i!=20 && !force)
2343     {
2344       log_error (_("key already exists\n"));
2345       return gpg_error (GPG_ERR_EEXIST);
2346     }
2347   else if (i!=20)
2348     log_info (_("existing key will be replaced\n"));
2349   else if (generating)
2350     log_info (_("generating new key\n"));
2351   else
2352     log_info (_("writing new key\n"));
2353   return 0;
2354 }
2355
2356
2357 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2358    of tag and length.  A LENGTH greater than 65535 is truncated. */
2359 static size_t
2360 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2361 {
2362   unsigned char *p = buffer;
2363
2364   assert (tag <= 0xffff);
2365   if ( tag > 0xff )
2366     *p++ = tag >> 8;
2367   *p++ = tag;
2368   if (length < 128)
2369     *p++ = length;
2370   else if (length < 256)
2371     {
2372       *p++ = 0x81;
2373       *p++ = length;
2374     }
2375   else
2376     {
2377       if (length > 0xffff)
2378         length = 0xffff;
2379       *p++ = 0x82;
2380       *p++ = length >> 8;
2381       *p++ = length;
2382     }
2383
2384   return p - buffer;
2385 }
2386
2387
2388 /* Build the private key template as specified in the OpenPGP specs
2389    v2.0 section 4.3.3.7.  */
2390 static gpg_error_t
2391 build_privkey_template (app_t app, int keyno,
2392                         const unsigned char *rsa_n, size_t rsa_n_len,
2393                         const unsigned char *rsa_e, size_t rsa_e_len,
2394                         const unsigned char *rsa_p, size_t rsa_p_len,
2395                         const unsigned char *rsa_q, size_t rsa_q_len,
2396                         const unsigned char *rsa_u, size_t rsa_u_len,
2397                         const unsigned char *rsa_dp, size_t rsa_dp_len,
2398                         const unsigned char *rsa_dq, size_t rsa_dq_len,
2399                         unsigned char **result, size_t *resultlen)
2400 {
2401   size_t rsa_e_reqlen;
2402   unsigned char privkey[7*(1+3+3)];
2403   size_t privkey_len;
2404   unsigned char exthdr[2+2+3];
2405   size_t exthdr_len;
2406   unsigned char suffix[2+3];
2407   size_t suffix_len;
2408   unsigned char *tp;
2409   size_t datalen;
2410   unsigned char *template;
2411   size_t template_size;
2412
2413   *result = NULL;
2414   *resultlen = 0;
2415
2416   switch (app->app_local->keyattr[keyno].format)
2417     {
2418     case RSA_STD:
2419     case RSA_STD_N:
2420     case RSA_CRT:
2421     case RSA_CRT_N:
2422       break;
2423
2424     default:
2425       return gpg_error (GPG_ERR_INV_VALUE);
2426     }
2427
2428   /* Get the required length for E. Rounded up to the nearest byte  */
2429   rsa_e_reqlen = (app->app_local->keyattr[keyno].e_bits + 7) / 8;
2430   assert (rsa_e_len <= rsa_e_reqlen);
2431
2432   /* Build the 7f48 cardholder private key template.  */
2433   datalen = 0;
2434   tp = privkey;
2435
2436   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2437   datalen += rsa_e_reqlen;
2438
2439   tp += add_tlv (tp, 0x92, rsa_p_len);
2440   datalen += rsa_p_len;
2441
2442   tp += add_tlv (tp, 0x93, rsa_q_len);
2443   datalen += rsa_q_len;
2444
2445   if (app->app_local->keyattr[keyno].format == RSA_CRT
2446       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2447     {
2448       tp += add_tlv (tp, 0x94, rsa_u_len);
2449       datalen += rsa_u_len;
2450       tp += add_tlv (tp, 0x95, rsa_dp_len);
2451       datalen += rsa_dp_len;
2452       tp += add_tlv (tp, 0x96, rsa_dq_len);
2453       datalen += rsa_dq_len;
2454     }
2455
2456   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2457       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2458     {
2459       tp += add_tlv (tp, 0x97, rsa_n_len);
2460       datalen += rsa_n_len;
2461     }
2462   privkey_len = tp - privkey;
2463
2464   /* Build the extended header list without the private key template.  */
2465   tp = exthdr;
2466   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2467   *tp++ = 0;
2468   tp += add_tlv (tp, 0x7f48, privkey_len);
2469   exthdr_len = tp - exthdr;
2470
2471   /* Build the 5f48 suffix of the data.  */
2472   tp = suffix;
2473   tp += add_tlv (tp, 0x5f48, datalen);
2474   suffix_len = tp - suffix;
2475
2476   /* Now concatenate everything.  */
2477   template_size = (1 + 3   /* 0x4d and len. */
2478                    + exthdr_len
2479                    + privkey_len
2480                    + suffix_len
2481                    + datalen);
2482   tp = template = xtrymalloc_secure (template_size);
2483   if (!template)
2484     return gpg_error_from_syserror ();
2485
2486   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2487   memcpy (tp, exthdr, exthdr_len);
2488   tp += exthdr_len;
2489   memcpy (tp, privkey, privkey_len);
2490   tp += privkey_len;
2491   memcpy (tp, suffix, suffix_len);
2492   tp += suffix_len;
2493
2494   memcpy (tp, rsa_e, rsa_e_len);
2495   if (rsa_e_len < rsa_e_reqlen)
2496     {
2497       /* Right justify E. */
2498       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2499       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2500     }
2501   tp += rsa_e_reqlen;
2502
2503   memcpy (tp, rsa_p, rsa_p_len);
2504   tp += rsa_p_len;
2505
2506   memcpy (tp, rsa_q, rsa_q_len);
2507   tp += rsa_q_len;
2508
2509   if (app->app_local->keyattr[keyno].format == RSA_CRT
2510       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2511     {
2512       memcpy (tp, rsa_u, rsa_u_len);
2513       tp += rsa_u_len;
2514       memcpy (tp, rsa_dp, rsa_dp_len);
2515       tp += rsa_dp_len;
2516       memcpy (tp, rsa_dq, rsa_dq_len);
2517       tp += rsa_dq_len;
2518     }
2519
2520   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2521       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2522     {
2523       memcpy (tp, rsa_n, rsa_n_len);
2524       tp += rsa_n_len;
2525     }
2526
2527   /* Sanity check.  We don't know the exact length because we
2528      allocated 3 bytes for the first length header.  */
2529   assert (tp - template <= template_size);
2530
2531   *result = template;
2532   *resultlen = tp - template;
2533   return 0;
2534 }
2535
2536
2537 /* Helper for do_writekley to change the size of a key.  Not ethat
2538    this deletes the entire key without asking.  */
2539 static gpg_error_t
2540 change_keyattr (app_t app, int keyno, unsigned int nbits,
2541                 gpg_error_t (*pincb)(void*, const char *, char **),
2542                 void *pincb_arg)
2543 {
2544   gpg_error_t err;
2545   unsigned char *buffer;
2546   size_t buflen;
2547   void *relptr;
2548
2549   assert (keyno >=0 && keyno <= 2);
2550
2551   if (nbits > 4096)
2552     return gpg_error (GPG_ERR_TOO_LARGE);
2553
2554   /* Read the current attributes into a buffer.  */
2555   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
2556   if (!relptr)
2557     return gpg_error (GPG_ERR_CARD);
2558   if (buflen < 6 || buffer[0] != PUBKEY_ALGO_RSA)
2559     {
2560       /* Attriutes too short or not an RSA key.  */
2561       xfree (relptr);
2562       return gpg_error (GPG_ERR_CARD);
2563     }
2564
2565   /* We only change n_bits and don't touch anything else.  Before we
2566      do so, we round up NBITS to a sensible way in the same way as
2567      gpg's key generation does it.  This may help to sort out problems
2568      with a few bits too short keys.  */
2569   nbits = ((nbits + 31) / 32) * 32;
2570   buffer[1] = (nbits >> 8);
2571   buffer[2] = nbits;
2572
2573   /* Prepare for storing the key.  */
2574   err = verify_chv3 (app, pincb, pincb_arg);
2575   if (err)
2576     {
2577       xfree (relptr);
2578       return err;
2579     }
2580
2581   /* Change the attribute.  */
2582   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buffer, buflen);
2583   xfree (relptr);
2584   if (err)
2585     log_error ("error changing size of key %d to %u bits\n", keyno+1, nbits);
2586   else
2587     log_info ("size of key %d changed to %u bits\n", keyno+1, nbits);
2588   flush_cache (app);
2589   parse_algorithm_attribute (app, keyno);
2590   app->did_chv1 = 0;
2591   app->did_chv2 = 0;
2592   app->did_chv3 = 0;
2593   return err;
2594 }
2595
2596
2597 /* Helper to process an setattr command for name KEY-ATTR.  It expects
2598    a string "--force <keyno> <algo> <nbits>" in (VALUE,VALUELEN).  */
2599 static gpg_error_t
2600 change_keyattr_from_string (app_t app,
2601                             gpg_error_t (*pincb)(void*, const char *, char **),
2602                             void *pincb_arg,
2603                             const void *value, size_t valuelen)
2604 {
2605   gpg_error_t err;
2606   char *string;
2607   int keyno, algo;
2608   unsigned int nbits;
2609
2610   /* VALUE is expected to be a string but not guaranteed to be
2611      terminated.  Thus copy it to an allocated buffer first. */
2612   string = xtrymalloc (valuelen+1);
2613   if (!string)
2614     return gpg_error_from_syserror ();
2615   memcpy (string, value, valuelen);
2616   string[valuelen] = 0;
2617
2618   /* Because this function deletes the key we require the string
2619      "--force" in the data to make clear that something serious might
2620      happen.  */
2621   if (sscanf (string, " --force %d %d %u", &keyno, &algo, &nbits) != 3)
2622     err = gpg_error (GPG_ERR_INV_DATA);
2623   keyno = keyno - 1;
2624   if (!err)
2625     {
2626       if (keyno < 0 || keyno > 2)
2627         err = gpg_error (GPG_ERR_INV_ID);
2628       else if (algo != PUBKEY_ALGO_RSA)
2629         err = gpg_error (GPG_ERR_PUBKEY_ALGO);
2630       else if (nbits < 1024)
2631         err = gpg_error (GPG_ERR_TOO_SHORT);
2632       else
2633         err = change_keyattr (app, keyno, nbits, pincb, pincb_arg);
2634     }
2635
2636   xfree (string);
2637   return err;
2638 }
2639
2640
2641 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2642    canonical encoded S-expression with the secret key in KEYDATA and
2643    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2644    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2645    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2646    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2647    the pinentry callback.  */
2648 static gpg_error_t
2649 do_writekey (app_t app, ctrl_t ctrl,
2650              const char *keyid, unsigned int flags,
2651              gpg_error_t (*pincb)(void*, const char *, char **),
2652              void *pincb_arg,
2653              const unsigned char *keydata, size_t keydatalen)
2654 {
2655   gpg_error_t err;
2656   int force = (flags & 1);
2657   int keyno;
2658   const unsigned char *buf, *tok;
2659   size_t buflen, toklen;
2660   int depth, last_depth1, last_depth2;
2661   const unsigned char *rsa_n = NULL;
2662   const unsigned char *rsa_e = NULL;
2663   const unsigned char *rsa_p = NULL;
2664   const unsigned char *rsa_q = NULL;
2665   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2666   unsigned int nbits;
2667   unsigned int maxbits;
2668   unsigned char *template = NULL;
2669   unsigned char *tp;
2670   size_t template_len;
2671   unsigned char fprbuf[20];
2672   u32 created_at = 0;
2673
2674   (void)ctrl;
2675
2676   if (!strcmp (keyid, "OPENPGP.1"))
2677     keyno = 0;
2678   else if (!strcmp (keyid, "OPENPGP.2"))
2679     keyno = 1;
2680   else if (!strcmp (keyid, "OPENPGP.3"))
2681     keyno = 2;
2682   else
2683     return gpg_error (GPG_ERR_INV_ID);
2684
2685   err = does_key_exist (app, keyno, 0, force);
2686   if (err)
2687     return err;
2688
2689
2690   /*
2691      Parse the S-expression
2692    */
2693   buf = keydata;
2694   buflen = keydatalen;
2695   depth = 0;
2696   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2697     goto leave;
2698   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2699     goto leave;
2700   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2701     {
2702       if (!tok)
2703         ;
2704       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2705         log_info ("protected-private-key passed to writekey\n");
2706       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2707         log_info ("shadowed-private-key passed to writekey\n");
2708       err = gpg_error (GPG_ERR_BAD_SECKEY);
2709       goto leave;
2710     }
2711   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2712     goto leave;
2713   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2714     goto leave;
2715   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2716     {
2717       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2718       goto leave;
2719     }
2720   last_depth1 = depth;
2721   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2722          && depth && depth >= last_depth1)
2723     {
2724       if (tok)
2725         {
2726           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2727           goto leave;
2728         }
2729       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2730         goto leave;
2731       if (tok && toklen == 1)
2732         {
2733           const unsigned char **mpi;
2734           size_t *mpi_len;
2735
2736           switch (*tok)
2737             {
2738             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
2739             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
2740             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
2741             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
2742             default: mpi = NULL;  mpi_len = NULL; break;
2743             }
2744           if (mpi && *mpi)
2745             {
2746               err = gpg_error (GPG_ERR_DUP_VALUE);
2747               goto leave;
2748             }
2749           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2750             goto leave;
2751           if (tok && mpi)
2752             {
2753               /* Strip off leading zero bytes and save. */
2754               for (;toklen && !*tok; toklen--, tok++)
2755                 ;
2756               *mpi = tok;
2757               *mpi_len = toklen;
2758             }
2759         }
2760       /* Skip until end of list. */
2761       last_depth2 = depth;
2762       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2763              && depth && depth >= last_depth2)
2764         ;
2765       if (err)
2766         goto leave;
2767     }
2768   /* Parse other attributes. */
2769   last_depth1 = depth;
2770   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2771          && depth && depth >= last_depth1)
2772     {
2773       if (tok)
2774         {
2775           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2776           goto leave;
2777         }
2778       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2779         goto leave;
2780       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2781         {
2782           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2783             goto leave;
2784           if (tok)
2785             {
2786               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2787                    tok++, toklen--)
2788                 created_at = created_at*10 + (*tok - '0');
2789             }
2790         }
2791       /* Skip until end of list. */
2792       last_depth2 = depth;
2793       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2794              && depth && depth >= last_depth2)
2795         ;
2796       if (err)
2797         goto leave;
2798     }
2799
2800
2801   /* Check that we have all parameters and that they match the card
2802      description. */
2803   if (!created_at)
2804     {
2805       log_error (_("creation timestamp missing\n"));
2806       err = gpg_error (GPG_ERR_INV_VALUE);
2807       goto leave;
2808     }
2809
2810   maxbits = app->app_local->keyattr[keyno].n_bits;
2811   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2812   if (opt.verbose)
2813     log_info ("RSA modulus size is %u bits (%u bytes)\n",
2814               nbits, (unsigned int)rsa_n_len);
2815   if (nbits && nbits != maxbits
2816       && app->app_local->extcap.algo_attr_change)
2817     {
2818       /* Try to switch the key to a new length.  */
2819       err = change_keyattr (app, keyno, nbits, pincb, pincb_arg);
2820       if (!err)
2821         maxbits = app->app_local->keyattr[keyno].n_bits;
2822     }
2823   if (nbits != maxbits)
2824     {
2825       log_error (_("RSA modulus missing or not of size %d bits\n"),
2826                  (int)maxbits);
2827       err = gpg_error (GPG_ERR_BAD_SECKEY);
2828       goto leave;
2829     }
2830
2831   maxbits = app->app_local->keyattr[keyno].e_bits;
2832   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2833     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2834   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2835   if (nbits < 2 || nbits > maxbits)
2836     {
2837       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2838                  (int)maxbits);
2839       err = gpg_error (GPG_ERR_BAD_SECKEY);
2840       goto leave;
2841     }
2842
2843   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2844   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2845   if (nbits != maxbits)
2846     {
2847       log_error (_("RSA prime %s missing or not of size %d bits\n"),
2848                  "P", (int)maxbits);
2849       err = gpg_error (GPG_ERR_BAD_SECKEY);
2850       goto leave;
2851     }
2852   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2853   if (nbits != maxbits)
2854     {
2855       log_error (_("RSA prime %s missing or not of size %d bits\n"),
2856                  "Q", (int)maxbits);
2857       err = gpg_error (GPG_ERR_BAD_SECKEY);
2858       goto leave;
2859     }
2860
2861   /* We need to remove the cached public key.  */
2862   xfree (app->app_local->pk[keyno].key);
2863   app->app_local->pk[keyno].key = NULL;
2864   app->app_local->pk[keyno].keylen = 0;
2865   app->app_local->pk[keyno].read_done = 0;
2866
2867
2868   if (app->app_local->extcap.is_v2)
2869     {
2870       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
2871       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
2872       gcry_mpi_t mpi_e, mpi_p, mpi_q;
2873       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
2874       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
2875       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
2876       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
2877       int exmode;
2878
2879       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
2880       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
2881       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
2882       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
2883
2884       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
2885       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
2886       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
2887       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
2888       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
2889
2890       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
2891       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
2892       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
2893
2894       gcry_mpi_release (mpi_e);
2895       gcry_mpi_release (mpi_p);
2896       gcry_mpi_release (mpi_q);
2897       gcry_mpi_release (mpi_u);
2898       gcry_mpi_release (mpi_dp);
2899       gcry_mpi_release (mpi_dq);
2900       gcry_mpi_release (mpi_tmp);
2901
2902       /* Build the private key template as described in section 4.3.3.7 of
2903          the OpenPGP card specs version 2.0.  */
2904       err = build_privkey_template (app, keyno,
2905                                     rsa_n, rsa_n_len,
2906                                     rsa_e, rsa_e_len,
2907                                     rsa_p, rsa_p_len,
2908                                     rsa_q, rsa_q_len,
2909                                     rsa_u, rsa_u_len,
2910                                     rsa_dp, rsa_dp_len,
2911                                     rsa_dq, rsa_dq_len,
2912                                     &template, &template_len);
2913       xfree(rsa_u);
2914       xfree(rsa_dp);
2915       xfree(rsa_dq);
2916
2917       if (err)
2918         goto leave;
2919
2920       /* Prepare for storing the key.  */
2921       err = verify_chv3 (app, pincb, pincb_arg);
2922       if (err)
2923         goto leave;
2924
2925       /* Store the key. */
2926       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
2927         exmode = 1;    /* Use extended length w/o a limit.  */
2928       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2929         exmode = -254;
2930       else
2931         exmode = 0;
2932       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2933                                   template, template_len);
2934     }
2935   else
2936     {
2937       /* Build the private key template as described in section 4.3.3.6 of
2938          the OpenPGP card specs version 1.1:
2939          0xC0   <length> public exponent
2940          0xC1   <length> prime p
2941          0xC2   <length> prime q
2942       */
2943       assert (rsa_e_len <= 4);
2944       template_len = (1 + 1 + 4
2945                       + 1 + 1 + rsa_p_len
2946                       + 1 + 1 + rsa_q_len);
2947       template = tp = xtrymalloc_secure (template_len);
2948       if (!template)
2949         {
2950           err = gpg_error_from_syserror ();
2951           goto leave;
2952         }
2953       *tp++ = 0xC0;
2954       *tp++ = 4;
2955       memcpy (tp, rsa_e, rsa_e_len);
2956       if (rsa_e_len < 4)
2957         {
2958           /* Right justify E. */
2959           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2960           memset (tp, 0, 4-rsa_e_len);
2961         }
2962       tp += 4;
2963
2964       *tp++ = 0xC1;
2965       *tp++ = rsa_p_len;
2966       memcpy (tp, rsa_p, rsa_p_len);
2967       tp += rsa_p_len;
2968
2969       *tp++ = 0xC2;
2970       *tp++ = rsa_q_len;
2971       memcpy (tp, rsa_q, rsa_q_len);
2972       tp += rsa_q_len;
2973
2974       assert (tp - template == template_len);
2975
2976       /* Prepare for storing the key.  */
2977       err = verify_chv3 (app, pincb, pincb_arg);
2978       if (err)
2979         goto leave;
2980
2981       /* Store the key. */
2982       err = iso7816_put_data (app->slot, 0,
2983                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2984                               template, template_len);
2985     }
2986   if (err)
2987     {
2988       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2989       goto leave;
2990     }
2991
2992   err = store_fpr (app, keyno, created_at,
2993                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2994                   fprbuf, app->card_version);
2995   if (err)
2996     goto leave;
2997
2998
2999  leave:
3000   xfree (template);
3001   return err;
3002 }
3003
3004
3005 /* Handle the GENKEY command. */
3006 static gpg_error_t
3007 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
3008            time_t createtime,
3009            gpg_error_t (*pincb)(void*, const char *, char **),
3010            void *pincb_arg)
3011 {
3012   gpg_error_t err;
3013   char numbuf[30];
3014   unsigned char fprbuf[20];
3015   const unsigned char *keydata, *m, *e;
3016   unsigned char *buffer = NULL;
3017   size_t buflen, keydatalen, mlen, elen;
3018   u32 created_at;
3019   int keyno = atoi (keynostr) - 1;
3020   int force = (flags & 1);
3021   time_t start_at;
3022   int exmode;
3023   int le_value;
3024   unsigned int keybits;
3025
3026   if (keyno < 0 || keyno > 2)
3027     return gpg_error (GPG_ERR_INV_ID);
3028
3029   /* We flush the cache to increase the traffic before a key
3030      generation.  This _might_ help a card to gather more entropy. */
3031   flush_cache (app);
3032
3033   /* Obviously we need to remove the cached public key.  */
3034   xfree (app->app_local->pk[keyno].key);
3035   app->app_local->pk[keyno].key = NULL;
3036   app->app_local->pk[keyno].keylen = 0;
3037   app->app_local->pk[keyno].read_done = 0;
3038
3039   /* Check whether a key already exists.  */
3040   err = does_key_exist (app, keyno, 1, force);
3041   if (err)
3042     return err;
3043
3044   /* Because we send the key parameter back via status lines we need
3045      to put a limit on the max. allowed keysize.  2048 bit will
3046      already lead to a 527 byte long status line and thus a 4096 bit
3047      key would exceed the Assuan line length limit.  */
3048   keybits = app->app_local->keyattr[keyno].n_bits;
3049   if (keybits > 4096)
3050     return gpg_error (GPG_ERR_TOO_LARGE);
3051
3052   /* Prepare for key generation by verifying the Admin PIN.  */
3053   err = verify_chv3 (app, pincb, pincb_arg);
3054   if (err)
3055     goto leave;
3056
3057   /* Test whether we will need extended length mode.  */
3058   if (app->app_local->cardcap.ext_lc_le && keybits > RSA_SMALL_SIZE_KEY)
3059     {
3060       exmode = 1;    /* Use extended length w/o a limit.  */
3061       le_value = determine_rsa_response (app, keyno);
3062       /* No need to check le_value because it comes from a 16 bit
3063          value and thus can't create an overflow on a 32 bit
3064          system.  */
3065     }
3066   else
3067     {
3068       exmode = 0;
3069       le_value = 256; /* Use legacy value. */
3070     }
3071
3072   log_info (_("please wait while key is being generated ...\n"));
3073   start_at = time (NULL);
3074   err = iso7816_generate_keypair (app->slot, exmode,
3075                                   (keyno == 0? "\xB6" :
3076                                    keyno == 1? "\xB8" : "\xA4"),
3077                                   2, le_value, &buffer, &buflen);
3078   if (err)
3079     {
3080       err = gpg_error (GPG_ERR_CARD);
3081       log_error (_("generating key failed\n"));
3082       goto leave;
3083     }
3084   log_info (_("key generation completed (%d seconds)\n"),
3085             (int)(time (NULL) - start_at));
3086
3087   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
3088   if (!keydata)
3089     {
3090       err = gpg_error (GPG_ERR_CARD);
3091       log_error (_("response does not contain the public key data\n"));
3092       goto leave;
3093     }
3094
3095   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
3096   if (!m)
3097     {
3098       err = gpg_error (GPG_ERR_CARD);
3099       log_error (_("response does not contain the RSA modulus\n"));
3100       goto leave;
3101     }
3102   /* log_printhex ("RSA n:", m, mlen); */
3103   send_key_data (ctrl, "n", m, mlen);
3104
3105   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
3106   if (!e)
3107     {
3108       err = gpg_error (GPG_ERR_CARD);
3109       log_error (_("response does not contain the RSA public exponent\n"));
3110       goto leave;
3111     }
3112   /* log_printhex ("RSA e:", e, elen); */
3113   send_key_data (ctrl, "e", e, elen);
3114
3115   created_at = (u32)(createtime? createtime : gnupg_get_time ());
3116   sprintf (numbuf, "%u", created_at);
3117   send_status_info (ctrl, "KEY-CREATED-AT",
3118                     numbuf, (size_t)strlen(numbuf), NULL, 0);
3119
3120   err = store_fpr (app, keyno, (u32)created_at,
3121                   m, mlen, e, elen, fprbuf, app->card_version);
3122   if (err)
3123     goto leave;
3124   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
3125
3126
3127  leave:
3128   xfree (buffer);
3129   return err;
3130 }
3131
3132
3133 static unsigned long
3134 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
3135 {
3136   unsigned long ul;
3137
3138   if (valuelen == 3 )
3139     ul = (value[0] << 16) | (value[1] << 8) | value[2];
3140   else
3141     {
3142       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
3143       ul = 0;
3144     }
3145   return ul;
3146 }
3147
3148 static unsigned long
3149 get_sig_counter (app_t app)
3150 {
3151   void *relptr;
3152   unsigned char *value;
3153   size_t valuelen;
3154   unsigned long ul;
3155
3156   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
3157   if (!relptr)
3158     return 0;
3159   ul = convert_sig_counter_value (value, valuelen);
3160   xfree (relptr);
3161   return ul;
3162 }
3163
3164 static gpg_error_t
3165 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
3166 {
3167   const unsigned char *fpr;
3168   unsigned char *buffer;
3169   size_t buflen, n;
3170   int rc, i;
3171
3172   assert (keyno >= 0 && keyno <= 2);
3173
3174   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
3175   if (rc)
3176     {
3177       log_error (_("error reading application data\n"));
3178       return gpg_error (GPG_ERR_GENERAL);
3179     }
3180   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
3181   if (!fpr || n != 60)
3182     {
3183       xfree (buffer);
3184       log_error (_("error reading fingerprint DO\n"));
3185       return gpg_error (GPG_ERR_GENERAL);
3186     }
3187   fpr += keyno*20;
3188   for (i=0; i < 20; i++)
3189     if (sha1fpr[i] != fpr[i])
3190       {
3191         xfree (buffer);
3192         log_info (_("fingerprint on card does not match requested one\n"));
3193         return gpg_error (GPG_ERR_WRONG_SECKEY);
3194       }
3195   xfree (buffer);
3196   return 0;
3197 }
3198
3199
3200 /* If a fingerprint has been specified check it against the one on the
3201    card.  This allows for a meaningful error message in case the key
3202    on the card has been replaced but the shadow information known to
3203    gpg has not been updated.  If there is no fingerprint we assume
3204    that this is okay. */
3205 static gpg_error_t
3206 check_against_given_fingerprint (app_t app, const char *fpr, int key)
3207 {
3208   unsigned char tmp[20];
3209   const char *s;
3210   int n;
3211
3212   for (s=fpr, n=0; hexdigitp (s); s++, n++)
3213     ;
3214   if (n != 40)
3215     return gpg_error (GPG_ERR_INV_ID);
3216   else if (!*s)
3217     ; /* okay */
3218   else
3219     return gpg_error (GPG_ERR_INV_ID);
3220
3221   for (s=fpr, n=0; n < 20; s += 2, n++)
3222         tmp[n] = xtoi_2 (s);
3223   return compare_fingerprint (app, key-1, tmp);
3224 }
3225
3226
3227
3228 /* Compute a digital signature on INDATA which is expected to be the
3229    raw message digest. For this application the KEYIDSTR consists of
3230    the serialnumber and the fingerprint delimited by a slash.
3231
3232    Note that this function may return the error code
3233    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3234    not match the one required for the requested action (e.g. the
3235    serial number does not match).
3236
3237    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
3238    operation to the auth command.
3239 */
3240 static gpg_error_t
3241 do_sign (app_t app, const char *keyidstr, int hashalgo,
3242          gpg_error_t (*pincb)(void*, const char *, char **),
3243          void *pincb_arg,
3244          const void *indata, size_t indatalen,
3245          unsigned char **outdata, size_t *outdatalen )
3246 {
3247   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
3248     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
3249       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
3250   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
3251     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
3252       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
3253   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
3254     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
3255       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
3256       0x1C  };
3257   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
3258     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3259       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
3260       0x00, 0x04, 0x20  };
3261   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
3262     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3263       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
3264       0x00, 0x04, 0x30  };
3265   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
3266     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3267       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
3268       0x00, 0x04, 0x40  };
3269   int rc;
3270   unsigned char data[19+64];
3271   size_t datalen;
3272   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
3273   const char *s;
3274   int n;
3275   const char *fpr = NULL;
3276   unsigned long sigcount;
3277   int use_auth = 0;
3278   int exmode, le_value;
3279
3280   if (!keyidstr || !*keyidstr)
3281     return gpg_error (GPG_ERR_INV_VALUE);
3282
3283   /* Strip off known prefixes.  */
3284 #define X(a,b,c,d) \
3285   if (hashalgo == GCRY_MD_ ## a                               \
3286       && (d)                                                  \
3287       && indatalen == sizeof b ## _prefix + (c)               \
3288       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
3289     {                                                         \
3290       indata = (const char*)indata + sizeof b ## _prefix;     \
3291       indatalen -= sizeof b ## _prefix;                       \
3292     }
3293
3294   if (indatalen == 20)
3295     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
3296   else X(SHA1,   sha1,   20, 1)
3297   else X(RMD160, rmd160, 20, 1)
3298   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
3299   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
3300   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
3301   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
3302   else if ((indatalen == 28 || indatalen == 32
3303             || indatalen == 48 || indatalen ==64)
3304            && app->app_local->extcap.is_v2)
3305     ;  /* Assume a plain SHA-3 digest has been given.  */
3306   else
3307     {
3308       log_error (_("card does not support digest algorithm %s\n"),
3309                  gcry_md_algo_name (hashalgo));
3310       /* Or the supplied digest length does not match an algorithm.  */
3311       return gpg_error (GPG_ERR_INV_VALUE);
3312     }
3313 #undef X
3314
3315   /* Check whether an OpenPGP card of any version has been requested. */
3316   if (!strcmp (keyidstr, "OPENPGP.1"))
3317     ;
3318   else if (!strcmp (keyidstr, "OPENPGP.3"))
3319     use_auth = 1;
3320   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3321     return gpg_error (GPG_ERR_INV_ID);
3322   else
3323     {
3324       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3325         ;
3326       if (n != 32)
3327         return gpg_error (GPG_ERR_INV_ID);
3328       else if (!*s)
3329         ; /* no fingerprint given: we allow this for now. */
3330       else if (*s == '/')
3331         fpr = s + 1;
3332       else
3333         return gpg_error (GPG_ERR_INV_ID);
3334
3335       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3336         tmp_sn[n] = xtoi_2 (s);
3337
3338       if (app->serialnolen != 16)
3339         return gpg_error (GPG_ERR_INV_CARD);
3340       if (memcmp (app->serialno, tmp_sn, 16))
3341         return gpg_error (GPG_ERR_WRONG_CARD);
3342     }
3343
3344   /* If a fingerprint has been specified check it against the one on
3345      the card.  This is allows for a meaningful error message in case
3346      the key on the card has been replaced but the shadow information
3347      known to gpg was not updated.  If there is no fingerprint, gpg
3348      will detect a bogus signature anyway due to the
3349      verify-after-signing feature. */
3350   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
3351   if (rc)
3352     return rc;
3353
3354   /* Concatenate prefix and digest.  */
3355 #define X(a,b,d) \
3356   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
3357     {                                                         \
3358       datalen = sizeof b ## _prefix + indatalen;              \
3359       assert (datalen <= sizeof data);                        \
3360       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
3361       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
3362     }
3363
3364   X(SHA1,   sha1,   1)
3365   else X(RMD160, rmd160, 1)
3366   else X(SHA224, sha224, app->app_local->extcap.is_v2)
3367   else X(SHA256, sha256, app->app_local->extcap.is_v2)
3368   else X(SHA384, sha384, app->app_local->extcap.is_v2)
3369   else X(SHA512, sha512, app->app_local->extcap.is_v2)
3370   else
3371     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3372 #undef X
3373
3374   /* Redirect to the AUTH command if asked to. */
3375   if (use_auth)
3376     {
3377       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
3378                       data, datalen,
3379                       outdata, outdatalen);
3380     }
3381
3382   /* Show the number of signature done using this key.  */
3383   sigcount = get_sig_counter (app);
3384   log_info (_("signatures created so far: %lu\n"), sigcount);
3385
3386   /* Check CHV if needed.  */
3387   if (!app->did_chv1 || app->force_chv1 )
3388     {
3389       char *pinvalue;
3390
3391       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
3392       if (rc)
3393         return rc;
3394
3395       app->did_chv1 = 1;
3396
3397       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
3398          sync, thus we verify CHV2 here using the given PIN.  Cards
3399          with version2 to not have the need for a separate CHV2 and
3400          internally use just one.  Obviously we can't do that if the
3401          pinpad has been used. */
3402       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
3403         {
3404           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
3405           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
3406             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
3407           if (rc)
3408             {
3409               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
3410               xfree (pinvalue);
3411               flush_cache_after_error (app);
3412               return rc;
3413             }
3414           app->did_chv2 = 1;
3415         }
3416       xfree (pinvalue);
3417     }
3418
3419
3420   if (app->app_local->cardcap.ext_lc_le
3421       && app->app_local->keyattr[0].n_bits > RSA_SMALL_SIZE_OP)
3422     {
3423       exmode = 1;    /* Use extended length.  */
3424       le_value = app->app_local->keyattr[0].n_bits / 8;
3425     }
3426   else
3427     {
3428       exmode = 0;
3429       le_value = 0;
3430     }
3431   rc = iso7816_compute_ds (app->slot, exmode, data, datalen, le_value,
3432                            outdata, outdatalen);
3433   return rc;
3434 }
3435
3436 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
3437    on INDATA which is expected to be the raw message digest. For this
3438    application the KEYIDSTR consists of the serialnumber and the
3439    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
3440    be given.
3441
3442    Note that this function may return the error code
3443    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3444    not match the one required for the requested action (e.g. the
3445    serial number does not match). */
3446 static gpg_error_t
3447 do_auth (app_t app, const char *keyidstr,
3448          gpg_error_t (*pincb)(void*, const char *, char **),
3449          void *pincb_arg,
3450          const void *indata, size_t indatalen,
3451          unsigned char **outdata, size_t *outdatalen )
3452 {
3453   int rc;
3454   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
3455   const char *s;
3456   int n;
3457   const char *fpr = NULL;
3458
3459   if (!keyidstr || !*keyidstr)
3460     return gpg_error (GPG_ERR_INV_VALUE);
3461   if (indatalen > 101) /* For a 2048 bit key. */
3462     return gpg_error (GPG_ERR_INV_VALUE);
3463
3464   /* Check whether an OpenPGP card of any version has been requested. */
3465   if (!strcmp (keyidstr, "OPENPGP.3"))
3466     ;
3467   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3468     return gpg_error (GPG_ERR_INV_ID);
3469   else
3470     {
3471       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3472         ;
3473       if (n != 32)
3474         return gpg_error (GPG_ERR_INV_ID);
3475       else if (!*s)
3476         ; /* no fingerprint given: we allow this for now. */
3477       else if (*s == '/')
3478         fpr = s + 1;
3479       else
3480         return gpg_error (GPG_ERR_INV_ID);
3481
3482       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3483         tmp_sn[n] = xtoi_2 (s);
3484
3485       if (app->serialnolen != 16)
3486         return gpg_error (GPG_ERR_INV_CARD);
3487       if (memcmp (app->serialno, tmp_sn, 16))
3488         return gpg_error (GPG_ERR_WRONG_CARD);
3489     }
3490
3491   /* If a fingerprint has been specified check it against the one on
3492      the card.  This is allows for a meaningful error message in case
3493      the key on the card has been replaced but the shadow information
3494      known to gpg was not updated.  If there is no fingerprint, gpg
3495      will detect a bogus signature anyway due to the
3496      verify-after-signing feature. */
3497   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
3498   if (rc)
3499     return rc;
3500
3501   rc = verify_chv2 (app, pincb, pincb_arg);
3502   if (!rc)
3503     {
3504       int exmode, le_value;
3505
3506       if (app->app_local->cardcap.ext_lc_le
3507           && app->app_local->keyattr[2].n_bits > RSA_SMALL_SIZE_OP)
3508         {
3509           exmode = 1;    /* Use extended length.  */
3510           le_value = app->app_local->keyattr[2].n_bits / 8;
3511         }
3512       else
3513         {
3514           exmode = 0;
3515           le_value = 0;
3516         }
3517       rc = iso7816_internal_authenticate (app->slot, exmode,
3518                                           indata, indatalen, le_value,
3519                                           outdata, outdatalen);
3520     }
3521   return rc;
3522 }
3523
3524
3525 static gpg_error_t
3526 do_decipher (app_t app, const char *keyidstr,
3527              gpg_error_t (*pincb)(void*, const char *, char **),
3528              void *pincb_arg,
3529              const void *indata, size_t indatalen,
3530              unsigned char **outdata, size_t *outdatalen )
3531 {
3532   int rc;
3533   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
3534   const char *s;
3535   int n;
3536   const char *fpr = NULL;
3537   int exmode, le_value;
3538
3539   if (!keyidstr || !*keyidstr || !indatalen)
3540     return gpg_error (GPG_ERR_INV_VALUE);
3541
3542   /* Check whether an OpenPGP card of any version has been requested. */
3543   if (!strcmp (keyidstr, "OPENPGP.2"))
3544     ;
3545   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3546     return gpg_error (GPG_ERR_INV_ID);
3547   else
3548     {
3549       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3550         ;
3551       if (n != 32)
3552         return gpg_error (GPG_ERR_INV_ID);
3553       else if (!*s)
3554         ; /* no fingerprint given: we allow this for now. */
3555       else if (*s == '/')
3556         fpr = s + 1;