scd: Factor out a function to check keyidstr.
[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->appversion > 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->appversion > 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->appversion > 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     { "$ENCRKEYID",   0x0000, -6 },
991     { "$SIGNKEYID",   0x0000, -7 },
992     { "$DISPSERIALNO",0x0000, -4 },
993     { "UIF-1",        0x00D6, 0 },
994     { "UIF-2",        0x00D7, 0 },
995     { "UIF-3",        0x00D8, 0 },
996     { "KDF",          0x00F9 },
997     { NULL, 0 }
998   };
999   int idx, i, rc;
1000   void *relptr;
1001   unsigned char *value;
1002   size_t valuelen;
1003
1004   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1005     ;
1006   if (!table[idx].name)
1007     return gpg_error (GPG_ERR_INV_NAME);
1008
1009   if (table[idx].special == -1)
1010     {
1011       /* The serial number is very special.  We could have used the
1012          AID DO to retrieve it.  The AID DO is available anyway but
1013          not hex formatted. */
1014       char *serial = app_get_serialno (app);
1015
1016       if (serial)
1017         {
1018           send_status_direct (ctrl, "SERIALNO", serial);
1019           xfree (serial);
1020         }
1021       return 0;
1022     }
1023   if (table[idx].special == -2)
1024     {
1025       char tmp[110];
1026
1027       snprintf (tmp, sizeof tmp,
1028                 "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d "
1029                 "sm=%d si=%u dec=%d bt=%d kdf=%d",
1030                 app->app_local->extcap.get_challenge,
1031                 app->app_local->extcap.key_import,
1032                 app->app_local->extcap.change_force_chv,
1033                 app->app_local->extcap.private_dos,
1034                 app->app_local->extcap.max_certlen_3,
1035                 app->app_local->extcap.algo_attr_change,
1036                 (app->app_local->extcap.sm_supported
1037                  ? (app->app_local->extcap.sm_algo == 0? CIPHER_ALGO_3DES :
1038                     (app->app_local->extcap.sm_algo == 1?
1039                      CIPHER_ALGO_AES : CIPHER_ALGO_AES256))
1040                  : 0),
1041                 app->app_local->status_indicator,
1042                 app->app_local->extcap.has_decrypt,
1043                 app->app_local->extcap.has_button,
1044                 app->app_local->extcap.kdf_do);
1045       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1046       return 0;
1047     }
1048   if (table[idx].special == -3)
1049     {
1050       char const tmp[] = "OPENPGP.3";
1051       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1052       return 0;
1053     }
1054   if (table[idx].special == -4)
1055     {
1056       char *serial = app_get_serialno (app);
1057
1058       if (serial)
1059         {
1060           if (strlen (serial) > 16+12)
1061             {
1062               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
1063               xfree (serial);
1064               return 0;
1065             }
1066           xfree (serial);
1067         }
1068       return gpg_error (GPG_ERR_INV_NAME);
1069     }
1070   if (table[idx].special == -5)
1071     {
1072       for (i=0; i < 3; i++)
1073         send_key_attr (ctrl, app, table[idx].name, i);
1074       return 0;
1075     }
1076   if (table[idx].special == -6)
1077     {
1078       char const tmp[] = "OPENPGP.2";
1079       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1080       return 0;
1081     }
1082   if (table[idx].special == -7)
1083     {
1084       char const tmp[] = "OPENPGP.1";
1085       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1086       return 0;
1087     }
1088
1089   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
1090   if (relptr)
1091     {
1092       if (table[idx].special == 1)
1093         {
1094           char numbuf[7*23];
1095
1096           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
1097             sprintf (numbuf+strlen (numbuf), " %d", value[i]);
1098           send_status_info (ctrl, table[idx].name,
1099                             numbuf, strlen (numbuf), NULL, 0);
1100         }
1101       else if (table[idx].special == 2)
1102         {
1103           char numbuf[50];
1104
1105           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
1106           send_status_info (ctrl, table[idx].name,
1107                             numbuf, strlen (numbuf), NULL, 0);
1108         }
1109       else if (table[idx].special == 3)
1110         {
1111           if (valuelen >= 60)
1112             for (i=0; i < 3; i++)
1113               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
1114         }
1115       else if (table[idx].special == 4)
1116         {
1117           if (valuelen >= 12)
1118             for (i=0; i < 3; i++)
1119               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
1120         }
1121       else
1122         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
1123
1124       xfree (relptr);
1125     }
1126   return rc;
1127 }
1128
1129
1130 /* Return the DISP-NAME without any padding characters.  Caller must
1131  * free the result.  If not found or empty NULL is returned.  */
1132 static char *
1133 get_disp_name (app_t app)
1134 {
1135   int rc;
1136   void *relptr;
1137   unsigned char *value;
1138   size_t valuelen;
1139   char *string;
1140   char *p, *given;
1141   char *result;
1142
1143   relptr = get_one_do (app, 0x005B, &value, &valuelen, &rc);
1144   if (!relptr)
1145     return NULL;
1146
1147   string = xtrymalloc (valuelen + 1);
1148   if (!string)
1149     {
1150       xfree (relptr);
1151       return NULL;
1152     }
1153   memcpy (string, value, valuelen);
1154   string[valuelen] = 0;
1155   xfree (relptr);
1156
1157   /* Swap surname and given name.  */
1158   given = strstr (string, "<<");
1159   for (p = string; *p; p++)
1160     if (*p == '<')
1161       *p = ' ';
1162
1163   if (given && given[2])
1164     {
1165       *given = 0;
1166       given += 2;
1167       result = strconcat (given, " ", string, NULL);
1168     }
1169   else
1170     {
1171       result = string;
1172       string = NULL;
1173     }
1174
1175   xfree (string);
1176   return result;
1177 }
1178
1179
1180 /* Return the pretty formatted serialnumber.  On error NULL is
1181  * returned.  */
1182 static char *
1183 get_disp_serialno (app_t app)
1184 {
1185   char *serial = app_get_serialno (app);
1186
1187   /* For our OpenPGP cards we do not want to show the entire serial
1188    * number but a nicely reformatted actual serial number.  */
1189   if (serial && strlen (serial) > 16+12)
1190     {
1191       memmove (serial, serial+16, 4);
1192       serial[4] = ' ';
1193       /* memmove (serial+5, serial+20, 4); */
1194       /* serial[9] = ' '; */
1195       /* memmove (serial+10, serial+24, 4); */
1196       /* serial[14] = 0; */
1197       memmove (serial+5, serial+20, 8);
1198       serial[13] = 0;
1199     }
1200   return serial;
1201 }
1202
1203
1204 /* Return the number of remaining tries for the standard or the admin
1205  * pw.  Returns -1 on card error.  */
1206 static int
1207 get_remaining_tries (app_t app, int adminpw)
1208 {
1209   void *relptr;
1210   unsigned char *value;
1211   size_t valuelen;
1212   int remaining;
1213
1214   relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1215   if (!relptr || valuelen < 7)
1216     {
1217       log_error (_("error retrieving CHV status from card\n"));
1218       xfree (relptr);
1219       return -1;
1220     }
1221   remaining = value[adminpw? 6 : 4];
1222   xfree (relptr);
1223   return remaining;
1224 }
1225
1226
1227 /* Retrieve the fingerprint from the card inserted in SLOT and write
1228    the according hex representation to FPR.  Caller must have provide
1229    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
1230    error code. */
1231 #if GNUPG_MAJOR_VERSION > 1
1232 static gpg_error_t
1233 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
1234 {
1235   gpg_error_t err = 0;
1236   void *relptr;
1237   unsigned char *value;
1238   size_t valuelen;
1239
1240   assert (keyno >=0 && keyno <= 2);
1241
1242   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
1243   if (relptr && valuelen >= 60)
1244     bin2hex (value+keyno*20, 20, fpr);
1245   else
1246     err = gpg_error (GPG_ERR_NOT_FOUND);
1247   xfree (relptr);
1248   return err;
1249 }
1250 #endif /*GNUPG_MAJOR_VERSION > 1*/
1251
1252
1253 /* Retrieve the public key material for the RSA key, whose fingerprint
1254    is FPR, from gpg output, which can be read through the stream FP.
1255    The RSA modulus will be stored at the address of M and MLEN, the
1256    public exponent at E and ELEN.  Returns zero on success, an error
1257    code on failure.  Caller must release the allocated buffers at M
1258    and E if the function returns success.  */
1259 #if GNUPG_MAJOR_VERSION > 1
1260 static gpg_error_t
1261 retrieve_key_material (FILE *fp, const char *hexkeyid,
1262                        const unsigned char **m, size_t *mlen,
1263                        const unsigned char **e, size_t *elen)
1264 {
1265   gcry_error_t err = 0;
1266   char *line = NULL;    /* read_line() buffer. */
1267   size_t line_size = 0; /* Helper for for read_line. */
1268   int found_key = 0;    /* Helper to find a matching key. */
1269   unsigned char *m_new = NULL;
1270   unsigned char *e_new = NULL;
1271   size_t m_new_n = 0;
1272   size_t e_new_n = 0;
1273
1274   /* Loop over all records until we have found the subkey
1275      corresponding to the fingerprint. Inm general the first record
1276      should be the pub record, but we don't rely on that.  Given that
1277      we only need to look at one key, it is sufficient to compare the
1278      keyid so that we don't need to look at "fpr" records. */
1279   for (;;)
1280     {
1281       char *p;
1282       char *fields[6] = { NULL, NULL, NULL, NULL, NULL, NULL };
1283       int nfields;
1284       size_t max_length;
1285       gcry_mpi_t mpi;
1286       int i;
1287
1288       max_length = 4096;
1289       i = read_line (fp, &line, &line_size, &max_length);
1290       if (!i)
1291         break; /* EOF. */
1292       if (i < 0)
1293         {
1294           err = gpg_error_from_syserror ();
1295           goto leave; /* Error. */
1296         }
1297       if (!max_length)
1298         {
1299           err = gpg_error (GPG_ERR_TRUNCATED);
1300           goto leave;  /* Line truncated - we better stop processing.  */
1301         }
1302
1303       /* Parse the line into fields. */
1304       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
1305         {
1306           fields[nfields] = p;
1307           p = strchr (p, ':');
1308           if (p)
1309             *(p++) = 0;
1310         }
1311       if (!nfields)
1312         continue; /* No fields at all - skip line.  */
1313
1314       if (!found_key)
1315         {
1316           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1317                && nfields > 4 && !strcmp (fields[4], hexkeyid))
1318             found_key = 1;
1319           continue;
1320         }
1321
1322       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1323         break; /* Next key - stop.  */
1324
1325       if ( strcmp (fields[0], "pkd") )
1326         continue; /* Not a key data record.  */
1327       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1328            || (!i && m_new) || (i && e_new))
1329         {
1330           err = gpg_error (GPG_ERR_GENERAL);
1331           goto leave; /* Error: Invalid key data record or not an RSA key.  */
1332         }
1333
1334       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1335       if (err)
1336         mpi = NULL;
1337       else if (!i)
1338         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1339       else
1340         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1341       gcry_mpi_release (mpi);
1342       if (err)
1343         goto leave;
1344     }
1345
1346   if (m_new && e_new)
1347     {
1348       *m = m_new;
1349       *mlen = m_new_n;
1350       m_new = NULL;
1351       *e = e_new;
1352       *elen = e_new_n;
1353       e_new = NULL;
1354     }
1355   else
1356     err = gpg_error (GPG_ERR_GENERAL);
1357
1358  leave:
1359   xfree (m_new);
1360   xfree (e_new);
1361   xfree (line);
1362   return err;
1363 }
1364 #endif /*GNUPG_MAJOR_VERSION > 1*/
1365
1366
1367 static gpg_error_t
1368 rsa_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at,  int keyno,
1369                  const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
1370 {
1371   gpg_error_t err;
1372   const unsigned char *m, *e;
1373   size_t mlen, elen;
1374   unsigned char *mbuf = NULL, *ebuf = NULL;
1375
1376   m = find_tlv (data, datalen, 0x0081, &mlen);
1377   if (!m)
1378     {
1379       log_error (_("response does not contain the RSA modulus\n"));
1380       return gpg_error (GPG_ERR_CARD);
1381     }
1382
1383   e = find_tlv (data, datalen, 0x0082, &elen);
1384   if (!e)
1385     {
1386       log_error (_("response does not contain the RSA public exponent\n"));
1387       return gpg_error (GPG_ERR_CARD);
1388     }
1389
1390   if (ctrl)
1391     {
1392       send_key_data (ctrl, "n", m, mlen);
1393       send_key_data (ctrl, "e", e, elen);
1394     }
1395
1396   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
1397     ;
1398   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
1399     ;
1400
1401   if (ctrl)
1402     {
1403       unsigned char fprbuf[20];
1404
1405       err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
1406                        m, mlen, e, elen);
1407       if (err)
1408         return err;
1409
1410       send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1411     }
1412
1413   mbuf = xtrymalloc (mlen + 1);
1414   if (!mbuf)
1415     {
1416       err = gpg_error_from_syserror ();
1417       goto leave;
1418     }
1419   /* Prepend numbers with a 0 if needed.  */
1420   if (mlen && (*m & 0x80))
1421     {
1422       *mbuf = 0;
1423       memcpy (mbuf+1, m, mlen);
1424       mlen++;
1425     }
1426   else
1427     memcpy (mbuf, m, mlen);
1428
1429   ebuf = xtrymalloc (elen + 1);
1430   if (!ebuf)
1431     {
1432       err = gpg_error_from_syserror ();
1433       goto leave;
1434     }
1435   /* Prepend numbers with a 0 if needed.  */
1436   if (elen && (*e & 0x80))
1437     {
1438       *ebuf = 0;
1439       memcpy (ebuf+1, e, elen);
1440       elen++;
1441     }
1442   else
1443     memcpy (ebuf, e, elen);
1444
1445   err = gcry_sexp_build (r_sexp, NULL, "(public-key(rsa(n%b)(e%b)))",
1446                          (int)mlen, mbuf, (int)elen, ebuf);
1447  leave:
1448   xfree (mbuf);
1449   xfree (ebuf);
1450   return err;
1451 }
1452
1453
1454 /* Determine KDF hash algorithm and KEK encryption algorithm by CURVE.  */
1455 static const unsigned char*
1456 ecdh_params (const char *curve)
1457 {
1458   unsigned int nbits;
1459
1460   openpgp_curve_to_oid (curve, &nbits);
1461
1462   /* See RFC-6637 for those constants.
1463          0x03: Number of bytes
1464          0x01: Version for this parameter format
1465          KEK digest algorithm
1466          KEK cipher algorithm
1467   */
1468   if (nbits <= 256)
1469     return (const unsigned char*)"\x03\x01\x08\x07";
1470   else if (nbits <= 384)
1471     return (const unsigned char*)"\x03\x01\x09\x09";
1472   else
1473     return (const unsigned char*)"\x03\x01\x0a\x09";
1474 }
1475
1476 static gpg_error_t
1477 ecc_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
1478                  const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
1479 {
1480   gpg_error_t err;
1481   unsigned char *qbuf = NULL;
1482   const unsigned char *ecc_q;
1483   size_t ecc_q_len;
1484   gcry_mpi_t oid = NULL;
1485   int n;
1486   const char *curve;
1487   const char *oidstr;
1488   const unsigned char *oidbuf;
1489   size_t oid_len;
1490   int algo;
1491   const char *format;
1492
1493   ecc_q = find_tlv (data, datalen, 0x0086, &ecc_q_len);
1494   if (!ecc_q)
1495     {
1496       log_error (_("response does not contain the EC public key\n"));
1497       return gpg_error (GPG_ERR_CARD);
1498     }
1499
1500   curve = app->app_local->keyattr[keyno].ecc.curve;
1501   oidstr = openpgp_curve_to_oid (curve, NULL);
1502   err = openpgp_oid_from_str (oidstr, &oid);
1503   if (err)
1504     return err;
1505   oidbuf = gcry_mpi_get_opaque (oid, &n);
1506   if (!oidbuf)
1507     {
1508       err = gpg_error_from_syserror ();
1509       goto leave;
1510     }
1511   oid_len = (n+7)/8;
1512
1513   qbuf = xtrymalloc (ecc_q_len + 1);
1514   if (!qbuf)
1515     {
1516       err = gpg_error_from_syserror ();
1517       goto leave;
1518     }
1519
1520   if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1521     {               /* Prepend 0x40 prefix.  */
1522       *qbuf = 0x40;
1523       memcpy (qbuf+1, ecc_q, ecc_q_len);
1524       ecc_q_len++;
1525     }
1526   else
1527     memcpy (qbuf, ecc_q, ecc_q_len);
1528
1529   if (ctrl)
1530     {
1531       send_key_data (ctrl, "q", qbuf, ecc_q_len);
1532       send_key_data (ctrl, "curve", oidbuf, oid_len);
1533     }
1534
1535   if (keyno == 1)
1536     {
1537       if (ctrl)
1538         send_key_data (ctrl, "kdf/kek", ecdh_params (curve), (size_t)4);
1539       algo = PUBKEY_ALGO_ECDH;
1540     }
1541   else
1542     {
1543       if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1544         algo = PUBKEY_ALGO_EDDSA;
1545       else
1546         algo = PUBKEY_ALGO_ECDSA;
1547     }
1548
1549   if (ctrl)
1550     {
1551       unsigned char fprbuf[20];
1552
1553       err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
1554                        qbuf, ecc_q_len, ecdh_params (curve), (size_t)4);
1555       if (err)
1556         goto leave;
1557
1558       send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1559     }
1560
1561   if (!(app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1562     format = "(public-key(ecc(curve%s)(q%b)))";
1563   else if (keyno == 1)
1564     format = "(public-key(ecc(curve%s)(flags djb-tweak)(q%b)))";
1565   else
1566     format = "(public-key(ecc(curve%s)(flags eddsa)(q%b)))";
1567
1568   err = gcry_sexp_build (r_sexp, NULL, format,
1569                          app->app_local->keyattr[keyno].ecc.curve,
1570                          (int)ecc_q_len, qbuf);
1571  leave:
1572   gcry_mpi_release (oid);
1573   xfree (qbuf);
1574   return err;
1575 }
1576
1577
1578 /* Parse tag-length-value data for public key in BUFFER of BUFLEN
1579    length.  Key of KEYNO in APP is updated with an S-expression of
1580    public key.  When CTRL is not NULL, fingerprint is computed with
1581    CREATED_AT, and fingerprint is written to the card, and key data
1582    and fingerprint are send back to the client side.
1583  */
1584 static gpg_error_t
1585 read_public_key (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
1586                  const unsigned char *buffer, size_t buflen)
1587 {
1588   gpg_error_t err;
1589   const unsigned char *data;
1590   size_t datalen;
1591   gcry_sexp_t s_pkey = NULL;
1592
1593   data = find_tlv (buffer, buflen, 0x7F49, &datalen);
1594   if (!data)
1595     {
1596       log_error (_("response does not contain the public key data\n"));
1597       return gpg_error (GPG_ERR_CARD);
1598     }
1599
1600   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
1601     err = rsa_read_pubkey (app, ctrl, created_at, keyno,
1602                            data, datalen, &s_pkey);
1603   else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
1604     err = ecc_read_pubkey (app, ctrl, created_at, keyno,
1605                            data, datalen, &s_pkey);
1606   else
1607     err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1608
1609   if (!err)
1610     {
1611       unsigned char *keybuf;
1612       size_t len;
1613
1614       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1615       keybuf = xtrymalloc (len);
1616       if (!data)
1617         {
1618           err = gpg_error_from_syserror ();
1619           gcry_sexp_release (s_pkey);
1620           return err;
1621         }
1622
1623       gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1624       gcry_sexp_release (s_pkey);
1625
1626       app->app_local->pk[keyno].key = keybuf;
1627       /* Decrement for trailing '\0' */
1628       app->app_local->pk[keyno].keylen = len - 1;
1629     }
1630
1631   return err;
1632 }
1633
1634
1635 /* Get the public key for KEYNO and store it as an S-expression with
1636    the APP handle.  On error that field gets cleared.  If we already
1637    know about the public key we will just return.  Note that this does
1638    not mean a key is available; this is solely indicated by the
1639    presence of the app->app_local->pk[KEYNO].key field.
1640
1641    Note that GnuPG 1.x does not need this and it would be too time
1642    consuming to send it just for the fun of it. However, given that we
1643    use the same code in gpg 1.4, we can't use the gcry S-expression
1644    here but need to open encode it. */
1645 #if GNUPG_MAJOR_VERSION > 1
1646 static gpg_error_t
1647 get_public_key (app_t app, int keyno)
1648 {
1649   gpg_error_t err = 0;
1650   unsigned char *buffer;
1651   const unsigned char *m, *e;
1652   size_t buflen;
1653   size_t mlen = 0;
1654   size_t elen = 0;
1655   char *keybuf = NULL;
1656   gcry_sexp_t s_pkey;
1657   size_t len;
1658
1659   if (keyno < 0 || keyno > 2)
1660     return gpg_error (GPG_ERR_INV_ID);
1661
1662   /* Already cached? */
1663   if (app->app_local->pk[keyno].read_done)
1664     return 0;
1665
1666   xfree (app->app_local->pk[keyno].key);
1667   app->app_local->pk[keyno].key = NULL;
1668   app->app_local->pk[keyno].keylen = 0;
1669
1670   m = e = NULL; /* (avoid cc warning) */
1671
1672   if (app->appversion > 0x0100)
1673     {
1674       int exmode, le_value;
1675
1676       /* We may simply read the public key out of these cards.  */
1677       if (app->app_local->cardcap.ext_lc_le
1678           && app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA
1679           && app->app_local->keyattr[keyno].rsa.n_bits > RSA_SMALL_SIZE_KEY)
1680         {
1681           exmode = 1;    /* Use extended length.  */
1682           le_value = determine_rsa_response (app, keyno);
1683         }
1684       else
1685         {
1686           exmode = 0;
1687           le_value = 256; /* Use legacy value. */
1688         }
1689
1690       err = iso7816_read_public_key (app->slot, exmode,
1691                                      (keyno == 0? "\xB6" :
1692                                       keyno == 1? "\xB8" : "\xA4"),
1693                                      2, le_value, &buffer, &buflen);
1694       if (err)
1695         {
1696           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1697           goto leave;
1698         }
1699
1700       err = read_public_key (app, NULL, 0U, keyno, buffer, buflen);
1701     }
1702   else
1703     {
1704       /* Due to a design problem in v1.0 cards we can't get the public
1705          key out of these cards without doing a verify on CHV3.
1706          Clearly that is not an option and thus we try to locate the
1707          key using an external helper.
1708
1709          The helper we use here is gpg itself, which should know about
1710          the key in any case.  */
1711
1712       char fpr[41];
1713       char *hexkeyid;
1714       char *command = NULL;
1715       FILE *fp;
1716       int ret;
1717
1718       buffer = NULL; /* We don't need buffer.  */
1719
1720       err = retrieve_fpr_from_card (app, keyno, fpr);
1721       if (err)
1722         {
1723           log_error ("error while retrieving fpr from card: %s\n",
1724                      gpg_strerror (err));
1725           goto leave;
1726         }
1727       hexkeyid = fpr + 24;
1728
1729       ret = gpgrt_asprintf
1730         (&command, "gpg --list-keys --with-colons --with-key-data '%s'", fpr);
1731       if (ret < 0)
1732         {
1733           err = gpg_error_from_syserror ();
1734           goto leave;
1735         }
1736
1737       fp = popen (command, "r");
1738       xfree (command);
1739       if (!fp)
1740         {
1741           err = gpg_error_from_syserror ();
1742           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1743           goto leave;
1744         }
1745
1746       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1747       pclose (fp);
1748       if (err)
1749         {
1750           log_error ("error while retrieving key material through pipe: %s\n",
1751                      gpg_strerror (err));
1752           goto leave;
1753         }
1754
1755       err = gcry_sexp_build (&s_pkey, NULL, "(public-key(rsa(n%b)(e%b)))",
1756                              (int)mlen, m, (int)elen, e);
1757       if (err)
1758         goto leave;
1759
1760       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1761
1762       keybuf = xtrymalloc (len);
1763       if (!keybuf)
1764         {
1765           err = gpg_error_from_syserror ();
1766           gcry_sexp_release (s_pkey);
1767           goto leave;
1768         }
1769
1770       gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1771       gcry_sexp_release (s_pkey);
1772
1773       app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1774       /* Decrement for trailing '\0' */
1775       app->app_local->pk[keyno].keylen = len - 1;
1776     }
1777
1778  leave:
1779   /* Set a flag to indicate that we tried to read the key.  */
1780   app->app_local->pk[keyno].read_done = 1;
1781
1782   xfree (buffer);
1783   return err;
1784 }
1785 #endif /* GNUPG_MAJOR_VERSION > 1 */
1786
1787
1788
1789 /* Send the KEYPAIRINFO back. KEY needs to be in the range [1,3].
1790    This is used by the LEARN command. */
1791 static gpg_error_t
1792 send_keypair_info (app_t app, ctrl_t ctrl, int key)
1793 {
1794   int keyno = key - 1;
1795   gpg_error_t err = 0;
1796   /* Note that GnuPG 1.x does not need this and it would be too time
1797      consuming to send it just for the fun of it. */
1798 #if GNUPG_MAJOR_VERSION > 1
1799   unsigned char grip[20];
1800   char gripstr[41];
1801   char idbuf[50];
1802   const char *usage;
1803
1804   err = get_public_key (app, keyno);
1805   if (err)
1806     goto leave;
1807
1808   assert (keyno >= 0 && keyno <= 2);
1809   if (!app->app_local->pk[keyno].key)
1810     goto leave; /* No such key - ignore. */
1811
1812   err = keygrip_from_canon_sexp (app->app_local->pk[keyno].key,
1813                                  app->app_local->pk[keyno].keylen,
1814                                  grip);
1815   if (err)
1816     goto leave;
1817
1818   bin2hex (grip, 20, gripstr);
1819
1820   switch (keyno)
1821     {
1822     case 0: usage = "sc"; break;
1823     case 1: usage = "e";  break;
1824     case 2: usage = "sa"; break;
1825     default: usage = "";  break;
1826     }
1827
1828   sprintf (idbuf, "OPENPGP.%d", keyno+1);
1829   send_status_info (ctrl, "KEYPAIRINFO",
1830                     gripstr, 40,
1831                     idbuf, strlen (idbuf),
1832                     usage, strlen (usage),
1833                     NULL, (size_t)0);
1834
1835  leave:
1836 #endif /* GNUPG_MAJOR_VERSION > 1 */
1837
1838   return err;
1839 }
1840
1841
1842 /* Handle the LEARN command for OpenPGP.  */
1843 static gpg_error_t
1844 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1845 {
1846   (void)flags;
1847
1848   do_getattr (app, ctrl, "EXTCAP");
1849   do_getattr (app, ctrl, "DISP-NAME");
1850   do_getattr (app, ctrl, "DISP-LANG");
1851   do_getattr (app, ctrl, "DISP-SEX");
1852   do_getattr (app, ctrl, "PUBKEY-URL");
1853   do_getattr (app, ctrl, "LOGIN-DATA");
1854   do_getattr (app, ctrl, "KEY-FPR");
1855   if (app->appversion > 0x0100)
1856     do_getattr (app, ctrl, "KEY-TIME");
1857   do_getattr (app, ctrl, "CA-FPR");
1858   do_getattr (app, ctrl, "CHV-STATUS");
1859   do_getattr (app, ctrl, "SIG-COUNTER");
1860   if (app->app_local->extcap.kdf_do)
1861     do_getattr (app, ctrl, "KDF");
1862   if (app->app_local->extcap.has_button)
1863     {
1864       do_getattr (app, ctrl, "UIF-1");
1865       do_getattr (app, ctrl, "UIF-2");
1866       do_getattr (app, ctrl, "UIF-3");
1867     }
1868   if (app->app_local->extcap.private_dos)
1869     {
1870       do_getattr (app, ctrl, "PRIVATE-DO-1");
1871       do_getattr (app, ctrl, "PRIVATE-DO-2");
1872       if (app->did_chv2)
1873         do_getattr (app, ctrl, "PRIVATE-DO-3");
1874       if (app->did_chv3)
1875         do_getattr (app, ctrl, "PRIVATE-DO-4");
1876     }
1877   send_keypair_info (app, ctrl, 1);
1878   send_keypair_info (app, ctrl, 2);
1879   send_keypair_info (app, ctrl, 3);
1880   /* Note: We do not send the Cardholder Certificate, because that is
1881      relatively long and for OpenPGP applications not really needed.  */
1882   return 0;
1883 }
1884
1885
1886 /* Handle the READKEY command for OpenPGP.  On success a canonical
1887    encoded S-expression with the public key will get stored at PK and
1888    its length (for assertions) at PKLEN; the caller must release that
1889    buffer. On error PK and PKLEN are not changed and an error code is
1890    returned.  */
1891 static gpg_error_t
1892 do_readkey (app_t app, ctrl_t ctrl, const char *keyid, unsigned int flags,
1893             unsigned char **pk, size_t *pklen)
1894 {
1895   gpg_error_t err;
1896   int keyno;
1897   unsigned char *buf;
1898
1899   if (!strcmp (keyid, "OPENPGP.1"))
1900     keyno = 0;
1901   else if (!strcmp (keyid, "OPENPGP.2"))
1902     keyno = 1;
1903   else if (!strcmp (keyid, "OPENPGP.3"))
1904     keyno = 2;
1905   else
1906     return gpg_error (GPG_ERR_INV_ID);
1907
1908   err = get_public_key (app, keyno);
1909   if (err)
1910     return err;
1911
1912   buf = app->app_local->pk[keyno].key;
1913   if (!buf)
1914     return gpg_error (GPG_ERR_NO_PUBKEY);
1915
1916   if ((flags & APP_READKEY_FLAG_INFO))
1917     {
1918       err = send_keypair_info (app, ctrl, keyno+1);
1919       if (err)
1920         return err;
1921     }
1922
1923   if (pk && pklen)
1924     {
1925       *pklen = app->app_local->pk[keyno].keylen;
1926       *pk = xtrymalloc (*pklen);
1927       if (!*pk)
1928         {
1929           err = gpg_error_from_syserror ();
1930           *pklen = 0;
1931           return err;
1932         }
1933       memcpy (*pk, buf, *pklen);
1934     }
1935
1936   return 0;
1937 }
1938
1939 /* Read the standard certificate of an OpenPGP v2 card.  It is
1940    returned in a freshly allocated buffer with that address stored at
1941    CERT and the length of the certificate stored at CERTLEN.  CERTID
1942    needs to be set to "OPENPGP.3".  */
1943 static gpg_error_t
1944 do_readcert (app_t app, const char *certid,
1945              unsigned char **cert, size_t *certlen)
1946 {
1947 #if GNUPG_MAJOR_VERSION > 1
1948   gpg_error_t err;
1949   unsigned char *buffer;
1950   size_t buflen;
1951   void *relptr;
1952
1953   *cert = NULL;
1954   *certlen = 0;
1955   if (strcmp (certid, "OPENPGP.3"))
1956     return gpg_error (GPG_ERR_INV_ID);
1957   if (!app->app_local->extcap.is_v2)
1958     return gpg_error (GPG_ERR_NOT_FOUND);
1959
1960   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1961   if (!relptr)
1962     return gpg_error (GPG_ERR_NOT_FOUND);
1963
1964   if (!buflen)
1965     err = gpg_error (GPG_ERR_NOT_FOUND);
1966   else if (!(*cert = xtrymalloc (buflen)))
1967     err = gpg_error_from_syserror ();
1968   else
1969     {
1970       memcpy (*cert, buffer, buflen);
1971       *certlen = buflen;
1972       err  = 0;
1973     }
1974   xfree (relptr);
1975   return err;
1976 #else
1977   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1978 #endif
1979 }
1980
1981
1982 /* Decide if we use the pinpad of the reader for PIN input according
1983    to the user preference on the card, and the capability of the
1984    reader.  This routine is only called when the reader has pinpad.
1985    Returns 0 if we use pinpad, 1 otherwise.  */
1986 static int
1987 check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1988 {
1989   if (app->app_local->pinpad.specified == 0) /* No preference on card.  */
1990     {
1991       if (pininfo->fixedlen == 0) /* Reader has varlen capability.  */
1992         return 0;                 /* Then, use pinpad.  */
1993       else
1994         /*
1995          * Reader has limited capability, and it may not match PIN of
1996          * the card.
1997          */
1998         return 1;
1999     }
2000
2001   if (admin_pin)
2002     pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
2003   else
2004     pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
2005
2006   if (pininfo->fixedlen == 0    /* User requests disable pinpad.  */
2007       || pininfo->fixedlen < pininfo->minlen
2008       || pininfo->fixedlen > pininfo->maxlen
2009       /* Reader doesn't have the capability to input a PIN which
2010        * length is FIXEDLEN.  */)
2011     return 1;
2012
2013   return 0;
2014 }
2015
2016
2017 /* Return a string with information about the card for use in a
2018  * prompt.  Returns NULL on memory failure.  */
2019 static char *
2020 get_prompt_info (app_t app, int chvno, unsigned long sigcount, int remaining)
2021 {
2022   char *serial, *disp_name, *rembuf, *tmpbuf, *result;
2023
2024   serial = get_disp_serialno (app);
2025   if (!serial)
2026     return NULL;
2027
2028   disp_name = get_disp_name (app);
2029   if (chvno == 1)
2030     {
2031       /* TRANSLATORS: Put a \x1f right before a colon.  This can be
2032        * used by pinentry to nicely align the names and values.  Keep
2033        * the %s at the start and end of the string.  */
2034       result = xtryasprintf (_("%s"
2035                                "Number\x1f: %s%%0A"
2036                                "Holder\x1f: %s%%0A"
2037                                "Counter\x1f: %lu"
2038                                "%s"),
2039                              "\x1e",
2040                              serial,
2041                              disp_name? disp_name:"",
2042                              sigcount,
2043                              "");
2044     }
2045   else
2046     {
2047       result = xtryasprintf (_("%s"
2048                                "Number\x1f: %s%%0A"
2049                                "Holder\x1f: %s"
2050                                "%s"),
2051                              "\x1e",
2052                              serial,
2053                              disp_name? disp_name:"",
2054                              "");
2055     }
2056   xfree (disp_name);
2057   xfree (serial);
2058
2059   if (remaining != -1)
2060     {
2061       /* TRANSLATORS: This is the number of remaining attempts to
2062        * enter a PIN.  Use %%0A (double-percent,0A) for a linefeed. */
2063       rembuf = xtryasprintf (_("Remaining attempts: %d"), remaining);
2064       if (!rembuf)
2065         {
2066           xfree (result);
2067           return NULL;
2068         }
2069       tmpbuf = strconcat (result, "%0A%0A", rembuf, NULL);
2070       xfree (rembuf);
2071       if (!tmpbuf)
2072         {
2073           xfree (result);
2074           return NULL;
2075         }
2076       xfree (result);
2077       result = tmpbuf;
2078     }
2079
2080   return result;
2081 }
2082
2083 #define KDF_DATA_LENGTH_MIN  90
2084 #define KDF_DATA_LENGTH_MAX 110
2085
2086 /* Compute hash if KDF-DO is available.  CHVNO must be 0 for reset
2087    code, 1 or 2 for user pin and 3 for admin pin.
2088  */
2089 static gpg_error_t
2090 pin2hash_if_kdf (app_t app, int chvno, char *pinvalue, int *r_pinlen)
2091 {
2092   gpg_error_t err = 0;
2093   void *relptr = NULL;
2094   unsigned char *buffer;
2095   size_t buflen;
2096
2097   if (app->app_local->extcap.kdf_do
2098       && (relptr = get_one_do (app, 0x00F9, &buffer, &buflen, NULL))
2099       && buflen >= KDF_DATA_LENGTH_MIN && (buffer[2] == 0x03))
2100     {
2101       const char *salt;
2102       unsigned long s2k_count;
2103       char dek[32];
2104       int salt_index;
2105
2106       s2k_count = (((unsigned int)buffer[8] << 24)
2107                    | (buffer[9] << 16) | (buffer[10] << 8) | buffer[11]);
2108
2109       if (buflen == KDF_DATA_LENGTH_MIN)
2110         salt_index =14;
2111       else if (buflen == KDF_DATA_LENGTH_MAX)
2112         salt_index = (chvno==3 ? 34 : (chvno==0 ? 24 : 14));
2113       else
2114         {
2115           err = gpg_error (GPG_ERR_INV_DATA);
2116           goto leave;
2117         }
2118
2119       salt = &buffer[salt_index];
2120       err = gcry_kdf_derive (pinvalue, strlen (pinvalue),
2121                              GCRY_KDF_ITERSALTED_S2K,
2122                              DIGEST_ALGO_SHA256, salt, 8,
2123                              s2k_count, sizeof (dek), dek);
2124       if (!err)
2125         {
2126           /* pinvalue has a buffer of MAXLEN_PIN+1, 32 is OK.  */
2127           *r_pinlen = 32;
2128           memcpy (pinvalue, dek, *r_pinlen);
2129           wipememory (dek, *r_pinlen);
2130         }
2131    }
2132   else
2133     *r_pinlen = strlen (pinvalue);
2134
2135  leave:
2136   xfree (relptr);
2137   return err;
2138 }
2139
2140
2141 /* Verify a CHV either using the pinentry or if possible by
2142    using a pinpad.  PINCB and PINCB_ARG describe the usual callback
2143    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
2144    used with CHV1.  PINVALUE is the address of a pointer which will
2145    receive a newly allocated block with the actual PIN (this is useful
2146    in case that PIN shall be used for another verify operation).  The
2147    caller needs to free this value.  If the function returns with
2148    success and NULL is stored at PINVALUE, the caller should take this
2149    as an indication that the pinpad has been used.
2150    */
2151 static gpg_error_t
2152 verify_a_chv (app_t app,
2153               gpg_error_t (*pincb)(void*, const char *, char **),
2154               void *pincb_arg, int chvno, unsigned long sigcount,
2155               char **pinvalue, int *pinlen)
2156 {
2157   int rc = 0;
2158   char *prompt_buffer = NULL;
2159   const char *prompt;
2160   pininfo_t pininfo;
2161   int minlen = 6;
2162   int remaining;
2163
2164   log_assert (chvno == 1 || chvno == 2);
2165
2166   *pinvalue = NULL;
2167   *pinlen = 0;
2168
2169   remaining = get_remaining_tries (app, 0);
2170   if (remaining == -1)
2171     return gpg_error (GPG_ERR_CARD);
2172
2173   if (chvno == 2 && app->app_local->flags.def_chv2)
2174     {
2175       /* Special case for def_chv2 mechanism. */
2176       if (opt.verbose)
2177         log_info (_("using default PIN as %s\n"), "CHV2");
2178       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
2179       if (rc)
2180         {
2181           /* Verification of CHV2 with the default PIN failed,
2182              although the card pretends to have the default PIN set as
2183              CHV2.  We better disable the def_chv2 flag now. */
2184           log_info (_("failed to use default PIN as %s: %s"
2185                       " - disabling further default use\n"),
2186                     "CHV2", gpg_strerror (rc));
2187           app->app_local->flags.def_chv2 = 0;
2188         }
2189       return rc;
2190     }
2191
2192   memset (&pininfo, 0, sizeof pininfo);
2193   pininfo.fixedlen = -1;
2194   pininfo.minlen = minlen;
2195
2196   {
2197     const char *firstline = _("||Please unlock the card");
2198     char *infoblock = get_prompt_info (app, chvno, sigcount,
2199                                        remaining < 3? remaining : -1);
2200
2201     prompt_buffer = strconcat (firstline, "%0A%0A", infoblock, NULL);
2202     if (prompt_buffer)
2203       prompt = prompt_buffer;
2204     else
2205       prompt = firstline;  /* ENOMEM fallback.  */
2206
2207     xfree (infoblock);
2208   }
2209
2210   if (!opt.disable_pinpad
2211       && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
2212       && !check_pinpad_request (app, &pininfo, 0))
2213     {
2214       /* The reader supports the verify command through the pinpad.
2215          Note that the pincb appends a text to the prompt telling the
2216          user to use the pinpad. */
2217       rc = pincb (pincb_arg, prompt, NULL);
2218       prompt = NULL;
2219       xfree (prompt_buffer);
2220       prompt_buffer = NULL;
2221       if (rc)
2222         {
2223           log_info (_("PIN callback returned error: %s\n"),
2224                     gpg_strerror (rc));
2225           return rc;
2226         }
2227       rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
2228       /* Dismiss the prompt. */
2229       pincb (pincb_arg, NULL, NULL);
2230
2231       log_assert (!*pinvalue);
2232     }
2233   else
2234     {
2235       /* The reader has no pinpad or we don't want to use it. */
2236       rc = pincb (pincb_arg, prompt, pinvalue);
2237       prompt = NULL;
2238       xfree (prompt_buffer);
2239       prompt_buffer = NULL;
2240       if (rc)
2241         {
2242           log_info (_("PIN callback returned error: %s\n"),
2243                     gpg_strerror (rc));
2244           return rc;
2245         }
2246
2247       if (strlen (*pinvalue) < minlen)
2248         {
2249           log_error (_("PIN for CHV%d is too short;"
2250                        " minimum length is %d\n"), chvno, minlen);
2251           xfree (*pinvalue);
2252           *pinvalue = NULL;
2253           return gpg_error (GPG_ERR_BAD_PIN);
2254         }
2255
2256       rc = pin2hash_if_kdf (app, chvno, *pinvalue, pinlen);
2257       if (!rc)
2258         rc = iso7816_verify (app->slot, 0x80+chvno, *pinvalue, *pinlen);
2259     }
2260
2261   if (rc)
2262     {
2263       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
2264       xfree (*pinvalue);
2265       *pinvalue = NULL;
2266       flush_cache_after_error (app);
2267     }
2268
2269   return rc;
2270 }
2271
2272
2273 /* Verify CHV2 if required.  Depending on the configuration of the
2274    card CHV1 will also be verified. */
2275 static gpg_error_t
2276 verify_chv2 (app_t app,
2277              gpg_error_t (*pincb)(void*, const char *, char **),
2278              void *pincb_arg)
2279 {
2280   int rc;
2281   char *pinvalue;
2282   int pinlen;
2283
2284   if (app->did_chv2)
2285     return 0;  /* We already verified CHV2.  */
2286
2287   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue, &pinlen);
2288   if (rc)
2289     return rc;
2290   app->did_chv2 = 1;
2291
2292   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
2293     {
2294       /* For convenience we verify CHV1 here too.  We do this only if
2295          the card is not configured to require a verification before
2296          each CHV1 controlled operation (force_chv1) and if we are not
2297          using the pinpad (PINVALUE == NULL). */
2298       rc = iso7816_verify (app->slot, 0x81, pinvalue, pinlen);
2299       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2300         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2301       if (rc)
2302         {
2303           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2304           flush_cache_after_error (app);
2305         }
2306       else
2307         app->did_chv1 = 1;
2308     }
2309
2310   xfree (pinvalue);
2311
2312   return rc;
2313 }
2314
2315
2316 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
2317    current sdtate of the card.  */
2318 static gpg_error_t
2319 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
2320 {
2321   int remaining;
2322   char *prompt;
2323   char *infoblock;
2324
2325   *r_prompt = NULL;
2326
2327   remaining = get_remaining_tries (app, 1);
2328   if (remaining == -1)
2329     return gpg_error (GPG_ERR_CARD);
2330   if (!remaining)
2331     {
2332       log_info (_("card is permanently locked!\n"));
2333       return gpg_error (GPG_ERR_BAD_PIN);
2334     }
2335
2336   log_info (ngettext("%d Admin PIN attempt remaining before card"
2337                      " is permanently locked\n",
2338                      "%d Admin PIN attempts remaining before card"
2339                      " is permanently locked\n",
2340                      remaining), remaining);
2341
2342   infoblock = get_prompt_info (app, 3, 0, remaining < 3? remaining : -1);
2343
2344   /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
2345      the start of the string.  Use %0A (single percent) for a linefeed.  */
2346   prompt = strconcat (_("|A|Please enter the Admin PIN"),
2347                       "%0A%0A", infoblock, NULL);
2348   xfree (infoblock);
2349   if (!prompt)
2350     return gpg_error_from_syserror ();
2351
2352   *r_prompt = prompt;
2353   return 0;
2354 }
2355
2356
2357 /* Verify CHV3 if required. */
2358 static gpg_error_t
2359 verify_chv3 (app_t app,
2360              gpg_error_t (*pincb)(void*, const char *, char **),
2361              void *pincb_arg)
2362 {
2363   int rc = 0;
2364
2365 #if GNUPG_MAJOR_VERSION != 1
2366   if (!opt.allow_admin)
2367     {
2368       log_info (_("access to admin commands is not configured\n"));
2369       return gpg_error (GPG_ERR_EACCES);
2370     }
2371 #endif
2372
2373   if (!app->did_chv3)
2374     {
2375       pininfo_t pininfo;
2376       int minlen = 8;
2377       char *prompt;
2378
2379       memset (&pininfo, 0, sizeof pininfo);
2380       pininfo.fixedlen = -1;
2381       pininfo.minlen = minlen;
2382
2383       rc = build_enter_admin_pin_prompt (app, &prompt);
2384       if (rc)
2385         return rc;
2386
2387       if (!opt.disable_pinpad
2388           && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
2389           && !check_pinpad_request (app, &pininfo, 1))
2390         {
2391           /* The reader supports the verify command through the pinpad. */
2392           rc = pincb (pincb_arg, prompt, NULL);
2393           xfree (prompt);
2394           prompt = NULL;
2395           if (rc)
2396             {
2397               log_info (_("PIN callback returned error: %s\n"),
2398                         gpg_strerror (rc));
2399               return rc;
2400             }
2401           rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
2402           /* Dismiss the prompt. */
2403           pincb (pincb_arg, NULL, NULL);
2404         }
2405       else
2406         {
2407           char *pinvalue;
2408           int pinlen;
2409
2410           rc = pincb (pincb_arg, prompt, &pinvalue);
2411           xfree (prompt);
2412           prompt = NULL;
2413           if (rc)
2414             {
2415               log_info (_("PIN callback returned error: %s\n"),
2416                         gpg_strerror (rc));
2417               return rc;
2418             }
2419
2420           if (strlen (pinvalue) < minlen)
2421             {
2422               log_error (_("PIN for CHV%d is too short;"
2423                            " minimum length is %d\n"), 3, minlen);
2424               xfree (pinvalue);
2425               return gpg_error (GPG_ERR_BAD_PIN);
2426             }
2427
2428           rc = pin2hash_if_kdf (app, 3, pinvalue, &pinlen);
2429           if (!rc)
2430             rc = iso7816_verify (app->slot, 0x83, pinvalue, pinlen);
2431           xfree (pinvalue);
2432         }
2433
2434       if (rc)
2435         {
2436           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
2437           flush_cache_after_error (app);
2438           return rc;
2439         }
2440       app->did_chv3 = 1;
2441     }
2442   return rc;
2443 }
2444
2445
2446 /* Handle the SETATTR operation. All arguments are already basically
2447    checked. */
2448 static gpg_error_t
2449 do_setattr (app_t app, const char *name,
2450             gpg_error_t (*pincb)(void*, const char *, char **),
2451             void *pincb_arg,
2452             const unsigned char *value, size_t valuelen)
2453 {
2454   gpg_error_t rc;
2455   int idx;
2456   static struct {
2457     const char *name;
2458     int tag;
2459     int flush_tag;  /* The tag which needs to be flushed or 0. */
2460     int need_chv;
2461     int special;
2462     unsigned int need_v2:1;
2463   } table[] = {
2464     { "DISP-NAME",    0x005B, 0,      3 },
2465     { "LOGIN-DATA",   0x005E, 0,      3, 2 },
2466     { "DISP-LANG",    0x5F2D, 0,      3 },
2467     { "DISP-SEX",     0x5F35, 0,      3 },
2468     { "PUBKEY-URL",   0x5F50, 0,      3 },
2469     { "CHV-STATUS-1", 0x00C4, 0,      3, 1 },
2470     { "CA-FPR-1",     0x00CA, 0x00C6, 3 },
2471     { "CA-FPR-2",     0x00CB, 0x00C6, 3 },
2472     { "CA-FPR-3",     0x00CC, 0x00C6, 3 },
2473     { "PRIVATE-DO-1", 0x0101, 0,      2 },
2474     { "PRIVATE-DO-2", 0x0102, 0,      3 },
2475     { "PRIVATE-DO-3", 0x0103, 0,      2 },
2476     { "PRIVATE-DO-4", 0x0104, 0,      3 },
2477     { "CERT-3",       0x7F21, 0,      3, 0, 1 },
2478     { "SM-KEY-ENC",   0x00D1, 0,      3, 0, 1 },
2479     { "SM-KEY-MAC",   0x00D2, 0,      3, 0, 1 },
2480     { "KEY-ATTR",     0,      0,      0, 3, 1 },
2481     { "AESKEY",       0x00D5, 0,      3, 0, 1 },
2482     { "UIF-1",        0x00D6, 0,      3, 5, 1 },
2483     { "UIF-2",        0x00D7, 0,      3, 5, 1 },
2484     { "UIF-3",        0x00D8, 0,      3, 5, 1 },
2485     { "KDF",          0x00F9, 0,      3, 4, 1 },
2486     { NULL, 0 }
2487   };
2488   int exmode;
2489
2490   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
2491     ;
2492   if (!table[idx].name)
2493     return gpg_error (GPG_ERR_INV_NAME);
2494   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
2495     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
2496
2497   if (table[idx].special == 5 && app->app_local->extcap.has_button == 0)
2498     return gpg_error (GPG_ERR_INV_OBJ);
2499
2500   if (table[idx].special == 3)
2501     return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
2502
2503   switch (table[idx].need_chv)
2504     {
2505     case 2:
2506       rc = verify_chv2 (app, pincb, pincb_arg);
2507       break;
2508     case 3:
2509       rc = verify_chv3 (app, pincb, pincb_arg);
2510       break;
2511     default:
2512       rc = 0;
2513     }
2514   if (rc)
2515     return rc;
2516
2517   /* Flush the cache before writing it, so that the next get operation
2518      will reread the data from the card and thus get synced in case of
2519      errors (e.g. data truncated by the card). */
2520   flush_cache_item (app, table[idx].flush_tag? table[idx].flush_tag
2521                     /* */                    : table[idx].tag);
2522
2523   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
2524     exmode = 1;    /* Use extended length w/o a limit.  */
2525   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
2526     exmode = -254; /* Command chaining with max. 254 bytes.  */
2527   else
2528     exmode = 0;
2529   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
2530   if (rc)
2531     log_error ("failed to set '%s': %s\n", table[idx].name, gpg_strerror (rc));
2532
2533   if (table[idx].special == 1)
2534     app->force_chv1 = (valuelen && *value == 0);
2535   else if (table[idx].special == 2)
2536     parse_login_data (app);
2537   else if (table[idx].special == 4)
2538     {
2539       app->did_chv1 = 0;
2540       app->did_chv2 = 0;
2541       app->did_chv3 = 0;
2542     }
2543
2544   return rc;
2545 }
2546
2547
2548 /* Handle the WRITECERT command for OpenPGP.  This writes the standard
2549  * certificate to the card; CERTID needs to be set to "OPENPGP.3".
2550  * PINCB and PINCB_ARG are the usual arguments for the pinentry
2551  * callback.  */
2552 static gpg_error_t
2553 do_writecert (app_t app, ctrl_t ctrl,
2554               const char *certidstr,
2555               gpg_error_t (*pincb)(void*, const char *, char **),
2556               void *pincb_arg,
2557               const unsigned char *certdata, size_t certdatalen)
2558 {
2559   (void)ctrl;
2560 #if GNUPG_MAJOR_VERSION > 1
2561   if (strcmp (certidstr, "OPENPGP.3"))
2562     return gpg_error (GPG_ERR_INV_ID);
2563   if (!certdata || !certdatalen)
2564     return gpg_error (GPG_ERR_INV_ARG);
2565   if (!app->app_local->extcap.is_v2)
2566     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2567   if (certdatalen > app->app_local->extcap.max_certlen_3)
2568     return gpg_error (GPG_ERR_TOO_LARGE);
2569   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
2570 #else
2571   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2572 #endif
2573 }
2574
2575
2576 static gpg_error_t
2577 clear_chv_status (app_t app, int chvno)
2578 {
2579   unsigned char apdu[4];
2580   gpg_error_t err;
2581
2582   if (!app->app_local->extcap.is_v2)
2583     return GPG_ERR_UNSUPPORTED_OPERATION;
2584
2585   apdu[0] = 0x00;
2586   apdu[1] = ISO7816_VERIFY;
2587   apdu[2] = 0xff;
2588   apdu[3] = 0x80+chvno;
2589
2590   err = iso7816_apdu_direct (app->slot, apdu, 4, 0, NULL, NULL, NULL);
2591   if (err)
2592     {
2593       if (gpg_err_code (err) == GPG_ERR_INV_VALUE)
2594         err = gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
2595       return err;
2596     }
2597
2598   if (chvno == 1)
2599     {
2600       apdu[3]++;
2601       err = iso7816_apdu_direct (app->slot, apdu, 4, 0, NULL, NULL, NULL);
2602       app->did_chv1 = app->did_chv2 = 0;
2603     }
2604   else if (chvno == 2)
2605     app->did_chv2 = 0;
2606   else if (chvno == 3)
2607     app->did_chv3 = 0;
2608
2609   return err;
2610 }
2611
2612
2613 /* Handle the PASSWD command.  The following combinations are
2614    possible:
2615
2616     Flags  CHVNO Vers.  Description
2617     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
2618     RESET    1   2      Verify PW3 and set a new PW1.
2619     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
2620     RESET    2   2      Verify PW3 and set a new Reset Code.
2621     RESET    3   any    Returns GPG_ERR_INV_ID.
2622      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
2623      -       1   2      Verify PW1 and set a new PW1.
2624      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
2625      -       2   2      Verify Reset Code and set a new PW1.
2626      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
2627
2628    The CHVNO can be prefixed with "OPENPGP.".
2629  */
2630 static gpg_error_t
2631 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
2632                unsigned int flags,
2633                gpg_error_t (*pincb)(void*, const char *, char **),
2634                void *pincb_arg)
2635 {
2636   int rc = 0;
2637   int chvno;
2638   char *resetcode = NULL;
2639   char *oldpinvalue = NULL;
2640   char *pinvalue = NULL;
2641   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2642   int set_resetcode = 0;
2643   pininfo_t pininfo;
2644   int use_pinpad = 0;
2645   int minlen = 6;
2646   int pinlen0 = 0;
2647   int pinlen = 0;
2648
2649   (void)ctrl;
2650
2651   if (digitp (chvnostr))
2652     chvno = atoi (chvnostr);
2653   else if (!ascii_strcasecmp (chvnostr, "OPENPGP.1"))
2654     chvno = 1;
2655   else if (!ascii_strcasecmp (chvnostr, "OPENPGP.2"))
2656     chvno = 2;
2657   else if (!ascii_strcasecmp (chvnostr, "OPENPGP.3"))
2658     chvno = 3;
2659   else
2660     return gpg_error (GPG_ERR_INV_ID);
2661
2662   memset (&pininfo, 0, sizeof pininfo);
2663   pininfo.fixedlen = -1;
2664   pininfo.minlen = minlen;
2665
2666   if ((flags & APP_CHANGE_FLAG_CLEAR))
2667     return clear_chv_status (app, chvno);
2668
2669   if (reset_mode && chvno == 3)
2670     {
2671       rc = gpg_error (GPG_ERR_INV_ID);
2672       goto leave;
2673     }
2674
2675   if (!app->app_local->extcap.is_v2)
2676     {
2677       /* Version 1 cards.  */
2678
2679       if (reset_mode || chvno == 3)
2680         {
2681           /* We always require that the PIN is entered. */
2682           app->did_chv3 = 0;
2683           rc = verify_chv3 (app, pincb, pincb_arg);
2684           if (rc)
2685             goto leave;
2686         }
2687       else if (chvno == 1 || chvno == 2)
2688         {
2689           /* On a v1.x card CHV1 and CVH2 should always have the same
2690              value, thus we enforce it here.  */
2691           int save_force = app->force_chv1;
2692
2693           app->force_chv1 = 0;
2694           app->did_chv1 = 0;
2695           app->did_chv2 = 0;
2696           rc = verify_chv2 (app, pincb, pincb_arg);
2697           app->force_chv1 = save_force;
2698           if (rc)
2699             goto leave;
2700         }
2701       else
2702         {
2703           rc = gpg_error (GPG_ERR_INV_ID);
2704           goto leave;
2705         }
2706     }
2707   else
2708     {
2709       /* Version 2 cards.  */
2710
2711       if (!opt.disable_pinpad
2712           && !iso7816_check_pinpad (app->slot,
2713                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2714           && !check_pinpad_request (app, &pininfo, chvno == 3))
2715         use_pinpad = 1;
2716
2717       if (reset_mode)
2718         {
2719           /* To reset a PIN the Admin PIN is required. */
2720           use_pinpad = 0;
2721           app->did_chv3 = 0;
2722           rc = verify_chv3 (app, pincb, pincb_arg);
2723           if (rc)
2724             goto leave;
2725
2726           if (chvno == 2)
2727             set_resetcode = 1;
2728         }
2729       else if (chvno == 1 || chvno == 3)
2730         {
2731           if (!use_pinpad)
2732             {
2733               char *promptbuf = NULL;
2734               const char *prompt;
2735
2736               if (chvno == 3)
2737                 {
2738                   minlen = 8;
2739                   rc = build_enter_admin_pin_prompt (app, &promptbuf);
2740                   if (rc)
2741                     goto leave;
2742                   prompt = promptbuf;
2743                 }
2744               else
2745                 prompt = _("||Please enter the PIN");
2746               rc = pincb (pincb_arg, prompt, &oldpinvalue);
2747               xfree (promptbuf);
2748               promptbuf = NULL;
2749               if (rc)
2750                 {
2751                   log_info (_("PIN callback returned error: %s\n"),
2752                             gpg_strerror (rc));
2753                   goto leave;
2754                 }
2755
2756               if (strlen (oldpinvalue) < minlen)
2757                 {
2758                   log_info (_("PIN for CHV%d is too short;"
2759                               " minimum length is %d\n"), chvno, minlen);
2760                   rc = gpg_error (GPG_ERR_BAD_PIN);
2761                   goto leave;
2762                 }
2763             }
2764         }
2765       else if (chvno == 2)
2766         {
2767           /* There is no PW2 for v2 cards.  We use this condition to
2768              allow a PW reset using the Reset Code.  */
2769           void *relptr;
2770           unsigned char *value;
2771           size_t valuelen;
2772           int remaining;
2773
2774           use_pinpad = 0;
2775           minlen = 8;
2776           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2777           if (!relptr || valuelen < 7)
2778             {
2779               log_error (_("error retrieving CHV status from card\n"));
2780               xfree (relptr);
2781               rc = gpg_error (GPG_ERR_CARD);
2782               goto leave;
2783             }
2784           remaining = value[5];
2785           xfree (relptr);
2786           if (!remaining)
2787             {
2788               log_error (_("Reset Code not or not anymore available\n"));
2789               rc = gpg_error (GPG_ERR_BAD_PIN);
2790               goto leave;
2791             }
2792
2793           rc = pincb (pincb_arg,
2794                       _("||Please enter the Reset Code for the card"),
2795                       &resetcode);
2796           if (rc)
2797             {
2798               log_info (_("PIN callback returned error: %s\n"),
2799                         gpg_strerror (rc));
2800               goto leave;
2801             }
2802           if (strlen (resetcode) < minlen)
2803             {
2804               log_info (_("Reset Code is too short; minimum length is %d\n"),
2805                         minlen);
2806               rc = gpg_error (GPG_ERR_BAD_PIN);
2807               goto leave;
2808             }
2809         }
2810       else
2811         {
2812           rc = gpg_error (GPG_ERR_INV_ID);
2813           goto leave;
2814         }
2815     }
2816
2817   if (chvno == 3)
2818     app->did_chv3 = 0;
2819   else
2820     app->did_chv1 = app->did_chv2 = 0;
2821
2822   if (!use_pinpad)
2823     {
2824       /* TRANSLATORS: Do not translate the "|*|" prefixes but
2825          keep it at the start of the string.  We need this elsewhere
2826          to get some infos on the string. */
2827       rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2828                   chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2829                   &pinvalue);
2830       if (rc || pinvalue == NULL)
2831         {
2832           log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2833           goto leave;
2834         }
2835     }
2836
2837
2838   if (resetcode)
2839     {
2840       char *buffer;
2841
2842       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2843       if (!buffer)
2844         rc = gpg_error_from_syserror ();
2845       else
2846         {
2847           strcpy (buffer, resetcode);
2848           rc = pin2hash_if_kdf (app, 0, buffer, &pinlen0);
2849           if (!rc)
2850             {
2851               strcpy (buffer+pinlen0, pinvalue);
2852               rc = pin2hash_if_kdf (app, 0, buffer+pinlen0, &pinlen);
2853             }
2854           if (!rc)
2855             rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2856                                                       buffer, pinlen0+pinlen);
2857           wipememory (buffer, pinlen0 + pinlen);
2858           xfree (buffer);
2859         }
2860     }
2861   else if (set_resetcode)
2862     {
2863       if (strlen (pinvalue) < 8)
2864         {
2865           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2866           rc = gpg_error (GPG_ERR_BAD_PIN);
2867         }
2868       else
2869         {
2870           rc = pin2hash_if_kdf (app, 0, pinvalue, &pinlen);
2871           if (!rc)
2872             rc = iso7816_put_data (app->slot, 0, 0xD3, pinvalue, pinlen);
2873         }
2874     }
2875   else if (reset_mode)
2876     {
2877       rc = pin2hash_if_kdf (app, 1, pinvalue, &pinlen);
2878       if (!rc)
2879         rc = iso7816_reset_retry_counter (app->slot, 0x81, pinvalue, pinlen);
2880       if (!rc && !app->app_local->extcap.is_v2)
2881         rc = iso7816_reset_retry_counter (app->slot, 0x82, pinvalue, pinlen);
2882     }
2883   else if (!app->app_local->extcap.is_v2)
2884     {
2885       /* Version 1 cards.  */
2886       if (chvno == 1 || chvno == 2)
2887         {
2888           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2889                                               pinvalue, strlen (pinvalue));
2890           if (!rc)
2891             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2892                                                 pinvalue, strlen (pinvalue));
2893         }
2894       else /* CHVNO == 3 */
2895         {
2896           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2897                                               pinvalue, strlen (pinvalue));
2898         }
2899     }
2900   else
2901     {
2902       /* Version 2 cards.  */
2903       assert (chvno == 1 || chvno == 3);
2904
2905       if (use_pinpad)
2906         {
2907           rc = pincb (pincb_arg,
2908                       chvno == 3 ?
2909                       _("||Please enter the Admin PIN and New Admin PIN") :
2910                       _("||Please enter the PIN and New PIN"), NULL);
2911           if (rc)
2912             {
2913               log_info (_("PIN callback returned error: %s\n"),
2914                         gpg_strerror (rc));
2915               goto leave;
2916             }
2917           rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
2918                                                  &pininfo);
2919           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2920         }
2921       else
2922         {
2923           rc = pin2hash_if_kdf (app, chvno, oldpinvalue, &pinlen0);
2924           if (!rc)
2925             rc = pin2hash_if_kdf (app, chvno, pinvalue, &pinlen);
2926           if (!rc)
2927             rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2928                                                 oldpinvalue, pinlen0,
2929                                                 pinvalue, pinlen);
2930         }
2931     }
2932
2933   if (pinvalue)
2934     {
2935       wipememory (pinvalue, pinlen);
2936       xfree (pinvalue);
2937     }
2938   if (rc)
2939     flush_cache_after_error (app);
2940
2941  leave:
2942   if (resetcode)
2943     {
2944       wipememory (resetcode, strlen (resetcode));
2945       xfree (resetcode);
2946     }
2947   if (oldpinvalue)
2948     {
2949       wipememory (oldpinvalue, pinlen0);
2950       xfree (oldpinvalue);
2951     }
2952   return rc;
2953 }
2954
2955
2956 /* Check whether a key already exists.  KEYIDX is the index of the key
2957    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2958    error returned if the key already exists.  The flag GENERATING is
2959    only used to print correct messages. */
2960 static gpg_error_t
2961 does_key_exist (app_t app, int keyidx, int generating, int force)
2962 {
2963   const unsigned char *fpr;
2964   unsigned char *buffer;
2965   size_t buflen, n;
2966   int i;
2967
2968   assert (keyidx >=0 && keyidx <= 2);
2969
2970   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2971     {
2972       log_error (_("error reading application data\n"));
2973       return gpg_error (GPG_ERR_GENERAL);
2974     }
2975   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2976   if (!fpr || n < 60)
2977     {
2978       log_error (_("error reading fingerprint DO\n"));
2979       xfree (buffer);
2980       return gpg_error (GPG_ERR_GENERAL);
2981     }
2982   fpr += 20*keyidx;
2983   for (i=0; i < 20 && !fpr[i]; i++)
2984     ;
2985   xfree (buffer);
2986   if (i!=20 && !force)
2987     {
2988       log_error (_("key already exists\n"));
2989       return gpg_error (GPG_ERR_EEXIST);
2990     }
2991   else if (i!=20)
2992     log_info (_("existing key will be replaced\n"));
2993   else if (generating)
2994     log_info (_("generating new key\n"));
2995   else
2996     log_info (_("writing new key\n"));
2997   return 0;
2998 }
2999
3000
3001 /* Create a TLV tag and value and store it at BUFFER.  Return the length
3002    of tag and length.  A LENGTH greater than 65535 is truncated. */
3003 static size_t
3004 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
3005 {
3006   unsigned char *p = buffer;
3007
3008   assert (tag <= 0xffff);
3009   if ( tag > 0xff )
3010     *p++ = tag >> 8;
3011   *p++ = tag;
3012   if (length < 128)
3013     *p++ = length;
3014   else if (length < 256)
3015     {
3016       *p++ = 0x81;
3017       *p++ = length;
3018     }
3019   else
3020     {
3021       if (length > 0xffff)
3022         length = 0xffff;
3023       *p++ = 0x82;
3024       *p++ = length >> 8;
3025       *p++ = length;
3026     }
3027
3028   return p - buffer;
3029 }
3030
3031
3032 static gpg_error_t
3033 build_privkey_template (app_t app, int keyno,
3034                         const unsigned char *rsa_n, size_t rsa_n_len,
3035                         const unsigned char *rsa_e, size_t rsa_e_len,
3036                         const unsigned char *rsa_p, size_t rsa_p_len,
3037                         const unsigned char *rsa_q, size_t rsa_q_len,
3038                         const unsigned char *rsa_u, size_t rsa_u_len,
3039                         const unsigned char *rsa_dp, size_t rsa_dp_len,
3040                         const unsigned char *rsa_dq, size_t rsa_dq_len,
3041                         unsigned char **result, size_t *resultlen)
3042 {
3043   size_t rsa_e_reqlen;
3044   unsigned char privkey[7*(1+3+3)];
3045   size_t privkey_len;
3046   unsigned char exthdr[2+2+3];
3047   size_t exthdr_len;
3048   unsigned char suffix[2+3];
3049   size_t suffix_len;
3050   unsigned char *tp;
3051   size_t datalen;
3052   unsigned char *template;
3053   size_t template_size;
3054
3055   *result = NULL;
3056   *resultlen = 0;
3057
3058   switch (app->app_local->keyattr[keyno].rsa.format)
3059     {
3060     case RSA_STD:
3061     case RSA_STD_N:
3062     case RSA_CRT:
3063     case RSA_CRT_N:
3064       break;
3065
3066     default:
3067       return gpg_error (GPG_ERR_INV_VALUE);
3068     }
3069
3070   /* Get the required length for E. Rounded up to the nearest byte  */
3071   rsa_e_reqlen = (app->app_local->keyattr[keyno].rsa.e_bits + 7) / 8;
3072   assert (rsa_e_len <= rsa_e_reqlen);
3073
3074   /* Build the 7f48 cardholder private key template.  */
3075   datalen = 0;
3076   tp = privkey;
3077
3078   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
3079   datalen += rsa_e_reqlen;
3080
3081   tp += add_tlv (tp, 0x92, rsa_p_len);
3082   datalen += rsa_p_len;
3083
3084   tp += add_tlv (tp, 0x93, rsa_q_len);
3085   datalen += rsa_q_len;
3086
3087   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
3088       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3089     {
3090       tp += add_tlv (tp, 0x94, rsa_u_len);
3091       datalen += rsa_u_len;
3092       tp += add_tlv (tp, 0x95, rsa_dp_len);
3093       datalen += rsa_dp_len;
3094       tp += add_tlv (tp, 0x96, rsa_dq_len);
3095       datalen += rsa_dq_len;
3096     }
3097
3098   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
3099       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3100     {
3101       tp += add_tlv (tp, 0x97, rsa_n_len);
3102       datalen += rsa_n_len;
3103     }
3104   privkey_len = tp - privkey;
3105
3106   /* Build the extended header list without the private key template.  */
3107   tp = exthdr;
3108   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
3109   *tp++ = 0;
3110   tp += add_tlv (tp, 0x7f48, privkey_len);
3111   exthdr_len = tp - exthdr;
3112
3113   /* Build the 5f48 suffix of the data.  */
3114   tp = suffix;
3115   tp += add_tlv (tp, 0x5f48, datalen);
3116   suffix_len = tp - suffix;
3117
3118   /* Now concatenate everything.  */
3119   template_size = (1 + 3   /* 0x4d and len. */
3120                    + exthdr_len
3121                    + privkey_len
3122                    + suffix_len
3123                    + datalen);
3124   tp = template = xtrymalloc_secure (template_size);
3125   if (!template)
3126     return gpg_error_from_syserror ();
3127
3128   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
3129   memcpy (tp, exthdr, exthdr_len);
3130   tp += exthdr_len;
3131   memcpy (tp, privkey, privkey_len);
3132   tp += privkey_len;
3133   memcpy (tp, suffix, suffix_len);
3134   tp += suffix_len;
3135
3136   memcpy (tp, rsa_e, rsa_e_len);
3137   if (rsa_e_len < rsa_e_reqlen)
3138     {
3139       /* Right justify E. */
3140       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
3141       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
3142     }
3143   tp += rsa_e_reqlen;
3144
3145   memcpy (tp, rsa_p, rsa_p_len);
3146   tp += rsa_p_len;
3147
3148   memcpy (tp, rsa_q, rsa_q_len);
3149   tp += rsa_q_len;
3150
3151   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
3152       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3153     {
3154       memcpy (tp, rsa_u, rsa_u_len);
3155       tp += rsa_u_len;
3156       memcpy (tp, rsa_dp, rsa_dp_len);
3157       tp += rsa_dp_len;
3158       memcpy (tp, rsa_dq, rsa_dq_len);
3159       tp += rsa_dq_len;
3160     }
3161
3162   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
3163       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3164     {
3165       memcpy (tp, rsa_n, rsa_n_len);
3166       tp += rsa_n_len;
3167     }
3168
3169   /* Sanity check.  We don't know the exact length because we
3170      allocated 3 bytes for the first length header.  */
3171   assert (tp - template <= template_size);
3172
3173   *result = template;
3174   *resultlen = tp - template;
3175   return 0;
3176 }
3177
3178 static gpg_error_t
3179 build_ecc_privkey_template (app_t app, int keyno,
3180                             const unsigned char *ecc_d, size_t ecc_d_len,
3181                             const unsigned char *ecc_q, size_t ecc_q_len,
3182                             unsigned char **result, size_t *resultlen)
3183 {
3184   unsigned char privkey[2+2];
3185   size_t privkey_len;
3186   unsigned char exthdr[2+2+1];
3187   size_t exthdr_len;
3188   unsigned char suffix[2+1];
3189   size_t suffix_len;
3190   unsigned char *tp;
3191   size_t datalen;
3192   unsigned char *template;
3193   size_t template_size;
3194   int pubkey_required;
3195
3196   pubkey_required = !!(app->app_local->keyattr[keyno].ecc.flags
3197                        & ECC_FLAG_PUBKEY);
3198
3199   *result = NULL;
3200   *resultlen = 0;
3201
3202   /* Build the 7f48 cardholder private key template.  */
3203   datalen = 0;
3204   tp = privkey;
3205
3206   tp += add_tlv (tp, 0x92, ecc_d_len);
3207   datalen += ecc_d_len;
3208
3209   if (pubkey_required)
3210     {
3211       tp += add_tlv (tp, 0x99, ecc_q_len);
3212       datalen += ecc_q_len;
3213     }
3214
3215   privkey_len = tp - privkey;
3216
3217
3218   /* Build the extended header list without the private key template.  */
3219   tp = exthdr;
3220   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
3221   *tp++ = 0;
3222   tp += add_tlv (tp, 0x7f48, privkey_len);
3223   exthdr_len = tp - exthdr;
3224
3225   /* Build the 5f48 suffix of the data.  */
3226   tp = suffix;
3227   tp += add_tlv (tp, 0x5f48, datalen);
3228   suffix_len = tp - suffix;
3229
3230   /* Now concatenate everything.  */
3231   template_size = (1 + 1   /* 0x4d and len. */
3232                    + exthdr_len
3233                    + privkey_len
3234                    + suffix_len
3235                    + datalen);
3236   if (exthdr_len + privkey_len + suffix_len + datalen >= 128)
3237     template_size++;
3238   tp = template = xtrymalloc_secure (template_size);
3239   if (!template)
3240     return gpg_error_from_syserror ();
3241
3242   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
3243   memcpy (tp, exthdr, exthdr_len);
3244   tp += exthdr_len;
3245   memcpy (tp, privkey, privkey_len);
3246   tp += privkey_len;
3247   memcpy (tp, suffix, suffix_len);
3248   tp += suffix_len;
3249
3250   memcpy (tp, ecc_d, ecc_d_len);
3251   tp += ecc_d_len;
3252
3253   if (pubkey_required)
3254     {
3255       memcpy (tp, ecc_q, ecc_q_len);
3256       tp += ecc_q_len;
3257     }
3258
3259   assert (tp - template == template_size);
3260
3261   *result = template;
3262   *resultlen = tp - template;
3263   return 0;
3264 }
3265
3266
3267 /* Helper for do_writekley to change the size of a key.  Not ethat
3268    this deletes the entire key without asking.  */
3269 static gpg_error_t
3270 change_keyattr (app_t app, int keyno, const unsigned char *buf, size_t buflen,
3271                 gpg_error_t (*pincb)(void*, const char *, char **),
3272                 void *pincb_arg)
3273 {
3274   gpg_error_t err;
3275
3276   assert (keyno >=0 && keyno <= 2);
3277
3278   /* Prepare for storing the key.  */
3279   err = verify_chv3 (app, pincb, pincb_arg);
3280   if (err)
3281     return err;
3282
3283   /* Change the attribute.  */
3284   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buf, buflen);
3285   if (err)
3286     log_error ("error changing key attribute (key=%d)\n", keyno+1);
3287   else
3288     log_info ("key attribute changed (key=%d)\n", keyno+1);
3289   flush_cache (app);
3290   parse_algorithm_attribute (app, keyno);
3291   app->did_chv1 = 0;
3292   app->did_chv2 = 0;
3293   app->did_chv3 = 0;
3294   return err;
3295 }
3296
3297
3298 static gpg_error_t
3299 change_rsa_keyattr (app_t app, int keyno, unsigned int nbits,
3300                     gpg_error_t (*pincb)(void*, const char *, char **),
3301                     void *pincb_arg)
3302 {
3303   gpg_error_t err = 0;
3304   unsigned char *buf;
3305   size_t buflen;
3306   void *relptr;
3307
3308   /* Read the current attributes into a buffer.  */
3309   relptr = get_one_do (app, 0xC1+keyno, &buf, &buflen, NULL);
3310   if (!relptr)
3311     err = gpg_error (GPG_ERR_CARD);
3312   else if (buflen < 6)
3313     {
3314       /* Attributes too short.  */
3315       xfree (relptr);
3316       err = gpg_error (GPG_ERR_CARD);
3317     }
3318   else
3319     {
3320       /* If key attribute was RSA, we only change n_bits and don't
3321          touch anything else.  Before we do so, we round up NBITS to a
3322          sensible way in the same way as gpg's key generation does it.
3323          This may help to sort out problems with a few bits too short
3324          keys.  */
3325       nbits = ((nbits + 31) / 32) * 32;
3326       buf[1] = (nbits >> 8);
3327       buf[2] = nbits;
3328
3329       /* If it was not RSA, we need to fill other parts.  */
3330       if (buf[0] != PUBKEY_ALGO_RSA)
3331         {
3332           buf[0] = PUBKEY_ALGO_RSA;
3333           buf[3] = 0;
3334           buf[4] = 32;
3335           buf[5] = 0;
3336           buflen = 6;
3337         }
3338
3339       err = change_keyattr (app, keyno, buf, buflen, pincb, pincb_arg);
3340       xfree (relptr);
3341     }
3342
3343   return err;
3344 }
3345
3346
3347 /* Helper to process an setattr command for name KEY-ATTR.
3348    In (VALUE,VALUELEN), it expects following string:
3349         RSA: "--force <key> <algo> rsa<nbits>"
3350         ECC: "--force <key> <algo> <curvename>"
3351   */
3352 static gpg_error_t
3353 change_keyattr_from_string (app_t app,
3354                             gpg_error_t (*pincb)(void*, const char *, char **),
3355                             void *pincb_arg,
3356                             const void *value, size_t valuelen)
3357 {
3358   gpg_error_t err = 0;
3359   char *string;
3360   int key, keyno, algo;
3361   int n = 0;
3362
3363   /* VALUE is expected to be a string but not guaranteed to be
3364      terminated.  Thus copy it to an allocated buffer first. */
3365   string = xtrymalloc (valuelen+1);
3366   if (!string)
3367     return gpg_error_from_syserror ();
3368   memcpy (string, value, valuelen);
3369   string[valuelen] = 0;
3370
3371   /* Because this function deletes the key we require the string
3372      "--force" in the data to make clear that something serious might
3373      happen.  */
3374   sscanf (string, "--force %d %d %n", &key, &algo, &n);
3375   if (n < 12)
3376     {
3377       err = gpg_error (GPG_ERR_INV_DATA);
3378       goto leave;
3379     }
3380
3381   keyno = key - 1;
3382   if (keyno < 0 || keyno > 2)
3383     err = gpg_error (GPG_ERR_INV_ID);
3384   else if (algo == PUBKEY_ALGO_RSA)
3385     {
3386       unsigned int nbits;
3387
3388       errno = 0;
3389       nbits = strtoul (string+n+3, NULL, 10);
3390       if (errno)
3391         err = gpg_error (GPG_ERR_INV_DATA);
3392       else if (nbits < 1024)
3393         err = gpg_error (GPG_ERR_TOO_SHORT);
3394       else if (nbits > 4096)
3395         err = gpg_error (GPG_ERR_TOO_LARGE);
3396       else
3397         err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3398     }
3399   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
3400            || algo == PUBKEY_ALGO_EDDSA)
3401     {
3402       const char *oidstr;
3403       gcry_mpi_t oid;
3404       const unsigned char *oidbuf;
3405       size_t oid_len;
3406
3407       oidstr = openpgp_curve_to_oid (string+n, NULL);
3408       if (!oidstr)
3409         {
3410           err = gpg_error (GPG_ERR_INV_DATA);
3411           goto leave;
3412         }
3413
3414       err = openpgp_oid_from_str (oidstr, &oid);
3415       if (err)
3416         goto leave;
3417
3418       oidbuf = gcry_mpi_get_opaque (oid, &n);
3419       oid_len = (n+7)/8;
3420
3421       /* We have enough room at STRING.  */
3422       string[0] = algo;
3423       memcpy (string+1, oidbuf+1, oid_len-1);
3424       err = change_keyattr (app, keyno, string, oid_len, pincb, pincb_arg);
3425       gcry_mpi_release (oid);
3426     }
3427   else
3428     err = gpg_error (GPG_ERR_PUBKEY_ALGO);
3429
3430  leave:
3431   xfree (string);
3432   return err;
3433 }
3434
3435
3436 static gpg_error_t
3437 rsa_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3438               void *pincb_arg, int keyno,
3439               const unsigned char *buf, size_t buflen, int depth)
3440 {
3441   gpg_error_t err;
3442   const unsigned char *tok;
3443   size_t toklen;
3444   int last_depth1, last_depth2;
3445   const unsigned char *rsa_n = NULL;
3446   const unsigned char *rsa_e = NULL;
3447   const unsigned char *rsa_p = NULL;
3448   const unsigned char *rsa_q = NULL;
3449   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3450   unsigned int nbits;
3451   unsigned int maxbits;
3452   unsigned char *template = NULL;
3453   unsigned char *tp;
3454   size_t template_len;
3455   unsigned char fprbuf[20];
3456   u32 created_at = 0;
3457
3458   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
3459     {
3460       log_error (_("unsupported algorithm: %s"), "RSA");
3461       err = gpg_error (GPG_ERR_INV_VALUE);
3462       goto leave;
3463     }
3464
3465   last_depth1 = depth;
3466   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3467          && depth && depth >= last_depth1)
3468     {
3469       if (tok)
3470         {
3471           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3472           goto leave;
3473         }
3474       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3475         goto leave;
3476       if (tok && toklen == 1)
3477         {
3478           const unsigned char **mpi;
3479           size_t *mpi_len;
3480
3481           switch (*tok)
3482             {
3483             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
3484             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
3485             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
3486             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
3487             default: mpi = NULL;  mpi_len = NULL; break;
3488             }
3489           if (mpi && *mpi)
3490             {
3491               err = gpg_error (GPG_ERR_DUP_VALUE);
3492               goto leave;
3493             }
3494           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3495             goto leave;
3496           if (tok && mpi)
3497             {
3498               /* Strip off leading zero bytes and save. */
3499               for (;toklen && !*tok; toklen--, tok++)
3500                 ;
3501               *mpi = tok;
3502               *mpi_len = toklen;
3503             }
3504         }
3505       /* Skip until end of list. */
3506       last_depth2 = depth;
3507       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3508              && depth && depth >= last_depth2)
3509         ;
3510       if (err)
3511         goto leave;
3512     }
3513   /* Parse other attributes. */
3514   last_depth1 = depth;
3515   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3516          && depth && depth >= last_depth1)
3517     {
3518       if (tok)
3519         {
3520           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3521           goto leave;
3522         }
3523       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3524         goto leave;
3525       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3526         {
3527           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3528             goto leave;
3529           if (tok)
3530             {
3531               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3532                    tok++, toklen--)
3533                 created_at = created_at*10 + (*tok - '0');
3534             }
3535         }
3536       /* Skip until end of list. */
3537       last_depth2 = depth;
3538       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3539              && depth && depth >= last_depth2)
3540         ;
3541       if (err)
3542         goto leave;
3543     }
3544
3545
3546   /* Check that we have all parameters and that they match the card
3547      description. */
3548   if (!created_at)
3549     {
3550       log_error (_("creation timestamp missing\n"));
3551       err = gpg_error (GPG_ERR_INV_VALUE);
3552       goto leave;
3553     }
3554
3555   maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3556   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
3557   if (opt.verbose)
3558     log_info ("RSA modulus size is %u bits\n", nbits);
3559   if (nbits && nbits != maxbits
3560       && app->app_local->extcap.algo_attr_change)
3561     {
3562       /* Try to switch the key to a new length.  */
3563       err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3564       if (!err)
3565         maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3566     }
3567   if (nbits != maxbits)
3568     {
3569       log_error (_("RSA modulus missing or not of size %d bits\n"),
3570                  (int)maxbits);
3571       err = gpg_error (GPG_ERR_BAD_SECKEY);
3572       goto leave;
3573     }
3574
3575   maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
3576   if (maxbits > 32 && !app->app_local->extcap.is_v2)
3577     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
3578   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
3579   if (nbits < 2 || nbits > maxbits)
3580     {
3581       log_error (_("RSA public exponent missing or larger than %d bits\n"),
3582                  (int)maxbits);
3583       err = gpg_error (GPG_ERR_BAD_SECKEY);
3584       goto leave;
3585     }
3586
3587   maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
3588   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
3589   if (nbits != maxbits)
3590     {
3591       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3592                  "P", (int)maxbits);
3593       err = gpg_error (GPG_ERR_BAD_SECKEY);
3594       goto leave;
3595     }
3596   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
3597   if (nbits != maxbits)
3598     {
3599       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3600                  "Q", (int)maxbits);
3601       err = gpg_error (GPG_ERR_BAD_SECKEY);
3602       goto leave;
3603     }
3604
3605   /* We need to remove the cached public key.  */
3606   xfree (app->app_local->pk[keyno].key);
3607   app->app_local->pk[keyno].key = NULL;
3608   app->app_local->pk[keyno].keylen = 0;
3609   app->app_local->pk[keyno].read_done = 0;
3610
3611
3612   if (app->app_local->extcap.is_v2)
3613     {
3614       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
3615       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
3616       gcry_mpi_t mpi_e, mpi_p, mpi_q;
3617       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
3618       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
3619       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
3620       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
3621       int exmode;
3622
3623       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
3624       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
3625       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
3626       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
3627
3628       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
3629       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
3630       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
3631       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
3632       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
3633
3634       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
3635       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
3636       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
3637
3638       gcry_mpi_release (mpi_e);
3639       gcry_mpi_release (mpi_p);
3640       gcry_mpi_release (mpi_q);
3641       gcry_mpi_release (mpi_u);
3642       gcry_mpi_release (mpi_dp);
3643       gcry_mpi_release (mpi_dq);
3644       gcry_mpi_release (mpi_tmp);
3645
3646       /* Build the private key template as described in section 4.3.3.7 of
3647          the OpenPGP card specs version 2.0.  */
3648       err = build_privkey_template (app, keyno,
3649                                     rsa_n, rsa_n_len,
3650                                     rsa_e, rsa_e_len,
3651                                     rsa_p, rsa_p_len,
3652                                     rsa_q, rsa_q_len,
3653                                     rsa_u, rsa_u_len,
3654                                     rsa_dp, rsa_dp_len,
3655                                     rsa_dq, rsa_dq_len,
3656                                     &template, &template_len);
3657       xfree(rsa_u);
3658       xfree(rsa_dp);
3659       xfree(rsa_dq);
3660
3661       if (err)
3662         goto leave;
3663
3664       /* Prepare for storing the key.  */
3665       err = verify_chv3 (app, pincb, pincb_arg);
3666       if (err)
3667         goto leave;
3668
3669       /* Store the key. */
3670       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3671         exmode = 1;    /* Use extended length w/o a limit.  */
3672       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3673         exmode = -254;
3674       else
3675         exmode = 0;
3676       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3677                                   template, template_len);
3678     }
3679   else
3680     {
3681       /* Build the private key template as described in section 4.3.3.6 of
3682          the OpenPGP card specs version 1.1:
3683          0xC0   <length> public exponent
3684          0xC1   <length> prime p
3685          0xC2   <length> prime q
3686       */
3687       assert (rsa_e_len <= 4);
3688       template_len = (1 + 1 + 4
3689                       + 1 + 1 + rsa_p_len
3690                       + 1 + 1 + rsa_q_len);
3691       template = tp = xtrymalloc_secure (template_len);
3692       if (!template)
3693         {
3694           err = gpg_error_from_syserror ();
3695           goto leave;
3696         }
3697       *tp++ = 0xC0;
3698       *tp++ = 4;
3699       memcpy (tp, rsa_e, rsa_e_len);
3700       if (rsa_e_len < 4)
3701         {
3702           /* Right justify E. */
3703           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
3704           memset (tp, 0, 4-rsa_e_len);
3705         }
3706       tp += 4;
3707
3708       *tp++ = 0xC1;
3709       *tp++ = rsa_p_len;
3710       memcpy (tp, rsa_p, rsa_p_len);
3711       tp += rsa_p_len;
3712
3713       *tp++ = 0xC2;
3714       *tp++ = rsa_q_len;
3715       memcpy (tp, rsa_q, rsa_q_len);
3716       tp += rsa_q_len;
3717
3718       assert (tp - template == template_len);
3719
3720       /* Prepare for storing the key.  */
3721       err = verify_chv3 (app, pincb, pincb_arg);
3722       if (err)
3723         goto leave;
3724
3725       /* Store the key. */
3726       err = iso7816_put_data (app->slot, 0,
3727                               (app->appversion > 0x0007? 0xE0:0xE9)+keyno,
3728                               template, template_len);
3729     }
3730   if (err)
3731     {
3732       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3733       goto leave;
3734     }
3735
3736   err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
3737                    rsa_n, rsa_n_len, rsa_e, rsa_e_len);
3738   if (err)
3739     goto leave;
3740
3741
3742  leave:
3743   xfree (template);
3744   return err;
3745 }
3746
3747
3748 static gpg_error_t
3749 ecc_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3750               void *pincb_arg, int keyno,
3751               const unsigned char *buf, size_t buflen, int depth)
3752 {
3753   gpg_error_t err;
3754   const unsigned char *tok;
3755   size_t toklen;
3756   int last_depth1, last_depth2;
3757   const unsigned char *ecc_q = NULL;
3758   const unsigned char *ecc_d = NULL;
3759   size_t ecc_q_len, ecc_d_len;
3760   const char *curve = NULL;
3761   u32 created_at = 0;
3762   const char *oidstr;
3763   int flag_djb_tweak = 0;
3764   int algo;
3765   gcry_mpi_t oid = NULL;
3766   const unsigned char *oidbuf;
3767   unsigned int n;
3768   size_t oid_len;
3769   unsigned char fprbuf[20];
3770
3771   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3772      curve = "NIST P-256" */
3773   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3774      curve = "secp256k1" */
3775   /* (private-key(ecc(curve%s)(flags eddsa)(q%m)(d%m))(created-at%d)):
3776       curve = "Ed25519" */
3777   last_depth1 = depth;
3778   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3779          && depth && depth >= last_depth1)
3780     {
3781       if (tok)
3782         {
3783           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3784           goto leave;
3785         }
3786       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3787         goto leave;
3788
3789       if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
3790         {
3791           char *curve_name;
3792
3793           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3794             goto leave;
3795
3796           curve_name = xtrymalloc (toklen+1);
3797           if (!curve_name)
3798             {
3799               err = gpg_error_from_syserror ();
3800               goto leave;
3801             }
3802
3803           memcpy (curve_name, tok, toklen);
3804           curve_name[toklen] = 0;
3805           curve = openpgp_is_curve_supported (curve_name, NULL, NULL);
3806           xfree (curve_name);
3807         }
3808       else if (tok && toklen == 5 && !memcmp (tok, "flags", 5))
3809         {
3810           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3811             goto leave;
3812
3813           if (tok)
3814             {
3815               if ((toklen == 5 && !memcmp (tok, "eddsa", 5))
3816                   || (toklen == 9 && !memcmp (tok, "djb-tweak", 9)))
3817                 flag_djb_tweak = 1;
3818             }
3819         }
3820       else if (tok && toklen == 1)
3821         {
3822           const unsigned char **buf2;
3823           size_t *buf2len;
3824           int native = flag_djb_tweak;
3825
3826           switch (*tok)
3827             {
3828             case 'q': buf2 = &ecc_q; buf2len = &ecc_q_len; break;
3829             case 'd': buf2 = &ecc_d; buf2len = &ecc_d_len; native = 0; break;
3830             default: buf2 = NULL;  buf2len = NULL; break;
3831             }
3832           if (buf2 && *buf2)
3833             {
3834               err = gpg_error (GPG_ERR_DUP_VALUE);
3835               goto leave;
3836             }
3837           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3838             goto leave;
3839           if (tok && buf2)
3840             {
3841               if (!native)
3842                 /* Strip off leading zero bytes and save. */
3843                 for (;toklen && !*tok; toklen--, tok++)
3844                   ;
3845
3846               *buf2 = tok;
3847               *buf2len = toklen;
3848             }
3849         }
3850       /* Skip until end of list. */
3851       last_depth2 = depth;
3852       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3853              && depth && depth >= last_depth2)
3854         ;
3855       if (err)
3856         goto leave;
3857     }
3858   /* Parse other attributes. */
3859   last_depth1 = depth;
3860   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3861          && depth && depth >= last_depth1)
3862     {
3863       if (tok)
3864         {
3865           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3866           goto leave;
3867         }
3868       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3869         goto leave;
3870       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3871         {
3872           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3873             goto leave;
3874           if (tok)
3875             {
3876               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3877                    tok++, toklen--)
3878                 created_at = created_at*10 + (*tok - '0');
3879             }
3880         }
3881       /* Skip until end of list. */
3882       last_depth2 = depth;
3883       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3884              && depth && depth >= last_depth2)
3885         ;
3886       if (err)
3887         goto leave;
3888     }
3889
3890
3891   /* Check that we have all parameters and that they match the card
3892      description. */
3893   if (!curve)
3894     {
3895       log_error (_("unsupported curve\n"));
3896       err = gpg_error (GPG_ERR_INV_VALUE);
3897       goto leave;
3898     }
3899   if (!created_at)
3900     {
3901       log_error (_("creation timestamp missing\n"));
3902       err = gpg_error (GPG_ERR_INV_VALUE);
3903       goto leave;
3904     }
3905   if (flag_djb_tweak && keyno != 1)
3906     algo = PUBKEY_ALGO_EDDSA;
3907   else if (keyno == 1)
3908     algo = PUBKEY_ALGO_ECDH;
3909   else
3910     algo = PUBKEY_ALGO_ECDSA;
3911
3912   oidstr = openpgp_curve_to_oid (curve, NULL);
3913   err = openpgp_oid_from_str (oidstr, &oid);
3914   if (err)
3915     goto leave;
3916   oidbuf = gcry_mpi_get_opaque (oid, &n);
3917   if (!oidbuf)
3918     {
3919       err = gpg_error_from_syserror ();
3920       goto leave;
3921     }
3922   oid_len = (n+7)/8;
3923
3924   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_ECC
3925       || app->app_local->keyattr[keyno].ecc.curve != curve
3926       || (flag_djb_tweak !=
3927           (app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK)))
3928     {
3929       if (app->app_local->extcap.algo_attr_change)
3930         {
3931           unsigned char *keyattr;
3932
3933           if (!oid_len)
3934             {
3935               err = gpg_error (GPG_ERR_INTERNAL);
3936               goto leave;
3937             }
3938           keyattr = xtrymalloc (oid_len);
3939           if (!keyattr)
3940             {
3941               err = gpg_error_from_syserror ();
3942               goto leave;
3943             }
3944           keyattr[0] = algo;
3945           memcpy (keyattr+1, oidbuf+1, oid_len-1);
3946           err = change_keyattr (app, keyno, keyattr, oid_len, pincb, pincb_arg);
3947           xfree (keyattr);
3948           if (err)
3949             goto leave;
3950         }
3951       else
3952         {
3953           log_error ("key attribute on card doesn't match\n");
3954           err = gpg_error (GPG_ERR_INV_VALUE);
3955           goto leave;
3956         }
3957     }
3958
3959   if (opt.verbose)
3960     log_info ("ECC private key size is %u bytes\n", (unsigned int)ecc_d_len);
3961
3962   /* We need to remove the cached public key.  */
3963   xfree (app->app_local->pk[keyno].key);
3964   app->app_local->pk[keyno].key = NULL;
3965   app->app_local->pk[keyno].keylen = 0;
3966   app->app_local->pk[keyno].read_done = 0;
3967
3968   if (app->app_local->extcap.is_v2)
3969     {
3970       /* Build the private key template as described in section 4.3.3.7 of
3971          the OpenPGP card specs version 2.0.  */
3972       unsigned char *template;
3973       size_t template_len;
3974       int exmode;
3975
3976       err = build_ecc_privkey_template (app, keyno,
3977                                         ecc_d, ecc_d_len,
3978                                         ecc_q, ecc_q_len,
3979                                         &template, &template_len);
3980       if (err)
3981         goto leave;
3982
3983       /* Prepare for storing the key.  */
3984       err = verify_chv3 (app, pincb, pincb_arg);
3985       if (err)
3986         {
3987           xfree (template);
3988           goto leave;
3989         }
3990
3991       /* Store the key. */
3992       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3993         exmode = 1;    /* Use extended length w/o a limit.  */
3994       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3995         exmode = -254;
3996       else
3997         exmode = 0;
3998       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3999                                   template, template_len);
4000       xfree (template);
4001     }
4002   else
4003     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
4004
4005   if (err)
4006     {
4007       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
4008       goto leave;
4009     }
4010
4011   err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
4012                    ecc_q, ecc_q_len, ecdh_params (curve), (size_t)4);
4013
4014  leave:
4015   gcry_mpi_release (oid);
4016   return err;
4017 }
4018
4019 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
4020    canonical encoded S-expression with the secret key in KEYDATA and
4021    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
4022    usual keyid which for OpenPGP is the string "OPENPGP.n" with
4023    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
4024    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
4025    the pinentry callback.  */
4026 static gpg_error_t
4027 do_writekey (app_t app, ctrl_t ctrl,
4028              const char *keyid, unsigned int flags,
4029              gpg_error_t (*pincb)(void*, const char *, char **),
4030              void *pincb_arg,
4031              const unsigned char *keydata, size_t keydatalen)
4032 {
4033   gpg_error_t err;
4034   int force = (flags & 1);
4035   int keyno;
4036   const unsigned char *buf, *tok;
4037   size_t buflen, toklen;
4038   int depth;
4039
4040   (void)ctrl;
4041
4042   if (!strcmp (keyid, "OPENPGP.1"))
4043     keyno = 0;
4044   else if (!strcmp (keyid, "OPENPGP.2"))
4045     keyno = 1;
4046   else if (!strcmp (keyid, "OPENPGP.3"))
4047     keyno = 2;
4048   else
4049     return gpg_error (GPG_ERR_INV_ID);
4050
4051   err = does_key_exist (app, keyno, 0, force);
4052   if (err)
4053     return err;
4054
4055
4056   /*
4057      Parse the S-expression
4058    */
4059   buf = keydata;
4060   buflen = keydatalen;
4061   depth = 0;
4062   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4063     goto leave;
4064   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4065     goto leave;
4066   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
4067     {
4068       if (!tok)
4069         ;
4070       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
4071         log_info ("protected-private-key passed to writekey\n");
4072       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
4073         log_info ("shadowed-private-key passed to writekey\n");
4074       err = gpg_error (GPG_ERR_BAD_SECKEY);
4075       goto leave;
4076     }
4077   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4078     goto leave;
4079   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4080     goto leave;
4081   if (tok && toklen == 3 && memcmp ("rsa", tok, toklen) == 0)
4082     err = rsa_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
4083   else if (tok && toklen == 3 && memcmp ("ecc", tok, toklen) == 0)
4084     err = ecc_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
4085   else
4086     {
4087       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
4088       goto leave;
4089     }
4090
4091  leave:
4092   return err;
4093 }
4094
4095
4096
4097 /* Handle the GENKEY command. */
4098 static gpg_error_t
4099 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, const char *keytype,
4100            unsigned int flags, time_t createtime,
4101            gpg_error_t (*pincb)(void*, const char *, char **),
4102            void *pincb_arg)
4103 {
4104   gpg_error_t err;
4105   char numbuf[30];
4106   unsigned char *buffer = NULL;
4107   const unsigned char *keydata;
4108   size_t buflen, keydatalen;
4109   u32 created_at;
4110   int keyno = atoi (keynostr) - 1;
4111   int force = (flags & 1);
4112   time_t start_at;
4113   int exmode = 0;
4114   int le_value = 256; /* Use legacy value. */
4115
4116   (void)keytype;  /* Ignored for OpenPGP cards.  */
4117
4118   if (keyno < 0 || keyno > 2)
4119     return gpg_error (GPG_ERR_INV_ID);
4120
4121   /* We flush the cache to increase the traffic before a key
4122      generation.  This _might_ help a card to gather more entropy. */
4123   flush_cache (app);
4124
4125   /* Obviously we need to remove the cached public key.  */
4126   xfree (app->app_local->pk[keyno].key);
4127   app->app_local->pk[keyno].key = NULL;
4128   app->app_local->pk[keyno].keylen = 0;
4129   app->app_local->pk[keyno].read_done = 0;
4130
4131   /* Check whether a key already exists.  */
4132   err = does_key_exist (app, keyno, 1, force);
4133   if (err)
4134     return err;
4135
4136   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
4137     {
4138       unsigned int keybits = app->app_local->keyattr[keyno].rsa.n_bits;
4139
4140       /* Because we send the key parameter back via status lines we need
4141          to put a limit on the max. allowed keysize.  2048 bit will
4142          already lead to a 527 byte long status line and thus a 4096 bit
4143          key would exceed the Assuan line length limit.  */
4144       if (keybits > 4096)
4145         return gpg_error (GPG_ERR_TOO_LARGE);
4146
4147       if (app->app_local->cardcap.ext_lc_le && keybits > RSA_SMALL_SIZE_KEY
4148           && app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
4149         {
4150           exmode = 1;    /* Use extended length w/o a limit.  */
4151           le_value = determine_rsa_response (app, keyno);
4152           /* No need to check le_value because it comes from a 16 bit
4153              value and thus can't create an overflow on a 32 bit
4154              system.  */
4155         }
4156     }
4157
4158   /* Prepare for key generation by verifying the Admin PIN.  */
4159   err = verify_chv3 (app, pincb, pincb_arg);
4160   if (err)
4161     return err;
4162
4163
4164   log_info (_("please wait while key is being generated ...\n"));
4165   start_at = time (NULL);
4166   err = iso7816_generate_keypair (app->slot, exmode, 0x80, 0,
4167                                   (keyno == 0? "\xB6" :
4168                                    keyno == 1? "\xB8" : "\xA4"),
4169                                   2, le_value, &buffer, &buflen);
4170   if (err)
4171     {
4172       log_error (_("generating key failed\n"));
4173       return gpg_error (GPG_ERR_CARD);
4174     }
4175
4176   {
4177     int nsecs = (int)(time (NULL) - start_at);
4178     log_info (ngettext("key generation completed (%d second)\n",
4179                        "key generation completed (%d seconds)\n",
4180                        nsecs), nsecs);
4181   }
4182
4183   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
4184   if (!keydata)
4185     {
4186       err = gpg_error (GPG_ERR_CARD);
4187       log_error (_("response does not contain the public key data\n"));
4188       goto leave;