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