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