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