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