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