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