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