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