c87add14aee6c66a843267cfc0d9f5c68205ec60
[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   if (app->app_local->extcap.kdf_do)
1837     do_getattr (app, ctrl, "KDF");
1838   if (app->app_local->extcap.has_button)
1839     {
1840       do_getattr (app, ctrl, "UIF-1");
1841       do_getattr (app, ctrl, "UIF-2");
1842       do_getattr (app, ctrl, "UIF-3");
1843     }
1844   if (app->app_local->extcap.private_dos)
1845     {
1846       do_getattr (app, ctrl, "PRIVATE-DO-1");
1847       do_getattr (app, ctrl, "PRIVATE-DO-2");
1848       if (app->did_chv2)
1849         do_getattr (app, ctrl, "PRIVATE-DO-3");
1850       if (app->did_chv3)
1851         do_getattr (app, ctrl, "PRIVATE-DO-4");
1852     }
1853   send_keypair_info (app, ctrl, 1);
1854   send_keypair_info (app, ctrl, 2);
1855   send_keypair_info (app, ctrl, 3);
1856   /* Note: We do not send the Cardholder Certificate, because that is
1857      relatively long and for OpenPGP applications not really needed.  */
1858   return 0;
1859 }
1860
1861
1862 /* Handle the READKEY command for OpenPGP.  On success a canonical
1863    encoded S-expression with the public key will get stored at PK and
1864    its length (for assertions) at PKLEN; the caller must release that
1865    buffer. On error PK and PKLEN are not changed and an error code is
1866    returned.  */
1867 static gpg_error_t
1868 do_readkey (app_t app, int advanced, const char *keyid,
1869             unsigned char **pk, size_t *pklen)
1870 {
1871 #if GNUPG_MAJOR_VERSION > 1
1872   gpg_error_t err;
1873   int keyno;
1874   unsigned char *buf;
1875
1876   if (!strcmp (keyid, "OPENPGP.1"))
1877     keyno = 0;
1878   else if (!strcmp (keyid, "OPENPGP.2"))
1879     keyno = 1;
1880   else if (!strcmp (keyid, "OPENPGP.3"))
1881     keyno = 2;
1882   else
1883     return gpg_error (GPG_ERR_INV_ID);
1884
1885   err = get_public_key (app, keyno);
1886   if (err)
1887     return err;
1888
1889   buf = app->app_local->pk[keyno].key;
1890   if (!buf)
1891     return gpg_error (GPG_ERR_NO_PUBKEY);
1892
1893   if (advanced)
1894     {
1895       gcry_sexp_t s_key;
1896
1897       err = gcry_sexp_new (&s_key, buf, app->app_local->pk[keyno].keylen, 0);
1898       if (err)
1899         return err;
1900
1901       *pklen = gcry_sexp_sprint (s_key, GCRYSEXP_FMT_ADVANCED, NULL, 0);
1902       *pk = xtrymalloc (*pklen);
1903       if (!*pk)
1904         {
1905           err = gpg_error_from_syserror ();
1906           *pklen = 0;
1907           return err;
1908         }
1909
1910       gcry_sexp_sprint (s_key, GCRYSEXP_FMT_ADVANCED, *pk, *pklen);
1911       gcry_sexp_release (s_key);
1912       /* Decrement for trailing '\0' */
1913       *pklen = *pklen - 1;
1914     }
1915   else
1916     {
1917       *pklen = app->app_local->pk[keyno].keylen;
1918       *pk = xtrymalloc (*pklen);
1919       if (!*pk)
1920         {
1921           err = gpg_error_from_syserror ();
1922           *pklen = 0;
1923           return err;
1924         }
1925       memcpy (*pk, buf, *pklen);
1926     }
1927
1928   return 0;
1929 #else
1930   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1931 #endif
1932 }
1933
1934 /* Read the standard certificate of an OpenPGP v2 card.  It is
1935    returned in a freshly allocated buffer with that address stored at
1936    CERT and the length of the certificate stored at CERTLEN.  CERTID
1937    needs to be set to "OPENPGP.3".  */
1938 static gpg_error_t
1939 do_readcert (app_t app, const char *certid,
1940              unsigned char **cert, size_t *certlen)
1941 {
1942 #if GNUPG_MAJOR_VERSION > 1
1943   gpg_error_t err;
1944   unsigned char *buffer;
1945   size_t buflen;
1946   void *relptr;
1947
1948   *cert = NULL;
1949   *certlen = 0;
1950   if (strcmp (certid, "OPENPGP.3"))
1951     return gpg_error (GPG_ERR_INV_ID);
1952   if (!app->app_local->extcap.is_v2)
1953     return gpg_error (GPG_ERR_NOT_FOUND);
1954
1955   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1956   if (!relptr)
1957     return gpg_error (GPG_ERR_NOT_FOUND);
1958
1959   if (!buflen)
1960     err = gpg_error (GPG_ERR_NOT_FOUND);
1961   else if (!(*cert = xtrymalloc (buflen)))
1962     err = gpg_error_from_syserror ();
1963   else
1964     {
1965       memcpy (*cert, buffer, buflen);
1966       *certlen = buflen;
1967       err  = 0;
1968     }
1969   xfree (relptr);
1970   return err;
1971 #else
1972   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1973 #endif
1974 }
1975
1976
1977 /* Decide if we use the pinpad of the reader for PIN input according
1978    to the user preference on the card, and the capability of the
1979    reader.  This routine is only called when the reader has pinpad.
1980    Returns 0 if we use pinpad, 1 otherwise.  */
1981 static int
1982 check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1983 {
1984   if (app->app_local->pinpad.specified == 0) /* No preference on card.  */
1985     {
1986       if (pininfo->fixedlen == 0) /* Reader has varlen capability.  */
1987         return 0;                 /* Then, use pinpad.  */
1988       else
1989         /*
1990          * Reader has limited capability, and it may not match PIN of
1991          * the card.
1992          */
1993         return 1;
1994     }
1995
1996   if (admin_pin)
1997     pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
1998   else
1999     pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
2000
2001   if (pininfo->fixedlen == 0    /* User requests disable pinpad.  */
2002       || pininfo->fixedlen < pininfo->minlen
2003       || pininfo->fixedlen > pininfo->maxlen
2004       /* Reader doesn't have the capability to input a PIN which
2005        * length is FIXEDLEN.  */)
2006     return 1;
2007
2008   return 0;
2009 }
2010
2011
2012 /* Return a string with information about the card for use in a
2013  * prompt.  Returns NULL on memory failure.  */
2014 static char *
2015 get_prompt_info (app_t app, int chvno, unsigned long sigcount, int remaining)
2016 {
2017   char *serial, *disp_name, *rembuf, *tmpbuf, *result;
2018
2019   serial = get_disp_serialno (app);
2020   if (!serial)
2021     return NULL;
2022
2023   disp_name = get_disp_name (app);
2024   if (chvno == 1)
2025     {
2026       /* TRANSLATORS: Put a \x1f right before a colon.  This can be
2027        * used by pinentry to nicely align the names and values.  Keep
2028        * the %s at the start and end of the string.  */
2029       result = xtryasprintf (_("%s"
2030                                "Number\x1f: %s%%0A"
2031                                "Holder\x1f: %s%%0A"
2032                                "Counter\x1f: %lu"
2033                                "%s"),
2034                              "\x1e",
2035                              serial,
2036                              disp_name? disp_name:"",
2037                              sigcount,
2038                              "");
2039     }
2040   else
2041     {
2042       result = xtryasprintf (_("%s"
2043                                "Number\x1f: %s%%0A"
2044                                "Holder\x1f: %s"
2045                                "%s"),
2046                              "\x1e",
2047                              serial,
2048                              disp_name? disp_name:"",
2049                              "");
2050     }
2051   xfree (disp_name);
2052   xfree (serial);
2053
2054   if (remaining != -1)
2055     {
2056       /* TRANSLATORS: This is the number of remaining attempts to
2057        * enter a PIN.  Use %%0A (double-percent,0A) for a linefeed. */
2058       rembuf = xtryasprintf (_("Remaining attempts: %d"), remaining);
2059       if (!rembuf)
2060         {
2061           xfree (result);
2062           return NULL;
2063         }
2064       tmpbuf = strconcat (result, "%0A%0A", rembuf, NULL);
2065       xfree (rembuf);
2066       if (!tmpbuf)
2067         {
2068           xfree (result);
2069           return NULL;
2070         }
2071       xfree (result);
2072       result = tmpbuf;
2073     }
2074
2075   return result;
2076 }
2077
2078 #define KDF_DATA_LENGTH_MIN  90
2079 #define KDF_DATA_LENGTH_MAX 110
2080
2081 /* Compute hash if KDF-DO is available.  CHVNO must be 0 for reset
2082    code, 1 or 2 for user pin and 3 for admin pin.
2083  */
2084 static gpg_error_t
2085 pin2hash_if_kdf (app_t app, int chvno, char *pinvalue, int *r_pinlen)
2086 {
2087   gpg_error_t err = 0;
2088   void *relptr = NULL;
2089   unsigned char *buffer;
2090   size_t buflen;
2091
2092   if (app->app_local->extcap.kdf_do
2093       && (relptr = get_one_do (app, 0x00F9, &buffer, &buflen, NULL))
2094       && buflen >= KDF_DATA_LENGTH_MIN && (buffer[2] == 0x03))
2095     {
2096       const char *salt;
2097       unsigned long s2k_count;
2098       char dek[32];
2099       int salt_index;
2100
2101       s2k_count = (((unsigned int)buffer[8] << 24)
2102                    | (buffer[9] << 16) | (buffer[10] << 8) | buffer[11]);
2103
2104       if (buflen == KDF_DATA_LENGTH_MIN)
2105         salt_index =14;
2106       else if (buflen == KDF_DATA_LENGTH_MAX)
2107         salt_index = (chvno==3 ? 34 : (chvno==0 ? 24 : 14));
2108       else
2109         {
2110           err = gpg_error (GPG_ERR_INV_DATA);
2111           goto leave;
2112         }
2113
2114       salt = &buffer[salt_index];
2115       err = gcry_kdf_derive (pinvalue, strlen (pinvalue),
2116                              GCRY_KDF_ITERSALTED_S2K,
2117                              DIGEST_ALGO_SHA256, salt, 8,
2118                              s2k_count, sizeof (dek), dek);
2119       if (!err)
2120         {
2121           /* pinvalue has a buffer of MAXLEN_PIN+1, 32 is OK.  */
2122           *r_pinlen = 32;
2123           memcpy (pinvalue, dek, *r_pinlen);
2124           wipememory (dek, *r_pinlen);
2125         }
2126    }
2127   else
2128     *r_pinlen = strlen (pinvalue);
2129
2130  leave:
2131   xfree (relptr);
2132   return err;
2133 }
2134
2135
2136 /* Verify a CHV either using the pinentry or if possible by
2137    using a pinpad.  PINCB and PINCB_ARG describe the usual callback
2138    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
2139    used with CHV1.  PINVALUE is the address of a pointer which will
2140    receive a newly allocated block with the actual PIN (this is useful
2141    in case that PIN shall be used for another verify operation).  The
2142    caller needs to free this value.  If the function returns with
2143    success and NULL is stored at PINVALUE, the caller should take this
2144    as an indication that the pinpad has been used.
2145    */
2146 static gpg_error_t
2147 verify_a_chv (app_t app,
2148               gpg_error_t (*pincb)(void*, const char *, char **),
2149               void *pincb_arg, int chvno, unsigned long sigcount,
2150               char **pinvalue, int *pinlen)
2151 {
2152   int rc = 0;
2153   char *prompt_buffer = NULL;
2154   const char *prompt;
2155   pininfo_t pininfo;
2156   int minlen = 6;
2157   int remaining;
2158
2159   log_assert (chvno == 1 || chvno == 2);
2160
2161   *pinvalue = NULL;
2162   *pinlen = 0;
2163
2164   remaining = get_remaining_tries (app, 0);
2165   if (remaining == -1)
2166     return gpg_error (GPG_ERR_CARD);
2167
2168   if (chvno == 2 && app->app_local->flags.def_chv2)
2169     {
2170       /* Special case for def_chv2 mechanism. */
2171       if (opt.verbose)
2172         log_info (_("using default PIN as %s\n"), "CHV2");
2173       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
2174       if (rc)
2175         {
2176           /* Verification of CHV2 with the default PIN failed,
2177              although the card pretends to have the default PIN set as
2178              CHV2.  We better disable the def_chv2 flag now. */
2179           log_info (_("failed to use default PIN as %s: %s"
2180                       " - disabling further default use\n"),
2181                     "CHV2", gpg_strerror (rc));
2182           app->app_local->flags.def_chv2 = 0;
2183         }
2184       return rc;
2185     }
2186
2187   memset (&pininfo, 0, sizeof pininfo);
2188   pininfo.fixedlen = -1;
2189   pininfo.minlen = minlen;
2190
2191   {
2192     const char *firstline = _("||Please unlock the card");
2193     char *infoblock = get_prompt_info (app, chvno, sigcount,
2194                                        remaining < 3? remaining : -1);
2195
2196     prompt_buffer = strconcat (firstline, "%0A%0A", infoblock, NULL);
2197     if (prompt_buffer)
2198       prompt = prompt_buffer;
2199     else
2200       prompt = firstline;  /* ENOMEM fallback.  */
2201
2202     xfree (infoblock);
2203   }
2204
2205   if (!opt.disable_pinpad
2206       && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
2207       && !check_pinpad_request (app, &pininfo, 0))
2208     {
2209       /* The reader supports the verify command through the pinpad.
2210          Note that the pincb appends a text to the prompt telling the
2211          user to use the pinpad. */
2212       rc = pincb (pincb_arg, prompt, NULL);
2213       prompt = NULL;
2214       xfree (prompt_buffer);
2215       prompt_buffer = NULL;
2216       if (rc)
2217         {
2218           log_info (_("PIN callback returned error: %s\n"),
2219                     gpg_strerror (rc));
2220           return rc;
2221         }
2222       rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
2223       /* Dismiss the prompt. */
2224       pincb (pincb_arg, NULL, NULL);
2225
2226       log_assert (!*pinvalue);
2227     }
2228   else
2229     {
2230       /* The reader has no pinpad or we don't want to use it. */
2231       rc = pincb (pincb_arg, prompt, pinvalue);
2232       prompt = NULL;
2233       xfree (prompt_buffer);
2234       prompt_buffer = NULL;
2235       if (rc)
2236         {
2237           log_info (_("PIN callback returned error: %s\n"),
2238                     gpg_strerror (rc));
2239           return rc;
2240         }
2241
2242       if (strlen (*pinvalue) < minlen)
2243         {
2244           log_error (_("PIN for CHV%d is too short;"
2245                        " minimum length is %d\n"), chvno, minlen);
2246           xfree (*pinvalue);
2247           *pinvalue = NULL;
2248           return gpg_error (GPG_ERR_BAD_PIN);
2249         }
2250
2251       rc = pin2hash_if_kdf (app, chvno, *pinvalue, pinlen);
2252       if (!rc)
2253         rc = iso7816_verify (app->slot, 0x80+chvno, *pinvalue, *pinlen);
2254     }
2255
2256   if (rc)
2257     {
2258       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
2259       xfree (*pinvalue);
2260       *pinvalue = NULL;
2261       flush_cache_after_error (app);
2262     }
2263
2264   return rc;
2265 }
2266
2267
2268 /* Verify CHV2 if required.  Depending on the configuration of the
2269    card CHV1 will also be verified. */
2270 static gpg_error_t
2271 verify_chv2 (app_t app,
2272              gpg_error_t (*pincb)(void*, const char *, char **),
2273              void *pincb_arg)
2274 {
2275   int rc;
2276   char *pinvalue;
2277   int pinlen;
2278
2279   if (app->did_chv2)
2280     return 0;  /* We already verified CHV2.  */
2281
2282   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue, &pinlen);
2283   if (rc)
2284     return rc;
2285   app->did_chv2 = 1;
2286
2287   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
2288     {
2289       /* For convenience we verify CHV1 here too.  We do this only if
2290          the card is not configured to require a verification before
2291          each CHV1 controlled operation (force_chv1) and if we are not
2292          using the pinpad (PINVALUE == NULL). */
2293       rc = iso7816_verify (app->slot, 0x81, pinvalue, pinlen);
2294       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2295         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2296       if (rc)
2297         {
2298           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2299           flush_cache_after_error (app);
2300         }
2301       else
2302         app->did_chv1 = 1;
2303     }
2304
2305   xfree (pinvalue);
2306
2307   return rc;
2308 }
2309
2310
2311 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
2312    current sdtate of the card.  */
2313 static gpg_error_t
2314 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
2315 {
2316   int remaining;
2317   char *prompt;
2318   char *infoblock;
2319
2320   *r_prompt = NULL;
2321
2322   remaining = get_remaining_tries (app, 1);
2323   if (remaining == -1)
2324     return gpg_error (GPG_ERR_CARD);
2325   if (!remaining)
2326     {
2327       log_info (_("card is permanently locked!\n"));
2328       return gpg_error (GPG_ERR_BAD_PIN);
2329     }
2330
2331   log_info (ngettext("%d Admin PIN attempt remaining before card"
2332                      " is permanently locked\n",
2333                      "%d Admin PIN attempts remaining before card"
2334                      " is permanently locked\n",
2335                      remaining), remaining);
2336
2337   infoblock = get_prompt_info (app, 3, 0, remaining < 3? remaining : -1);
2338
2339   /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
2340      the start of the string.  Use %0A (single percent) for a linefeed.  */
2341   prompt = strconcat (_("|A|Please enter the Admin PIN"),
2342                       "%0A%0A", infoblock, NULL);
2343   xfree (infoblock);
2344   if (!prompt)
2345     return gpg_error_from_syserror ();
2346
2347   *r_prompt = prompt;
2348   return 0;
2349 }
2350
2351
2352 /* Verify CHV3 if required. */
2353 static gpg_error_t
2354 verify_chv3 (app_t app,
2355              gpg_error_t (*pincb)(void*, const char *, char **),
2356              void *pincb_arg)
2357 {
2358   int rc = 0;
2359
2360 #if GNUPG_MAJOR_VERSION != 1
2361   if (!opt.allow_admin)
2362     {
2363       log_info (_("access to admin commands is not configured\n"));
2364       return gpg_error (GPG_ERR_EACCES);
2365     }
2366 #endif
2367
2368   if (!app->did_chv3)
2369     {
2370       pininfo_t pininfo;
2371       int minlen = 8;
2372       char *prompt;
2373
2374       memset (&pininfo, 0, sizeof pininfo);
2375       pininfo.fixedlen = -1;
2376       pininfo.minlen = minlen;
2377
2378       rc = build_enter_admin_pin_prompt (app, &prompt);
2379       if (rc)
2380         return rc;
2381
2382       if (!opt.disable_pinpad
2383           && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
2384           && !check_pinpad_request (app, &pininfo, 1))
2385         {
2386           /* The reader supports the verify command through the pinpad. */
2387           rc = pincb (pincb_arg, prompt, NULL);
2388           xfree (prompt);
2389           prompt = NULL;
2390           if (rc)
2391             {
2392               log_info (_("PIN callback returned error: %s\n"),
2393                         gpg_strerror (rc));
2394               return rc;
2395             }
2396           rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
2397           /* Dismiss the prompt. */
2398           pincb (pincb_arg, NULL, NULL);
2399         }
2400       else
2401         {
2402           char *pinvalue;
2403           int pinlen;
2404
2405           rc = pincb (pincb_arg, prompt, &pinvalue);
2406           xfree (prompt);
2407           prompt = NULL;
2408           if (rc)
2409             {
2410               log_info (_("PIN callback returned error: %s\n"),
2411                         gpg_strerror (rc));
2412               return rc;
2413             }
2414
2415           if (strlen (pinvalue) < minlen)
2416             {
2417               log_error (_("PIN for CHV%d is too short;"
2418                            " minimum length is %d\n"), 3, minlen);
2419               xfree (pinvalue);
2420               return gpg_error (GPG_ERR_BAD_PIN);
2421             }
2422
2423           rc = pin2hash_if_kdf (app, 3, pinvalue, &pinlen);
2424           if (!rc)
2425             rc = iso7816_verify (app->slot, 0x83, pinvalue, pinlen);
2426           xfree (pinvalue);
2427         }
2428
2429       if (rc)
2430         {
2431           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
2432           flush_cache_after_error (app);
2433           return rc;
2434         }
2435       app->did_chv3 = 1;
2436     }
2437   return rc;
2438 }
2439
2440
2441 /* Handle the SETATTR operation. All arguments are already basically
2442    checked. */
2443 static gpg_error_t
2444 do_setattr (app_t app, const char *name,
2445             gpg_error_t (*pincb)(void*, const char *, char **),
2446             void *pincb_arg,
2447             const unsigned char *value, size_t valuelen)
2448 {
2449   gpg_error_t rc;
2450   int idx;
2451   static struct {
2452     const char *name;
2453     int tag;
2454     int need_chv;
2455     int special;
2456     unsigned int need_v2:1;
2457   } table[] = {
2458     { "DISP-NAME",    0x005B, 3 },
2459     { "LOGIN-DATA",   0x005E, 3, 2 },
2460     { "DISP-LANG",    0x5F2D, 3 },
2461     { "DISP-SEX",     0x5F35, 3 },
2462     { "PUBKEY-URL",   0x5F50, 3 },
2463     { "CHV-STATUS-1", 0x00C4, 3, 1 },
2464     { "CA-FPR-1",     0x00CA, 3 },
2465     { "CA-FPR-2",     0x00CB, 3 },
2466     { "CA-FPR-3",     0x00CC, 3 },
2467     { "PRIVATE-DO-1", 0x0101, 2 },
2468     { "PRIVATE-DO-2", 0x0102, 3 },
2469     { "PRIVATE-DO-3", 0x0103, 2 },
2470     { "PRIVATE-DO-4", 0x0104, 3 },
2471     { "CERT-3",       0x7F21, 3, 0, 1 },
2472     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
2473     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
2474     { "KEY-ATTR",     0,      0, 3, 1 },
2475     { "AESKEY",       0x00D5, 3, 0, 1 },
2476     { "UIF-1",        0x00D6, 3, 5, 1 },
2477     { "UIF-2",        0x00D7, 3, 5, 1 },
2478     { "UIF-3",        0x00D8, 3, 5, 1 },
2479     { "KDF",          0x00F9, 3, 4, 1 },
2480     { NULL, 0 }
2481   };
2482   int exmode;
2483
2484   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
2485     ;
2486   if (!table[idx].name)
2487     return gpg_error (GPG_ERR_INV_NAME);
2488   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
2489     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
2490
2491   if (table[idx].special == 5 && app->app_local->extcap.has_button == 0)
2492     return gpg_error (GPG_ERR_INV_OBJ);
2493
2494   if (table[idx].special == 3)
2495     return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
2496
2497   switch (table[idx].need_chv)
2498     {
2499     case 2:
2500       rc = verify_chv2 (app, pincb, pincb_arg);
2501       break;
2502     case 3:
2503       rc = verify_chv3 (app, pincb, pincb_arg);
2504       break;
2505     default:
2506       rc = 0;
2507     }
2508   if (rc)
2509     return rc;
2510
2511   /* Flush the cache before writing it, so that the next get operation
2512      will reread the data from the card and thus get synced in case of
2513      errors (e.g. data truncated by the card). */
2514   flush_cache_item (app, table[idx].tag);
2515
2516   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
2517     exmode = 1;    /* Use extended length w/o a limit.  */
2518   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
2519     exmode = -254; /* Command chaining with max. 254 bytes.  */
2520   else
2521     exmode = 0;
2522   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
2523   if (rc)
2524     log_error ("failed to set '%s': %s\n", table[idx].name, gpg_strerror (rc));
2525
2526   if (table[idx].special == 1)
2527     app->force_chv1 = (valuelen && *value == 0);
2528   else if (table[idx].special == 2)
2529     parse_login_data (app);
2530   else if (table[idx].special == 4)
2531     {
2532       app->did_chv1 = 0;
2533       app->did_chv2 = 0;
2534       app->did_chv3 = 0;
2535     }
2536
2537   return rc;
2538 }
2539
2540
2541 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
2542    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
2543    PINCB and PINCB_ARG are the usual arguments for the pinentry
2544    callback.  */
2545 static gpg_error_t
2546 do_writecert (app_t app, ctrl_t ctrl,
2547               const char *certidstr,
2548               gpg_error_t (*pincb)(void*, const char *, char **),
2549               void *pincb_arg,
2550               const unsigned char *certdata, size_t certdatalen)
2551 {
2552   (void)ctrl;
2553 #if GNUPG_MAJOR_VERSION > 1
2554   if (strcmp (certidstr, "OPENPGP.3"))
2555     return gpg_error (GPG_ERR_INV_ID);
2556   if (!certdata || !certdatalen)
2557     return gpg_error (GPG_ERR_INV_ARG);
2558   if (!app->app_local->extcap.is_v2)
2559     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2560   if (certdatalen > app->app_local->extcap.max_certlen_3)
2561     return gpg_error (GPG_ERR_TOO_LARGE);
2562   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
2563 #else
2564   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2565 #endif
2566 }
2567
2568
2569
2570 /* Handle the PASSWD command.  The following combinations are
2571    possible:
2572
2573     Flags  CHVNO Vers.  Description
2574     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
2575     RESET    1   2      Verify PW3 and set a new PW1.
2576     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
2577     RESET    2   2      Verify PW3 and set a new Reset Code.
2578     RESET    3   any    Returns GPG_ERR_INV_ID.
2579      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
2580      -       1   2      Verify PW1 and set a new PW1.
2581      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
2582      -       2   2      Verify Reset Code and set a new PW1.
2583      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
2584  */
2585 static gpg_error_t
2586 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
2587                unsigned int flags,
2588                gpg_error_t (*pincb)(void*, const char *, char **),
2589                void *pincb_arg)
2590 {
2591   int rc = 0;
2592   int chvno = atoi (chvnostr);
2593   char *resetcode = NULL;
2594   char *oldpinvalue = NULL;
2595   char *pinvalue = NULL;
2596   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2597   int set_resetcode = 0;
2598   pininfo_t pininfo;
2599   int use_pinpad = 0;
2600   int minlen = 6;
2601   int pinlen0 = 0;
2602   int pinlen = 0;
2603
2604   (void)ctrl;
2605   memset (&pininfo, 0, sizeof pininfo);
2606   pininfo.fixedlen = -1;
2607   pininfo.minlen = minlen;
2608
2609   if (reset_mode && chvno == 3)
2610     {
2611       rc = gpg_error (GPG_ERR_INV_ID);
2612       goto leave;
2613     }
2614
2615   if (!app->app_local->extcap.is_v2)
2616     {
2617       /* Version 1 cards.  */
2618
2619       if (reset_mode || chvno == 3)
2620         {
2621           /* We always require that the PIN is entered. */
2622           app->did_chv3 = 0;
2623           rc = verify_chv3 (app, pincb, pincb_arg);
2624           if (rc)
2625             goto leave;
2626         }
2627       else if (chvno == 1 || chvno == 2)
2628         {
2629           /* On a v1.x card CHV1 and CVH2 should always have the same
2630              value, thus we enforce it here.  */
2631           int save_force = app->force_chv1;
2632
2633           app->force_chv1 = 0;
2634           app->did_chv1 = 0;
2635           app->did_chv2 = 0;
2636           rc = verify_chv2 (app, pincb, pincb_arg);
2637           app->force_chv1 = save_force;
2638           if (rc)
2639             goto leave;
2640         }
2641       else
2642         {
2643           rc = gpg_error (GPG_ERR_INV_ID);
2644           goto leave;
2645         }
2646     }
2647   else
2648     {
2649       /* Version 2 cards.  */
2650
2651       if (!opt.disable_pinpad
2652           && !iso7816_check_pinpad (app->slot,
2653                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2654           && !check_pinpad_request (app, &pininfo, chvno == 3))
2655         use_pinpad = 1;
2656
2657       if (reset_mode)
2658         {
2659           /* To reset a PIN the Admin PIN is required. */
2660           use_pinpad = 0;
2661           app->did_chv3 = 0;
2662           rc = verify_chv3 (app, pincb, pincb_arg);
2663           if (rc)
2664             goto leave;
2665
2666           if (chvno == 2)
2667             set_resetcode = 1;
2668         }
2669       else if (chvno == 1 || chvno == 3)
2670         {
2671           if (!use_pinpad)
2672             {
2673               char *promptbuf = NULL;
2674               const char *prompt;
2675
2676               if (chvno == 3)
2677                 {
2678                   minlen = 8;
2679                   rc = build_enter_admin_pin_prompt (app, &promptbuf);
2680                   if (rc)
2681                     goto leave;
2682                   prompt = promptbuf;
2683                 }
2684               else
2685                 prompt = _("||Please enter the PIN");
2686               rc = pincb (pincb_arg, prompt, &oldpinvalue);
2687               xfree (promptbuf);
2688               promptbuf = NULL;
2689               if (rc)
2690                 {
2691                   log_info (_("PIN callback returned error: %s\n"),
2692                             gpg_strerror (rc));
2693                   goto leave;
2694                 }
2695
2696               if (strlen (oldpinvalue) < minlen)
2697                 {
2698                   log_info (_("PIN for CHV%d is too short;"
2699                               " minimum length is %d\n"), chvno, minlen);
2700                   rc = gpg_error (GPG_ERR_BAD_PIN);
2701                   goto leave;
2702                 }
2703             }
2704         }
2705       else if (chvno == 2)
2706         {
2707           /* There is no PW2 for v2 cards.  We use this condition to
2708              allow a PW reset using the Reset Code.  */
2709           void *relptr;
2710           unsigned char *value;
2711           size_t valuelen;
2712           int remaining;
2713
2714           use_pinpad = 0;
2715           minlen = 8;
2716           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2717           if (!relptr || valuelen < 7)
2718             {
2719               log_error (_("error retrieving CHV status from card\n"));
2720               xfree (relptr);
2721               rc = gpg_error (GPG_ERR_CARD);
2722               goto leave;
2723             }
2724           remaining = value[5];
2725           xfree (relptr);
2726           if (!remaining)
2727             {
2728               log_error (_("Reset Code not or not anymore available\n"));
2729               rc = gpg_error (GPG_ERR_BAD_PIN);
2730               goto leave;
2731             }
2732
2733           rc = pincb (pincb_arg,
2734                       _("||Please enter the Reset Code for the card"),
2735                       &resetcode);
2736           if (rc)
2737             {
2738               log_info (_("PIN callback returned error: %s\n"),
2739                         gpg_strerror (rc));
2740               goto leave;
2741             }
2742           if (strlen (resetcode) < minlen)
2743             {
2744               log_info (_("Reset Code is too short; minimum length is %d\n"),
2745                         minlen);
2746               rc = gpg_error (GPG_ERR_BAD_PIN);
2747               goto leave;
2748             }
2749         }
2750       else
2751         {
2752           rc = gpg_error (GPG_ERR_INV_ID);
2753           goto leave;
2754         }
2755     }
2756
2757   if (chvno == 3)
2758     app->did_chv3 = 0;
2759   else
2760     app->did_chv1 = app->did_chv2 = 0;
2761
2762   if (!use_pinpad)
2763     {
2764       /* TRANSLATORS: Do not translate the "|*|" prefixes but
2765          keep it at the start of the string.  We need this elsewhere
2766          to get some infos on the string. */
2767       rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2768                   chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2769                   &pinvalue);
2770       if (rc || pinvalue == NULL)
2771         {
2772           log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2773           goto leave;
2774         }
2775     }
2776
2777
2778   if (resetcode)
2779     {
2780       char *buffer;
2781
2782       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2783       if (!buffer)
2784         rc = gpg_error_from_syserror ();
2785       else
2786         {
2787           strcpy (buffer, resetcode);
2788           rc = pin2hash_if_kdf (app, 0, buffer, &pinlen0);
2789           if (!rc)
2790             {
2791               strcpy (buffer+pinlen0, pinvalue);
2792               rc = pin2hash_if_kdf (app, 0, buffer+pinlen0, &pinlen);
2793             }
2794           if (!rc)
2795             rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2796                                                       buffer, pinlen0+pinlen);
2797           wipememory (buffer, pinlen0 + pinlen);
2798           xfree (buffer);
2799         }
2800     }
2801   else if (set_resetcode)
2802     {
2803       if (strlen (pinvalue) < 8)
2804         {
2805           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2806           rc = gpg_error (GPG_ERR_BAD_PIN);
2807         }
2808       else
2809         {
2810           rc = pin2hash_if_kdf (app, 0, pinvalue, &pinlen);
2811           if (!rc)
2812             rc = iso7816_put_data (app->slot, 0, 0xD3, pinvalue, pinlen);
2813         }
2814     }
2815   else if (reset_mode)
2816     {
2817       rc = pin2hash_if_kdf (app, 1, pinvalue, &pinlen);
2818       if (!rc)
2819         rc = iso7816_reset_retry_counter (app->slot, 0x81, pinvalue, pinlen);
2820       if (!rc && !app->app_local->extcap.is_v2)
2821         rc = iso7816_reset_retry_counter (app->slot, 0x82, pinvalue, pinlen);
2822     }
2823   else if (!app->app_local->extcap.is_v2)
2824     {
2825       /* Version 1 cards.  */
2826       if (chvno == 1 || chvno == 2)
2827         {
2828           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2829                                               pinvalue, strlen (pinvalue));
2830           if (!rc)
2831             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2832                                                 pinvalue, strlen (pinvalue));
2833         }
2834       else /* CHVNO == 3 */
2835         {
2836           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2837                                               pinvalue, strlen (pinvalue));
2838         }
2839     }
2840   else
2841     {
2842       /* Version 2 cards.  */
2843       assert (chvno == 1 || chvno == 3);
2844
2845       if (use_pinpad)
2846         {
2847           rc = pincb (pincb_arg,
2848                       chvno == 3 ?
2849                       _("||Please enter the Admin PIN and New Admin PIN") :
2850                       _("||Please enter the PIN and New PIN"), NULL);
2851           if (rc)
2852             {
2853               log_info (_("PIN callback returned error: %s\n"),
2854                         gpg_strerror (rc));
2855               goto leave;
2856             }
2857           rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
2858                                                  &pininfo);
2859           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2860         }
2861       else
2862         {
2863           rc = pin2hash_if_kdf (app, chvno, oldpinvalue, &pinlen0);
2864           if (!rc)
2865             rc = pin2hash_if_kdf (app, chvno, pinvalue, &pinlen);
2866           if (!rc)
2867             rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2868                                                 oldpinvalue, pinlen0,
2869                                                 pinvalue, pinlen);
2870         }
2871     }
2872
2873   if (pinvalue)
2874     {
2875       wipememory (pinvalue, pinlen);
2876       xfree (pinvalue);
2877     }
2878   if (rc)
2879     flush_cache_after_error (app);
2880
2881  leave:
2882   if (resetcode)
2883     {
2884       wipememory (resetcode, strlen (resetcode));
2885       xfree (resetcode);
2886     }
2887   if (oldpinvalue)
2888     {
2889       wipememory (oldpinvalue, pinlen0);
2890       xfree (oldpinvalue);
2891     }
2892   return rc;
2893 }
2894
2895
2896 /* Check whether a key already exists.  KEYIDX is the index of the key
2897    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2898    error returned if the key already exists.  The flag GENERATING is
2899    only used to print correct messages. */
2900 static gpg_error_t
2901 does_key_exist (app_t app, int keyidx, int generating, int force)
2902 {
2903   const unsigned char *fpr;
2904   unsigned char *buffer;
2905   size_t buflen, n;
2906   int i;
2907
2908   assert (keyidx >=0 && keyidx <= 2);
2909
2910   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2911     {
2912       log_error (_("error reading application data\n"));
2913       return gpg_error (GPG_ERR_GENERAL);
2914     }
2915   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2916   if (!fpr || n < 60)
2917     {
2918       log_error (_("error reading fingerprint DO\n"));
2919       xfree (buffer);
2920       return gpg_error (GPG_ERR_GENERAL);
2921     }
2922   fpr += 20*keyidx;
2923   for (i=0; i < 20 && !fpr[i]; i++)
2924     ;
2925   xfree (buffer);
2926   if (i!=20 && !force)
2927     {
2928       log_error (_("key already exists\n"));
2929       return gpg_error (GPG_ERR_EEXIST);
2930     }
2931   else if (i!=20)
2932     log_info (_("existing key will be replaced\n"));
2933   else if (generating)
2934     log_info (_("generating new key\n"));
2935   else
2936     log_info (_("writing new key\n"));
2937   return 0;
2938 }
2939
2940
2941 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2942    of tag and length.  A LENGTH greater than 65535 is truncated. */
2943 static size_t
2944 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2945 {
2946   unsigned char *p = buffer;
2947
2948   assert (tag <= 0xffff);
2949   if ( tag > 0xff )
2950     *p++ = tag >> 8;
2951   *p++ = tag;
2952   if (length < 128)
2953     *p++ = length;
2954   else if (length < 256)
2955     {
2956       *p++ = 0x81;
2957       *p++ = length;
2958     }
2959   else
2960     {
2961       if (length > 0xffff)
2962         length = 0xffff;
2963       *p++ = 0x82;
2964       *p++ = length >> 8;
2965       *p++ = length;
2966     }
2967
2968   return p - buffer;
2969 }
2970
2971
2972 static gpg_error_t
2973 build_privkey_template (app_t app, int keyno,
2974                         const unsigned char *rsa_n, size_t rsa_n_len,
2975                         const unsigned char *rsa_e, size_t rsa_e_len,
2976                         const unsigned char *rsa_p, size_t rsa_p_len,
2977                         const unsigned char *rsa_q, size_t rsa_q_len,
2978                         const unsigned char *rsa_u, size_t rsa_u_len,
2979                         const unsigned char *rsa_dp, size_t rsa_dp_len,
2980                         const unsigned char *rsa_dq, size_t rsa_dq_len,
2981                         unsigned char **result, size_t *resultlen)
2982 {
2983   size_t rsa_e_reqlen;
2984   unsigned char privkey[7*(1+3+3)];
2985   size_t privkey_len;
2986   unsigned char exthdr[2+2+3];
2987   size_t exthdr_len;
2988   unsigned char suffix[2+3];
2989   size_t suffix_len;
2990   unsigned char *tp;
2991   size_t datalen;
2992   unsigned char *template;
2993   size_t template_size;
2994
2995   *result = NULL;
2996   *resultlen = 0;
2997
2998   switch (app->app_local->keyattr[keyno].rsa.format)
2999     {
3000     case RSA_STD:
3001     case RSA_STD_N:
3002     case RSA_CRT:
3003     case RSA_CRT_N:
3004       break;
3005
3006     default:
3007       return gpg_error (GPG_ERR_INV_VALUE);
3008     }
3009
3010   /* Get the required length for E. Rounded up to the nearest byte  */
3011   rsa_e_reqlen = (app->app_local->keyattr[keyno].rsa.e_bits + 7) / 8;
3012   assert (rsa_e_len <= rsa_e_reqlen);
3013
3014   /* Build the 7f48 cardholder private key template.  */
3015   datalen = 0;
3016   tp = privkey;
3017
3018   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
3019   datalen += rsa_e_reqlen;
3020
3021   tp += add_tlv (tp, 0x92, rsa_p_len);
3022   datalen += rsa_p_len;
3023
3024   tp += add_tlv (tp, 0x93, rsa_q_len);
3025   datalen += rsa_q_len;
3026
3027   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
3028       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3029     {
3030       tp += add_tlv (tp, 0x94, rsa_u_len);
3031       datalen += rsa_u_len;
3032       tp += add_tlv (tp, 0x95, rsa_dp_len);
3033       datalen += rsa_dp_len;
3034       tp += add_tlv (tp, 0x96, rsa_dq_len);
3035       datalen += rsa_dq_len;
3036     }
3037
3038   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
3039       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3040     {
3041       tp += add_tlv (tp, 0x97, rsa_n_len);
3042       datalen += rsa_n_len;
3043     }
3044   privkey_len = tp - privkey;
3045
3046   /* Build the extended header list without the private key template.  */
3047   tp = exthdr;
3048   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
3049   *tp++ = 0;
3050   tp += add_tlv (tp, 0x7f48, privkey_len);
3051   exthdr_len = tp - exthdr;
3052
3053   /* Build the 5f48 suffix of the data.  */
3054   tp = suffix;
3055   tp += add_tlv (tp, 0x5f48, datalen);
3056   suffix_len = tp - suffix;
3057
3058   /* Now concatenate everything.  */
3059   template_size = (1 + 3   /* 0x4d and len. */
3060                    + exthdr_len
3061                    + privkey_len
3062                    + suffix_len
3063                    + datalen);
3064   tp = template = xtrymalloc_secure (template_size);
3065   if (!template)
3066     return gpg_error_from_syserror ();
3067
3068   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
3069   memcpy (tp, exthdr, exthdr_len);
3070   tp += exthdr_len;
3071   memcpy (tp, privkey, privkey_len);
3072   tp += privkey_len;
3073   memcpy (tp, suffix, suffix_len);
3074   tp += suffix_len;
3075
3076   memcpy (tp, rsa_e, rsa_e_len);
3077   if (rsa_e_len < rsa_e_reqlen)
3078     {
3079       /* Right justify E. */
3080       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
3081       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
3082     }
3083   tp += rsa_e_reqlen;
3084
3085   memcpy (tp, rsa_p, rsa_p_len);
3086   tp += rsa_p_len;
3087
3088   memcpy (tp, rsa_q, rsa_q_len);
3089   tp += rsa_q_len;
3090
3091   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
3092       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3093     {
3094       memcpy (tp, rsa_u, rsa_u_len);
3095       tp += rsa_u_len;
3096       memcpy (tp, rsa_dp, rsa_dp_len);
3097       tp += rsa_dp_len;
3098       memcpy (tp, rsa_dq, rsa_dq_len);
3099       tp += rsa_dq_len;
3100     }
3101
3102   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
3103       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3104     {
3105       memcpy (tp, rsa_n, rsa_n_len);
3106       tp += rsa_n_len;
3107     }
3108
3109   /* Sanity check.  We don't know the exact length because we
3110      allocated 3 bytes for the first length header.  */
3111   assert (tp - template <= template_size);
3112
3113   *result = template;
3114   *resultlen = tp - template;
3115   return 0;
3116 }
3117
3118 static gpg_error_t
3119 build_ecc_privkey_template (app_t app, int keyno,
3120                             const unsigned char *ecc_d, size_t ecc_d_len,
3121                             const unsigned char *ecc_q, size_t ecc_q_len,
3122                             unsigned char **result, size_t *resultlen)
3123 {
3124   unsigned char privkey[2+2];
3125   size_t privkey_len;
3126   unsigned char exthdr[2+2+1];
3127   size_t exthdr_len;
3128   unsigned char suffix[2+1];
3129   size_t suffix_len;
3130   unsigned char *tp;
3131   size_t datalen;
3132   unsigned char *template;
3133   size_t template_size;
3134   int pubkey_required;
3135
3136   pubkey_required = !!(app->app_local->keyattr[keyno].ecc.flags
3137                        & ECC_FLAG_PUBKEY);
3138
3139   *result = NULL;
3140   *resultlen = 0;
3141
3142   /* Build the 7f48 cardholder private key template.  */
3143   datalen = 0;
3144   tp = privkey;
3145
3146   tp += add_tlv (tp, 0x92, ecc_d_len);
3147   datalen += ecc_d_len;
3148
3149   if (pubkey_required)
3150     {
3151       tp += add_tlv (tp, 0x99, ecc_q_len);
3152       datalen += ecc_q_len;
3153     }
3154
3155   privkey_len = tp - privkey;
3156
3157
3158   /* Build the extended header list without the private key template.  */
3159   tp = exthdr;
3160   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
3161   *tp++ = 0;
3162   tp += add_tlv (tp, 0x7f48, privkey_len);
3163   exthdr_len = tp - exthdr;
3164
3165   /* Build the 5f48 suffix of the data.  */
3166   tp = suffix;
3167   tp += add_tlv (tp, 0x5f48, datalen);
3168   suffix_len = tp - suffix;
3169
3170   /* Now concatenate everything.  */
3171   template_size = (1 + 1   /* 0x4d and len. */
3172                    + exthdr_len
3173                    + privkey_len
3174                    + suffix_len
3175                    + datalen);
3176   if (exthdr_len + privkey_len + suffix_len + datalen >= 128)
3177     template_size++;
3178   tp = template = xtrymalloc_secure (template_size);
3179   if (!template)
3180     return gpg_error_from_syserror ();
3181
3182   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
3183   memcpy (tp, exthdr, exthdr_len);
3184   tp += exthdr_len;
3185   memcpy (tp, privkey, privkey_len);
3186   tp += privkey_len;
3187   memcpy (tp, suffix, suffix_len);
3188   tp += suffix_len;
3189
3190   memcpy (tp, ecc_d, ecc_d_len);
3191   tp += ecc_d_len;
3192
3193   if (pubkey_required)
3194     {
3195       memcpy (tp, ecc_q, ecc_q_len);
3196       tp += ecc_q_len;
3197     }
3198
3199   assert (tp - template == template_size);
3200
3201   *result = template;
3202   *resultlen = tp - template;
3203   return 0;
3204 }
3205
3206
3207 /* Helper for do_writekley to change the size of a key.  Not ethat
3208    this deletes the entire key without asking.  */
3209 static gpg_error_t
3210 change_keyattr (app_t app, int keyno, const unsigned char *buf, size_t buflen,
3211                 gpg_error_t (*pincb)(void*, const char *, char **),
3212                 void *pincb_arg)
3213 {
3214   gpg_error_t err;
3215
3216   assert (keyno >=0 && keyno <= 2);
3217
3218   /* Prepare for storing the key.  */
3219   err = verify_chv3 (app, pincb, pincb_arg);
3220   if (err)
3221     return err;
3222
3223   /* Change the attribute.  */
3224   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buf, buflen);
3225   if (err)
3226     log_error ("error changing key attribute (key=%d)\n", keyno+1);
3227   else
3228     log_info ("key attribute changed (key=%d)\n", keyno+1);
3229   flush_cache (app);
3230   parse_algorithm_attribute (app, keyno);
3231   app->did_chv1 = 0;
3232   app->did_chv2 = 0;
3233   app->did_chv3 = 0;
3234   return err;
3235 }
3236
3237
3238 static gpg_error_t
3239 change_rsa_keyattr (app_t app, int keyno, unsigned int nbits,
3240                     gpg_error_t (*pincb)(void*, const char *, char **),
3241                     void *pincb_arg)
3242 {
3243   gpg_error_t err = 0;
3244   unsigned char *buf;
3245   size_t buflen;
3246   void *relptr;
3247
3248   /* Read the current attributes into a buffer.  */
3249   relptr = get_one_do (app, 0xC1+keyno, &buf, &buflen, NULL);
3250   if (!relptr)
3251     err = gpg_error (GPG_ERR_CARD);
3252   else if (buflen < 6)
3253     {
3254       /* Attributes too short.  */
3255       xfree (relptr);
3256       err = gpg_error (GPG_ERR_CARD);
3257     }
3258   else
3259     {
3260       /* If key attribute was RSA, we only change n_bits and don't
3261          touch anything else.  Before we do so, we round up NBITS to a
3262          sensible way in the same way as gpg's key generation does it.
3263          This may help to sort out problems with a few bits too short
3264          keys.  */
3265       nbits = ((nbits + 31) / 32) * 32;
3266       buf[1] = (nbits >> 8);
3267       buf[2] = nbits;
3268
3269       /* If it was not RSA, we need to fill other parts.  */
3270       if (buf[0] != PUBKEY_ALGO_RSA)
3271         {
3272           buf[0] = PUBKEY_ALGO_RSA;
3273           buf[3] = 0;
3274           buf[4] = 32;
3275           buf[5] = 0;
3276           buflen = 6;
3277         }
3278
3279       err = change_keyattr (app, keyno, buf, buflen, pincb, pincb_arg);
3280       xfree (relptr);
3281     }
3282
3283   return err;
3284 }
3285
3286
3287 /* Helper to process an setattr command for name KEY-ATTR.
3288    In (VALUE,VALUELEN), it expects following string:
3289         RSA: "--force <key> <algo> rsa<nbits>"
3290         ECC: "--force <key> <algo> <curvename>"
3291   */
3292 static gpg_error_t
3293 change_keyattr_from_string (app_t app,
3294                             gpg_error_t (*pincb)(void*, const char *, char **),
3295                             void *pincb_arg,
3296                             const void *value, size_t valuelen)
3297 {
3298   gpg_error_t err = 0;
3299   char *string;
3300   int key, keyno, algo;
3301   int n = 0;
3302
3303   /* VALUE is expected to be a string but not guaranteed to be
3304      terminated.  Thus copy it to an allocated buffer first. */
3305   string = xtrymalloc (valuelen+1);
3306   if (!string)
3307     return gpg_error_from_syserror ();
3308   memcpy (string, value, valuelen);
3309   string[valuelen] = 0;
3310
3311   /* Because this function deletes the key we require the string
3312      "--force" in the data to make clear that something serious might
3313      happen.  */
3314   sscanf (string, "--force %d %d %n", &key, &algo, &n);
3315   if (n < 12)
3316     {
3317       err = gpg_error (GPG_ERR_INV_DATA);
3318       goto leave;
3319     }
3320
3321   keyno = key - 1;
3322   if (keyno < 0 || keyno > 2)
3323     err = gpg_error (GPG_ERR_INV_ID);
3324   else if (algo == PUBKEY_ALGO_RSA)
3325     {
3326       unsigned int nbits;
3327
3328       errno = 0;
3329       nbits = strtoul (string+n+3, NULL, 10);
3330       if (errno)
3331         err = gpg_error (GPG_ERR_INV_DATA);
3332       else if (nbits < 1024)
3333         err = gpg_error (GPG_ERR_TOO_SHORT);
3334       else if (nbits > 4096)
3335         err = gpg_error (GPG_ERR_TOO_LARGE);
3336       else
3337         err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3338     }
3339   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
3340            || algo == PUBKEY_ALGO_EDDSA)
3341     {
3342       const char *oidstr;
3343       gcry_mpi_t oid;
3344       const unsigned char *oidbuf;
3345       size_t oid_len;
3346
3347       oidstr = openpgp_curve_to_oid (string+n, NULL);
3348       if (!oidstr)
3349         {
3350           err = gpg_error (GPG_ERR_INV_DATA);
3351           goto leave;
3352         }
3353
3354       err = openpgp_oid_from_str (oidstr, &oid);
3355       if (err)
3356         goto leave;
3357
3358       oidbuf = gcry_mpi_get_opaque (oid, &n);
3359       oid_len = (n+7)/8;
3360
3361       /* We have enough room at STRING.  */
3362       string[0] = algo;
3363       memcpy (string+1, oidbuf+1, oid_len-1);
3364       err = change_keyattr (app, keyno, string, oid_len, pincb, pincb_arg);
3365       gcry_mpi_release (oid);
3366     }
3367   else
3368     err = gpg_error (GPG_ERR_PUBKEY_ALGO);
3369
3370  leave:
3371   xfree (string);
3372   return err;
3373 }
3374
3375
3376 static gpg_error_t
3377 rsa_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3378               void *pincb_arg, int keyno,
3379               const unsigned char *buf, size_t buflen, int depth)
3380 {
3381   gpg_error_t err;
3382   const unsigned char *tok;
3383   size_t toklen;
3384   int last_depth1, last_depth2;
3385   const unsigned char *rsa_n = NULL;
3386   const unsigned char *rsa_e = NULL;
3387   const unsigned char *rsa_p = NULL;
3388   const unsigned char *rsa_q = NULL;
3389   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3390   unsigned int nbits;
3391   unsigned int maxbits;
3392   unsigned char *template = NULL;
3393   unsigned char *tp;
3394   size_t template_len;
3395   unsigned char fprbuf[20];
3396   u32 created_at = 0;
3397
3398   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
3399     {
3400       log_error (_("unsupported algorithm: %s"), "RSA");
3401       err = gpg_error (GPG_ERR_INV_VALUE);
3402       goto leave;
3403     }
3404
3405   last_depth1 = depth;
3406   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3407          && depth && depth >= last_depth1)
3408     {
3409       if (tok)
3410         {
3411           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3412           goto leave;
3413         }
3414       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3415         goto leave;
3416       if (tok && toklen == 1)
3417         {
3418           const unsigned char **mpi;
3419           size_t *mpi_len;
3420
3421           switch (*tok)
3422             {
3423             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
3424             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
3425             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
3426             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
3427             default: mpi = NULL;  mpi_len = NULL; break;
3428             }
3429           if (mpi && *mpi)
3430             {
3431               err = gpg_error (GPG_ERR_DUP_VALUE);
3432               goto leave;
3433             }
3434           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3435             goto leave;
3436           if (tok && mpi)
3437             {
3438               /* Strip off leading zero bytes and save. */
3439               for (;toklen && !*tok; toklen--, tok++)
3440                 ;
3441               *mpi = tok;
3442               *mpi_len = toklen;
3443             }
3444         }
3445       /* Skip until end of list. */
3446       last_depth2 = depth;
3447       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3448              && depth && depth >= last_depth2)
3449         ;
3450       if (err)
3451         goto leave;
3452     }
3453   /* Parse other attributes. */
3454   last_depth1 = depth;
3455   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3456          && depth && depth >= last_depth1)
3457     {
3458       if (tok)
3459         {
3460           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3461           goto leave;
3462         }
3463       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3464         goto leave;
3465       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3466         {
3467           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3468             goto leave;
3469           if (tok)
3470             {
3471               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3472                    tok++, toklen--)
3473                 created_at = created_at*10 + (*tok - '0');
3474             }
3475         }
3476       /* Skip until end of list. */
3477       last_depth2 = depth;
3478       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3479              && depth && depth >= last_depth2)
3480         ;
3481       if (err)
3482         goto leave;
3483     }
3484
3485
3486   /* Check that we have all parameters and that they match the card
3487      description. */
3488   if (!created_at)
3489     {
3490       log_error (_("creation timestamp missing\n"));
3491       err = gpg_error (GPG_ERR_INV_VALUE);
3492       goto leave;
3493     }
3494
3495   maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3496   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
3497   if (opt.verbose)
3498     log_info ("RSA modulus size is %u bits\n", nbits);
3499   if (nbits && nbits != maxbits
3500       && app->app_local->extcap.algo_attr_change)
3501     {
3502       /* Try to switch the key to a new length.  */
3503       err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3504       if (!err)
3505         maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3506     }
3507   if (nbits != maxbits)
3508     {
3509       log_error (_("RSA modulus missing or not of size %d bits\n"),
3510                  (int)maxbits);
3511       err = gpg_error (GPG_ERR_BAD_SECKEY);
3512       goto leave;
3513     }
3514
3515   maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
3516   if (maxbits > 32 && !app->app_local->extcap.is_v2)
3517     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
3518   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
3519   if (nbits < 2 || nbits > maxbits)
3520     {
3521       log_error (_("RSA public exponent missing or larger than %d bits\n"),
3522                  (int)maxbits);
3523       err = gpg_error (GPG_ERR_BAD_SECKEY);
3524       goto leave;
3525     }
3526
3527   maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
3528   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
3529   if (nbits != maxbits)
3530     {
3531       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3532                  "P", (int)maxbits);
3533       err = gpg_error (GPG_ERR_BAD_SECKEY);
3534       goto leave;
3535     }
3536   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
3537   if (nbits != maxbits)
3538     {
3539       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3540                  "Q", (int)maxbits);
3541       err = gpg_error (GPG_ERR_BAD_SECKEY);
3542       goto leave;
3543     }
3544
3545   /* We need to remove the cached public key.  */
3546   xfree (app->app_local->pk[keyno].key);
3547   app->app_local->pk[keyno].key = NULL;
3548   app->app_local->pk[keyno].keylen = 0;
3549   app->app_local->pk[keyno].read_done = 0;
3550
3551
3552   if (app->app_local->extcap.is_v2)
3553     {
3554       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
3555       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
3556       gcry_mpi_t mpi_e, mpi_p, mpi_q;
3557       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
3558       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
3559       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
3560       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
3561       int exmode;
3562
3563       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
3564       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
3565       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
3566       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
3567
3568       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
3569       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
3570       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
3571       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
3572       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
3573
3574       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
3575       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
3576       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
3577
3578       gcry_mpi_release (mpi_e);
3579       gcry_mpi_release (mpi_p);
3580       gcry_mpi_release (mpi_q);
3581       gcry_mpi_release (mpi_u);
3582       gcry_mpi_release (mpi_dp);
3583       gcry_mpi_release (mpi_dq);
3584       gcry_mpi_release (mpi_tmp);
3585
3586       /* Build the private key template as described in section 4.3.3.7 of
3587          the OpenPGP card specs version 2.0.  */
3588       err = build_privkey_template (app, keyno,
3589                                     rsa_n, rsa_n_len,
3590                                     rsa_e, rsa_e_len,
3591                                     rsa_p, rsa_p_len,
3592                                     rsa_q, rsa_q_len,
3593                                     rsa_u, rsa_u_len,
3594                                     rsa_dp, rsa_dp_len,
3595                                     rsa_dq, rsa_dq_len,
3596                                     &template, &template_len);
3597       xfree(rsa_u);
3598       xfree(rsa_dp);
3599       xfree(rsa_dq);
3600
3601       if (err)
3602         goto leave;
3603
3604       /* Prepare for storing the key.  */
3605       err = verify_chv3 (app, pincb, pincb_arg);
3606       if (err)
3607         goto leave;
3608
3609       /* Store the key. */
3610       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3611         exmode = 1;    /* Use extended length w/o a limit.  */
3612       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3613         exmode = -254;
3614       else
3615         exmode = 0;
3616       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3617                                   template, template_len);
3618     }
3619   else
3620     {
3621       /* Build the private key template as described in section 4.3.3.6 of
3622          the OpenPGP card specs version 1.1:
3623          0xC0   <length> public exponent
3624          0xC1   <length> prime p
3625          0xC2   <length> prime q
3626       */
3627       assert (rsa_e_len <= 4);
3628       template_len = (1 + 1 + 4
3629                       + 1 + 1 + rsa_p_len
3630                       + 1 + 1 + rsa_q_len);
3631       template = tp = xtrymalloc_secure (template_len);
3632       if (!template)
3633         {
3634           err = gpg_error_from_syserror ();
3635           goto leave;
3636         }
3637       *tp++ = 0xC0;
3638       *tp++ = 4;
3639       memcpy (tp, rsa_e, rsa_e_len);
3640       if (rsa_e_len < 4)
3641         {
3642           /* Right justify E. */
3643           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
3644           memset (tp, 0, 4-rsa_e_len);
3645         }
3646       tp += 4;
3647
3648       *tp++ = 0xC1;
3649       *tp++ = rsa_p_len;
3650       memcpy (tp, rsa_p, rsa_p_len);
3651       tp += rsa_p_len;
3652
3653       *tp++ = 0xC2;
3654       *tp++ = rsa_q_len;
3655       memcpy (tp, rsa_q, rsa_q_len);
3656       tp += rsa_q_len;
3657
3658       assert (tp - template == template_len);
3659
3660       /* Prepare for storing the key.  */
3661       err = verify_chv3 (app, pincb, pincb_arg);
3662       if (err)
3663         goto leave;
3664
3665       /* Store the key. */
3666       err = iso7816_put_data (app->slot, 0,
3667                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
3668                               template, template_len);
3669     }
3670   if (err)
3671     {
3672       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3673       goto leave;
3674     }
3675
3676   err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
3677                    rsa_n, rsa_n_len, rsa_e, rsa_e_len);
3678   if (err)
3679     goto leave;
3680
3681
3682  leave:
3683   xfree (template);
3684   return err;
3685 }
3686
3687
3688 static gpg_error_t
3689 ecc_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3690               void *pincb_arg, int keyno,
3691               const unsigned char *buf, size_t buflen, int depth)
3692 {
3693   gpg_error_t err;
3694   const unsigned char *tok;
3695   size_t toklen;
3696   int last_depth1, last_depth2;
3697   const unsigned char *ecc_q = NULL;
3698   const unsigned char *ecc_d = NULL;
3699   size_t ecc_q_len, ecc_d_len;
3700   const char *curve = NULL;
3701   u32 created_at = 0;
3702   const char *oidstr;
3703   int flag_djb_tweak = 0;
3704   int algo;
3705   gcry_mpi_t oid = NULL;
3706   const unsigned char *oidbuf;
3707   unsigned int n;
3708   size_t oid_len;
3709   unsigned char fprbuf[20];
3710
3711   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3712      curve = "NIST P-256" */
3713   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3714      curve = "secp256k1" */
3715   /* (private-key(ecc(curve%s)(flags eddsa)(q%m)(d%m))(created-at%d)):
3716       curve = "Ed25519" */
3717   last_depth1 = depth;
3718   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3719          && depth && depth >= last_depth1)
3720     {
3721       if (tok)
3722         {
3723           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3724           goto leave;
3725         }
3726       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3727         goto leave;
3728
3729       if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
3730         {
3731           char *curve_name;
3732
3733           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3734             goto leave;
3735
3736           curve_name = xtrymalloc (toklen+1);
3737           if (!curve_name)
3738             {
3739               err = gpg_error_from_syserror ();
3740               goto leave;
3741             }
3742
3743           memcpy (curve_name, tok, toklen);
3744           curve_name[toklen] = 0;
3745           curve = openpgp_is_curve_supported (curve_name, NULL, NULL);
3746           xfree (curve_name);
3747         }
3748       else if (tok && toklen == 5 && !memcmp (tok, "flags", 5))
3749         {
3750           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3751             goto leave;
3752
3753           if (tok)
3754             {
3755               if ((toklen == 5 && !memcmp (tok, "eddsa", 5))
3756                   || (toklen == 9 && !memcmp (tok, "djb-tweak", 9)))
3757                 flag_djb_tweak = 1;
3758             }
3759         }
3760       else if (tok && toklen == 1)
3761         {
3762           const unsigned char **buf2;
3763           size_t *buf2len;
3764           int native = flag_djb_tweak;
3765
3766           switch (*tok)
3767             {
3768             case 'q': buf2 = &ecc_q; buf2len = &ecc_q_len; break;
3769             case 'd': buf2 = &ecc_d; buf2len = &ecc_d_len; native = 0; break;
3770             default: buf2 = NULL;  buf2len = NULL; break;
3771             }
3772           if (buf2 && *buf2)
3773             {
3774               err = gpg_error (GPG_ERR_DUP_VALUE);
3775               goto leave;
3776             }
3777           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3778             goto leave;
3779           if (tok && buf2)
3780             {
3781               if (!native)
3782                 /* Strip off leading zero bytes and save. */
3783                 for (;toklen && !*tok; toklen--, tok++)
3784                   ;
3785
3786               *buf2 = tok;
3787               *buf2len = toklen;
3788             }
3789         }
3790       /* Skip until end of list. */
3791       last_depth2 = depth;
3792       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3793              && depth && depth >= last_depth2)
3794         ;
3795       if (err)
3796         goto leave;
3797     }
3798   /* Parse other attributes. */
3799   last_depth1 = depth;
3800   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3801          && depth && depth >= last_depth1)
3802     {
3803       if (tok)
3804         {
3805           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3806           goto leave;
3807         }
3808       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3809         goto leave;
3810       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3811         {
3812           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3813             goto leave;
3814           if (tok)
3815             {
3816               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3817                    tok++, toklen--)
3818                 created_at = created_at*10 + (*tok - '0');
3819             }
3820         }
3821       /* Skip until end of list. */
3822       last_depth2 = depth;
3823       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3824              && depth && depth >= last_depth2)
3825         ;
3826       if (err)
3827         goto leave;
3828     }
3829
3830
3831   /* Check that we have all parameters and that they match the card
3832      description. */
3833   if (!curve)
3834     {
3835       log_error (_("unsupported curve\n"));
3836       err = gpg_error (GPG_ERR_INV_VALUE);
3837       goto leave;
3838     }
3839   if (!created_at)
3840     {
3841       log_error (_("creation timestamp missing\n"));
3842       err = gpg_error (GPG_ERR_INV_VALUE);
3843       goto leave;
3844     }
3845   if (flag_djb_tweak && keyno != 1)
3846     algo = PUBKEY_ALGO_EDDSA;
3847   else if (keyno == 1)
3848     algo = PUBKEY_ALGO_ECDH;
3849   else
3850     algo = PUBKEY_ALGO_ECDSA;
3851
3852   oidstr = openpgp_curve_to_oid (curve, NULL);
3853   err = openpgp_oid_from_str (oidstr, &oid);
3854   if (err)
3855     goto leave;
3856   oidbuf = gcry_mpi_get_opaque (oid, &n);
3857   if (!oidbuf)
3858     {
3859       err = gpg_error_from_syserror ();
3860       goto leave;
3861     }
3862   oid_len = (n+7)/8;
3863
3864   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_ECC
3865       || app->app_local->keyattr[keyno].ecc.curve != curve
3866       || (flag_djb_tweak !=
3867           (app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK)))
3868     {
3869       if (app->app_local->extcap.algo_attr_change)
3870         {
3871           unsigned char *keyattr;
3872
3873           if (!oid_len)
3874             {
3875               err = gpg_error (GPG_ERR_INTERNAL);
3876               goto leave;
3877             }
3878           keyattr = xtrymalloc (oid_len);
3879           if (!keyattr)
3880             {
3881               err = gpg_error_from_syserror ();
3882               goto leave;
3883             }
3884           keyattr[0] = algo;
3885           memcpy (keyattr+1, oidbuf+1, oid_len-1);
3886           err = change_keyattr (app, keyno, keyattr, oid_len, pincb, pincb_arg);
3887           xfree (keyattr);
3888           if (err)
3889             goto leave;
3890         }
3891       else
3892         {
3893           log_error ("key attribute on card doesn't match\n");
3894           err = gpg_error (GPG_ERR_INV_VALUE);
3895           goto leave;
3896         }
3897     }
3898
3899   if (opt.verbose)
3900     log_info ("ECC private key size is %u bytes\n", (unsigned int)ecc_d_len);
3901
3902   /* We need to remove the cached public key.  */
3903   xfree (app->app_local->pk[keyno].key);
3904   app->app_local->pk[keyno].key = NULL;
3905   app->app_local->pk[keyno].keylen = 0;
3906   app->app_local->pk[keyno].read_done = 0;
3907
3908   if (app->app_local->extcap.is_v2)
3909     {
3910       /* Build the private key template as described in section 4.3.3.7 of
3911          the OpenPGP card specs version 2.0.  */
3912       unsigned char *template;
3913       size_t template_len;
3914       int exmode;
3915
3916       err = build_ecc_privkey_template (app, keyno,
3917                                         ecc_d, ecc_d_len,
3918                                         ecc_q, ecc_q_len,
3919                                         &template, &template_len);
3920       if (err)
3921         goto leave;
3922
3923       /* Prepare for storing the key.  */
3924       err = verify_chv3 (app, pincb, pincb_arg);
3925       if (err)
3926         {
3927           xfree (template);
3928           goto leave;
3929         }
3930
3931       /* Store the key. */
3932       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3933         exmode = 1;    /* Use extended length w/o a limit.  */
3934       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3935         exmode = -254;
3936       else
3937         exmode = 0;
3938       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3939                                   template, template_len);
3940       xfree (template);
3941     }
3942   else
3943     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
3944
3945   if (err)
3946     {
3947       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3948       goto leave;
3949     }
3950
3951   err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
3952                    ecc_q, ecc_q_len, ecdh_params (curve), (size_t)4);
3953
3954  leave:
3955   gcry_mpi_release (oid);
3956   return err;
3957 }
3958
3959 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
3960    canonical encoded S-expression with the secret key in KEYDATA and
3961    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
3962    usual keyid which for OpenPGP is the string "OPENPGP.n" with
3963    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
3964    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
3965    the pinentry callback.  */
3966 static gpg_error_t
3967 do_writekey (app_t app, ctrl_t ctrl,
3968              const char *keyid, unsigned int flags,
3969              gpg_error_t (*pincb)(void*, const char *, char **),
3970              void *pincb_arg,
3971              const unsigned char *keydata, size_t keydatalen)
3972 {
3973   gpg_error_t err;
3974   int force = (flags & 1);
3975   int keyno;
3976   const unsigned char *buf, *tok;
3977   size_t buflen, toklen;
3978   int depth;
3979
3980   (void)ctrl;
3981
3982   if (!strcmp (keyid, "OPENPGP.1"))
3983     keyno = 0;
3984   else if (!strcmp (keyid, "OPENPGP.2"))
3985     keyno = 1;
3986   else if (!strcmp (keyid, "OPENPGP.3"))
3987     keyno = 2;
3988   else
3989     return gpg_error (GPG_ERR_INV_ID);
3990
3991   err = does_key_exist (app, keyno, 0, force);
3992   if (err)
3993     return err;
3994
3995
3996   /*
3997      Parse the S-expression
3998    */
3999   buf = keydata;
4000   buflen = keydatalen;
4001   depth = 0;
4002   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4003     goto leave;
4004   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4005     goto leave;
4006   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
4007     {
4008       if (!tok)
4009         ;
4010       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
4011         log_info ("protected-private-key passed to writekey\n");
4012       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
4013         log_info ("shadowed-private-key passed to writekey\n");
4014       err = gpg_error (GPG_ERR_BAD_SECKEY);
4015       goto leave;
4016     }
4017   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4018     goto leave;
4019   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4020     goto leave;
4021   if (tok && toklen == 3 && memcmp ("rsa", tok, toklen) == 0)
4022     err = rsa_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
4023   else if (tok && toklen == 3 && memcmp ("ecc", tok, toklen) == 0)
4024     err = ecc_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
4025   else
4026     {
4027       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
4028       goto leave;
4029     }
4030
4031  leave:
4032   return err;
4033 }
4034
4035
4036
4037 /* Handle the GENKEY command. */
4038 static gpg_error_t
4039 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
4040            time_t createtime,
4041            gpg_error_t (*pincb)(void*, const char *, char **),
4042            void *pincb_arg)
4043 {
4044   gpg_error_t err;
4045   char numbuf[30];
4046   unsigned char *buffer = NULL;
4047   const unsigned char *keydata;
4048   size_t buflen, keydatalen;
4049   u32 created_at;
4050   int keyno = atoi (keynostr) - 1;
4051   int force = (flags & 1);
4052   time_t start_at;
4053   int exmode = 0;
4054   int le_value = 256; /* Use legacy value. */
4055
4056   if (keyno < 0 || keyno > 2)
4057     return gpg_error (GPG_ERR_INV_ID);
4058
4059   /* We flush the cache to increase the traffic before a key
4060      generation.  This _might_ help a card to gather more entropy. */
4061   flush_cache (app);
4062
4063   /* Obviously we need to remove the cached public key.  */
4064   xfree (app->app_local->pk[keyno].key);
4065   app->app_local->pk[keyno].key = NULL;
4066   app->app_local->pk[keyno].keylen = 0;
4067   app->app_local->pk[keyno].read_done = 0;
4068
4069   /* Check whether a key already exists.  */
4070   err = does_key_exist (app, keyno, 1, force);
4071   if (err)
4072     return err;
4073
4074   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
4075     {
4076       unsigned int keybits = app->app_local->keyattr[keyno].rsa.n_bits;
4077
4078       /* Because we send the key parameter back via status lines we need
4079          to put a limit on the max. allowed keysize.  2048 bit will
4080          already lead to a 527 byte long status line and thus a 4096 bit
4081          key would exceed the Assuan line length limit.  */
4082       if (keybits > 4096)
4083         return gpg_error (GPG_ERR_TOO_LARGE);
4084
4085       if (app->app_local->cardcap.ext_lc_le && keybits > RSA_SMALL_SIZE_KEY
4086           && app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
4087         {
4088           exmode = 1;    /* Use extended length w/o a limit.  */
4089           le_value = determine_rsa_response (app, keyno);
4090           /* No need to check le_value because it comes from a 16 bit
4091              value and thus can't create an overflow on a 32 bit
4092              system.  */
4093         }
4094     }
4095
4096   /* Prepare for key generation by verifying the Admin PIN.  */
4097   err = verify_chv3 (app, pincb, pincb_arg);
4098   if (err)
4099     return err;
4100
4101
4102   log_info (_("please wait while key is being generated ...\n"));
4103   start_at = time (NULL);
4104   err = iso7816_generate_keypair (app->slot, exmode,
4105                                   (keyno == 0? "\xB6" :
4106                                    keyno == 1? "\xB8" : "\xA4"),
4107                                   2, le_value, &buffer, &buflen);
4108   if (err)
4109     {
4110       log_error (_("generating key failed\n"));
4111       return gpg_error (GPG_ERR_CARD);
4112     }
4113
4114   {
4115     int nsecs = (int)(time (NULL) - start_at);
4116     log_info (ngettext("key generation completed (%d second)\n",
4117                        "key generation completed (%d seconds)\n",
4118                        nsecs), nsecs);
4119   }
4120
4121   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
4122   if (!keydata)
4123     {
4124       err = gpg_error (GPG_ERR_CARD);
4125       log_error (_("response does not contain the public key data\n"));
4126       goto leave;
4127     }
4128
4129   created_at = (u32)(createtime? createtime : gnupg_get_time ());
4130   sprintf (numbuf, "%u", created_at);
4131   send_status_info (ctrl, "KEY-CREATED-AT",
4132                     numbuf, (size_t)strlen(numbuf), NULL, 0);
4133
4134   err = read_public_key (app, ctrl, created_at, keyno, buffer, buflen);
4135  leave:
4136   xfree (buffer);
4137   return err;
4138 }
4139
4140
4141 static unsigned long
4142 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
4143 {
4144   unsigned long ul;
4145
4146   if (valuelen == 3 )
4147     ul = (value[0] << 16) | (value[1] << 8) | value[2];
4148   else
4149     {
4150       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
4151       ul = 0;
4152     }
4153   return ul;
4154 }
4155
4156 static unsigned long
4157 get_sig_counter (app_t app)
4158 {
4159   void *relptr;
4160   unsigned char *value;
4161   size_t valuelen;
4162   unsigned long ul;
4163
4164   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
4165   if (!relptr)
4166     return 0;
4167   ul = convert_sig_counter_value (value, valuelen);
4168   xfree (relptr);
4169   return ul;
4170 }
4171
4172 static gpg_error_t
4173 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
4174 {
4175   const unsigned char *fpr;
4176   unsigned char *buffer;
4177   size_t buflen, n;
4178   int rc, i;
4179
4180   assert (keyno >= 0 && keyno <= 2);
4181
4182   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
4183   if (rc)
4184     {
4185       log_error (_("error reading application data\n"));
4186       return gpg_error (GPG_ERR_GENERAL);
4187     }
4188   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
4189   if (!fpr || n != 60)
4190     {
4191       xfree (buffer);
4192       log_error (_("error reading fingerprint DO\n"));
4193       return gpg_error (GPG_ERR_GENERAL);
4194     }
4195   fpr += keyno*20;
4196   for (i=0; i < 20; i++)
4197     if (sha1fpr[i] != fpr[i])
4198       {
4199         xfree (buffer);
4200         log_info (_("fingerprint on card does not match requested one\n"));
4201         return gpg_error (GPG_ERR_WRONG_SECKEY);
4202       }
4203   xfree (buffer);
4204   return 0;
4205 }
4206
4207
4208 /* If a fingerprint has been specified check it against the one on the
4209    card.  This allows for a meaningful error message in case the key
4210    on the card has been replaced but the shadow information known to
4211    gpg has not been updated.  If there is no fingerprint we assume
4212    that this is okay. */
4213 static gpg_error_t
4214 check_against_given_fingerprint (app_t app, const char *fpr, int key)
4215 {
4216   unsigned char tmp[20];
4217   const char *s;
4218   int n;
4219