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