Remove unused debug flags and add "dns" and "network".
[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, but we have it already in the app
982          context and the stamp argument is required anyway which we
983          can't by other means. The AID DO is available anyway but not
984          hex formatted. */
985       char *serial;
986       time_t stamp;
987       char tmp[50];
988
989       if (!app_get_serial_and_stamp (app, &serial, &stamp))
990         {
991           sprintf (tmp, "%lu", (unsigned long)stamp);
992           send_status_info (ctrl, "SERIALNO",
993                             serial, strlen (serial),
994                             tmp, strlen (tmp),
995                             NULL, 0);
996           xfree (serial);
997         }
998       return 0;
999     }
1000   if (table[idx].special == -2)
1001     {
1002       char tmp[110];
1003
1004       snprintf (tmp, sizeof tmp,
1005                 "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d "
1006                 "sm=%d si=%u dec=%d bt=%d",
1007                 app->app_local->extcap.get_challenge,
1008                 app->app_local->extcap.key_import,
1009                 app->app_local->extcap.change_force_chv,
1010                 app->app_local->extcap.private_dos,
1011                 app->app_local->extcap.max_certlen_3,
1012                 app->app_local->extcap.algo_attr_change,
1013                 (app->app_local->extcap.sm_supported
1014                  ? (app->app_local->extcap.sm_algo == 0? CIPHER_ALGO_3DES :
1015                     (app->app_local->extcap.sm_algo == 1?
1016                      CIPHER_ALGO_AES : CIPHER_ALGO_AES256))
1017                  : 0),
1018                 app->app_local->status_indicator,
1019                 app->app_local->extcap.has_decrypt,
1020                 app->app_local->extcap.has_button);
1021       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1022       return 0;
1023     }
1024   if (table[idx].special == -3)
1025     {
1026       char const tmp[] = "OPENPGP.3";
1027       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1028       return 0;
1029     }
1030   if (table[idx].special == -4)
1031     {
1032       char *serial;
1033       time_t stamp;
1034
1035       if (!app_get_serial_and_stamp (app, &serial, &stamp))
1036         {
1037           if (strlen (serial) > 16+12)
1038             {
1039               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
1040               xfree (serial);
1041               return 0;
1042             }
1043           xfree (serial);
1044         }
1045       return gpg_error (GPG_ERR_INV_NAME);
1046     }
1047   if (table[idx].special == -5)
1048     {
1049       for (i=0; i < 3; i++)
1050         send_key_attr (ctrl, app, table[idx].name, i);
1051       return 0;
1052     }
1053
1054   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
1055   if (relptr)
1056     {
1057       if (table[idx].special == 1)
1058         {
1059           char numbuf[7*23];
1060
1061           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
1062             sprintf (numbuf+strlen (numbuf), " %d", value[i]);
1063           send_status_info (ctrl, table[idx].name,
1064                             numbuf, strlen (numbuf), NULL, 0);
1065         }
1066       else if (table[idx].special == 2)
1067         {
1068           char numbuf[50];
1069
1070           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
1071           send_status_info (ctrl, table[idx].name,
1072                             numbuf, strlen (numbuf), NULL, 0);
1073         }
1074       else if (table[idx].special == 3)
1075         {
1076           if (valuelen >= 60)
1077             for (i=0; i < 3; i++)
1078               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
1079         }
1080       else if (table[idx].special == 4)
1081         {
1082           if (valuelen >= 12)
1083             for (i=0; i < 3; i++)
1084               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
1085         }
1086       else
1087         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
1088
1089       xfree (relptr);
1090     }
1091   return rc;
1092 }
1093
1094 /* Retrieve the fingerprint from the card inserted in SLOT and write
1095    the according hex representation to FPR.  Caller must have provide
1096    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
1097    error code. */
1098 #if GNUPG_MAJOR_VERSION > 1
1099 static gpg_error_t
1100 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
1101 {
1102   gpg_error_t err = 0;
1103   void *relptr;
1104   unsigned char *value;
1105   size_t valuelen;
1106
1107   assert (keyno >=0 && keyno <= 2);
1108
1109   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
1110   if (relptr && valuelen >= 60)
1111     bin2hex (value+keyno*20, 20, fpr);
1112   else
1113     err = gpg_error (GPG_ERR_NOT_FOUND);
1114   xfree (relptr);
1115   return err;
1116 }
1117 #endif /*GNUPG_MAJOR_VERSION > 1*/
1118
1119
1120 /* Retrieve the public key material for the RSA key, whose fingerprint
1121    is FPR, from gpg output, which can be read through the stream FP.
1122    The RSA modulus will be stored at the address of M and MLEN, the
1123    public exponent at E and ELEN.  Returns zero on success, an error
1124    code on failure.  Caller must release the allocated buffers at M
1125    and E if the function returns success.  */
1126 #if GNUPG_MAJOR_VERSION > 1
1127 static gpg_error_t
1128 retrieve_key_material (FILE *fp, const char *hexkeyid,
1129                        const unsigned char **m, size_t *mlen,
1130                        const unsigned char **e, size_t *elen)
1131 {
1132   gcry_error_t err = 0;
1133   char *line = NULL;    /* read_line() buffer. */
1134   size_t line_size = 0; /* Helper for for read_line. */
1135   int found_key = 0;    /* Helper to find a matching key. */
1136   unsigned char *m_new = NULL;
1137   unsigned char *e_new = NULL;
1138   size_t m_new_n = 0;
1139   size_t e_new_n = 0;
1140
1141   /* Loop over all records until we have found the subkey
1142      corresponding to the fingerprint. Inm general the first record
1143      should be the pub record, but we don't rely on that.  Given that
1144      we only need to look at one key, it is sufficient to compare the
1145      keyid so that we don't need to look at "fpr" records. */
1146   for (;;)
1147     {
1148       char *p;
1149       char *fields[6] = { NULL, NULL, NULL, NULL, NULL, NULL };
1150       int nfields;
1151       size_t max_length;
1152       gcry_mpi_t mpi;
1153       int i;
1154
1155       max_length = 4096;
1156       i = read_line (fp, &line, &line_size, &max_length);
1157       if (!i)
1158         break; /* EOF. */
1159       if (i < 0)
1160         {
1161           err = gpg_error_from_syserror ();
1162           goto leave; /* Error. */
1163         }
1164       if (!max_length)
1165         {
1166           err = gpg_error (GPG_ERR_TRUNCATED);
1167           goto leave;  /* Line truncated - we better stop processing.  */
1168         }
1169
1170       /* Parse the line into fields. */
1171       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
1172         {
1173           fields[nfields] = p;
1174           p = strchr (p, ':');
1175           if (p)
1176             *(p++) = 0;
1177         }
1178       if (!nfields)
1179         continue; /* No fields at all - skip line.  */
1180
1181       if (!found_key)
1182         {
1183           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1184                && nfields > 4 && !strcmp (fields[4], hexkeyid))
1185             found_key = 1;
1186           continue;
1187         }
1188
1189       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1190         break; /* Next key - stop.  */
1191
1192       if ( strcmp (fields[0], "pkd") )
1193         continue; /* Not a key data record.  */
1194       i = 0; /* Avoid erroneous compiler warning. */
1195       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1196            || (!i && m_new) || (i && e_new))
1197         {
1198           err = gpg_error (GPG_ERR_GENERAL);
1199           goto leave; /* Error: Invalid key data record or not an RSA key.  */
1200         }
1201
1202       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1203       if (err)
1204         mpi = NULL;
1205       else if (!i)
1206         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1207       else
1208         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1209       gcry_mpi_release (mpi);
1210       if (err)
1211         goto leave;
1212     }
1213
1214   if (m_new && e_new)
1215     {
1216       *m = m_new;
1217       *mlen = m_new_n;
1218       m_new = NULL;
1219       *e = e_new;
1220       *elen = e_new_n;
1221       e_new = NULL;
1222     }
1223   else
1224     err = gpg_error (GPG_ERR_GENERAL);
1225
1226  leave:
1227   xfree (m_new);
1228   xfree (e_new);
1229   xfree (line);
1230   return err;
1231 }
1232 #endif /*GNUPG_MAJOR_VERSION > 1*/
1233
1234
1235 static gpg_error_t
1236 rsa_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at,  int keyno,
1237                  const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
1238 {
1239   gpg_error_t err;
1240   const unsigned char *m, *e;
1241   size_t mlen, elen;
1242   unsigned char *mbuf = NULL, *ebuf = NULL;
1243
1244   m = find_tlv (data, datalen, 0x0081, &mlen);
1245   if (!m)
1246     {
1247       log_error (_("response does not contain the RSA modulus\n"));
1248       return gpg_error (GPG_ERR_CARD);
1249     }
1250
1251   e = find_tlv (data, datalen, 0x0082, &elen);
1252   if (!e)
1253     {
1254       log_error (_("response does not contain the RSA public exponent\n"));
1255       return gpg_error (GPG_ERR_CARD);
1256     }
1257
1258   if (ctrl)
1259     {
1260       send_key_data (ctrl, "n", m, mlen);
1261       send_key_data (ctrl, "e", e, elen);
1262     }
1263
1264   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
1265     ;
1266   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
1267     ;
1268
1269   if (ctrl)
1270     {
1271       unsigned char fprbuf[20];
1272
1273       err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
1274                        m, mlen, e, elen);
1275       if (err)
1276         return err;
1277
1278       send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1279     }
1280
1281   mbuf = xtrymalloc (mlen + 1);
1282   if (!mbuf)
1283     {
1284       err = gpg_error_from_syserror ();
1285       goto leave;
1286     }
1287   /* Prepend numbers with a 0 if needed.  */
1288   if (mlen && (*m & 0x80))
1289     {
1290       *mbuf = 0;
1291       memcpy (mbuf+1, m, mlen);
1292       mlen++;
1293     }
1294   else
1295     memcpy (mbuf, m, mlen);
1296
1297   ebuf = xtrymalloc (elen + 1);
1298   if (!ebuf)
1299     {
1300       err = gpg_error_from_syserror ();
1301       goto leave;
1302     }
1303   /* Prepend numbers with a 0 if needed.  */
1304   if (elen && (*e & 0x80))
1305     {
1306       *ebuf = 0;
1307       memcpy (ebuf+1, e, elen);
1308       elen++;
1309     }
1310   else
1311     memcpy (ebuf, e, elen);
1312
1313   err = gcry_sexp_build (r_sexp, NULL, "(public-key(rsa(n%b)(e%b)))",
1314                          (int)mlen, mbuf, (int)elen, ebuf);
1315  leave:
1316   xfree (mbuf);
1317   xfree (ebuf);
1318   return err;
1319 }
1320
1321
1322 /* Determine KDF hash algorithm and KEK encryption algorithm by CURVE.  */
1323 static const unsigned char*
1324 ecdh_params (const char *curve)
1325 {
1326   unsigned int nbits;
1327
1328   openpgp_curve_to_oid (curve, &nbits);
1329
1330   /* See RFC-6637 for those constants.
1331          0x03: Number of bytes
1332          0x01: Version for this parameter format
1333          KDF algo
1334         KEK algo
1335   */
1336   if (nbits <= 256)
1337     return (const unsigned char*)"\x03\x01\x08\x07";
1338   else if (nbits <= 384)
1339     return (const unsigned char*)"\x03\x01\x09\x08";
1340   else
1341     return (const unsigned char*)"\x03\x01\x0a\x09";
1342 }
1343
1344 static gpg_error_t
1345 ecc_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
1346                  const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
1347 {
1348   gpg_error_t err;
1349   unsigned char *qbuf = NULL;
1350   const unsigned char *ecc_q;
1351   size_t ecc_q_len;
1352   gcry_mpi_t oid = NULL;
1353   int n;
1354   const char *curve;
1355   const char *oidstr;
1356   const unsigned char *oidbuf;
1357   size_t oid_len;
1358   int algo;
1359   const char *format;
1360
1361   ecc_q = find_tlv (data, datalen, 0x0086, &ecc_q_len);
1362   if (!ecc_q)
1363     {
1364       log_error (_("response does not contain the EC public key\n"));
1365       return gpg_error (GPG_ERR_CARD);
1366     }
1367
1368   curve = app->app_local->keyattr[keyno].ecc.curve;
1369   oidstr = openpgp_curve_to_oid (curve, NULL);
1370   err = openpgp_oid_from_str (oidstr, &oid);
1371   if (err)
1372     return err;
1373   oidbuf = gcry_mpi_get_opaque (oid, &n);
1374   if (!oidbuf)
1375     {
1376       err = gpg_error_from_syserror ();
1377       goto leave;
1378     }
1379   oid_len = (n+7)/8;
1380
1381   qbuf = xtrymalloc (ecc_q_len + 1);
1382   if (!qbuf)
1383     {
1384       err = gpg_error_from_syserror ();
1385       goto leave;
1386     }
1387
1388   if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1389     {               /* Prepend 0x40 prefix.  */
1390       *qbuf = 0x40;
1391       memcpy (qbuf+1, ecc_q, ecc_q_len);
1392       ecc_q_len++;
1393     }
1394   else
1395     memcpy (qbuf, ecc_q, ecc_q_len);
1396
1397   if (ctrl)
1398     {
1399       send_key_data (ctrl, "q", qbuf, ecc_q_len);
1400       send_key_data (ctrl, "curve", oidbuf, oid_len);
1401     }
1402
1403   if (keyno == 1)
1404     {
1405       if (ctrl)
1406         send_key_data (ctrl, "kdf/kek", ecdh_params (curve), (size_t)4);
1407       algo = PUBKEY_ALGO_ECDH;
1408     }
1409   else
1410     {
1411       if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1412         algo = PUBKEY_ALGO_EDDSA;
1413       else
1414         algo = PUBKEY_ALGO_ECDSA;
1415     }
1416
1417   if (ctrl)
1418     {
1419       unsigned char fprbuf[20];
1420
1421       err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
1422                        qbuf, ecc_q_len, ecdh_params (curve), (size_t)4);
1423       if (err)
1424         goto leave;
1425
1426       send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1427     }
1428
1429   if (!(app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1430     format = "(public-key(ecc(curve%s)(q%b)))";
1431   else if (keyno == 1)
1432     format = "(public-key(ecc(curve%s)(flags djb-tweak)(q%b)))";
1433   else
1434     format = "(public-key(ecc(curve%s)(flags eddsa)(q%b)))";
1435
1436   err = gcry_sexp_build (r_sexp, NULL, format,
1437                          app->app_local->keyattr[keyno].ecc.curve,
1438                          (int)ecc_q_len, qbuf);
1439  leave:
1440   gcry_mpi_release (oid);
1441   xfree (qbuf);
1442   return err;
1443 }
1444
1445
1446 /* Parse tag-length-value data for public key in BUFFER of BUFLEN
1447    length.  Key of KEYNO in APP is updated with an S-expression of
1448    public key.  When CTRL is not NULL, fingerprint is computed with
1449    CREATED_AT, and fingerprint is written to the card, and key data
1450    and fingerprint are send back to the client side.
1451  */
1452 static gpg_error_t
1453 read_public_key (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
1454                  const unsigned char *buffer, size_t buflen)
1455 {
1456   gpg_error_t err;
1457   const unsigned char *data;
1458   size_t datalen;
1459   gcry_sexp_t s_pkey = NULL;
1460
1461   data = find_tlv (buffer, buflen, 0x7F49, &datalen);
1462   if (!data)
1463     {
1464       log_error (_("response does not contain the public key data\n"));
1465       return gpg_error (GPG_ERR_CARD);
1466     }
1467
1468   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
1469     err = rsa_read_pubkey (app, ctrl, created_at, keyno,
1470                            data, datalen, &s_pkey);
1471   else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
1472     err = ecc_read_pubkey (app, ctrl, created_at, keyno,
1473                            data, datalen, &s_pkey);
1474   else
1475     err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1476
1477   if (!err)
1478     {
1479       unsigned char *keybuf;
1480       size_t len;
1481
1482       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1483       keybuf = xtrymalloc (len);
1484       if (!data)
1485         {
1486           err = gpg_error_from_syserror ();
1487           gcry_sexp_release (s_pkey);
1488           return err;
1489         }
1490
1491       gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1492       gcry_sexp_release (s_pkey);
1493
1494       app->app_local->pk[keyno].key = keybuf;
1495       /* Decrement for trailing '\0' */
1496       app->app_local->pk[keyno].keylen = len - 1;
1497     }
1498
1499   return err;
1500 }
1501
1502
1503 /* Get the public key for KEYNO and store it as an S-expresion with
1504    the APP handle.  On error that field gets cleared.  If we already
1505    know about the public key we will just return.  Note that this does
1506    not mean a key is available; this is solely indicated by the
1507    presence of the app->app_local->pk[KEYNO].key field.
1508
1509    Note that GnuPG 1.x does not need this and it would be too time
1510    consuming to send it just for the fun of it. However, given that we
1511    use the same code in gpg 1.4, we can't use the gcry S-expresion
1512    here but need to open encode it. */
1513 #if GNUPG_MAJOR_VERSION > 1
1514 static gpg_error_t
1515 get_public_key (app_t app, int keyno)
1516 {
1517   gpg_error_t err = 0;
1518   unsigned char *buffer;
1519   const unsigned char *m, *e;
1520   size_t buflen;
1521   size_t mlen = 0;
1522   size_t elen = 0;
1523   char *keybuf = NULL;
1524   gcry_sexp_t s_pkey;
1525   size_t len;
1526
1527   if (keyno < 0 || keyno > 2)
1528     return gpg_error (GPG_ERR_INV_ID);
1529
1530   /* Already cached? */
1531   if (app->app_local->pk[keyno].read_done)
1532     return 0;
1533
1534   xfree (app->app_local->pk[keyno].key);
1535   app->app_local->pk[keyno].key = NULL;
1536   app->app_local->pk[keyno].keylen = 0;
1537
1538   m = e = NULL; /* (avoid cc warning) */
1539
1540   if (app->card_version > 0x0100)
1541     {
1542       int exmode, le_value;
1543
1544       /* We may simply read the public key out of these cards.  */
1545       if (app->app_local->cardcap.ext_lc_le
1546           && app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA
1547           && app->app_local->keyattr[keyno].rsa.n_bits > RSA_SMALL_SIZE_KEY)
1548         {
1549           exmode = 1;    /* Use extended length.  */
1550           le_value = determine_rsa_response (app, keyno);
1551         }
1552       else
1553         {
1554           exmode = 0;
1555           le_value = 256; /* Use legacy value. */
1556         }
1557
1558       err = iso7816_read_public_key (app->slot, exmode,
1559                                      (keyno == 0? "\xB6" :
1560                                       keyno == 1? "\xB8" : "\xA4"),
1561                                      2, le_value, &buffer, &buflen);
1562       if (err)
1563         {
1564           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1565           goto leave;
1566         }
1567
1568       err = read_public_key (app, NULL, 0U, keyno, buffer, buflen);
1569     }
1570   else
1571     {
1572       /* Due to a design problem in v1.0 cards we can't get the public
1573          key out of these cards without doing a verify on CHV3.
1574          Clearly that is not an option and thus we try to locate the
1575          key using an external helper.
1576
1577          The helper we use here is gpg itself, which should know about
1578          the key in any case.  */
1579
1580       char fpr[41];
1581       char *hexkeyid;
1582       char *command = NULL;
1583       FILE *fp;
1584       int ret;
1585
1586       buffer = NULL; /* We don't need buffer.  */
1587
1588       err = retrieve_fpr_from_card (app, keyno, fpr);
1589       if (err)
1590         {
1591           log_error ("error while retrieving fpr from card: %s\n",
1592                      gpg_strerror (err));
1593           goto leave;
1594         }
1595       hexkeyid = fpr + 24;
1596
1597       ret = gpgrt_asprintf
1598         (&command, "gpg --list-keys --with-colons --with-key-data '%s'", fpr);
1599       if (ret < 0)
1600         {
1601           err = gpg_error_from_syserror ();
1602           goto leave;
1603         }
1604
1605       fp = popen (command, "r");
1606       xfree (command);
1607       if (!fp)
1608         {
1609           err = gpg_error_from_syserror ();
1610           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1611           goto leave;
1612         }
1613
1614       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1615       pclose (fp);
1616       if (err)
1617         {
1618           log_error ("error while retrieving key material through pipe: %s\n",
1619                      gpg_strerror (err));
1620           goto leave;
1621         }
1622
1623       err = gcry_sexp_build (&s_pkey, NULL, "(public-key(rsa(n%b)(e%b)))",
1624                              (int)mlen, m, (int)elen, e);
1625       if (err)
1626         goto leave;
1627
1628       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1629
1630       keybuf = xtrymalloc (len);
1631       if (!keybuf)
1632         {
1633           err = gpg_error_from_syserror ();
1634           gcry_sexp_release (s_pkey);
1635           goto leave;
1636         }
1637
1638       gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1639       gcry_sexp_release (s_pkey);
1640
1641       app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1642       /* Decrement for trailing '\0' */
1643       app->app_local->pk[keyno].keylen = len - 1;
1644     }
1645
1646  leave:
1647   /* Set a flag to indicate that we tried to read the key.  */
1648   app->app_local->pk[keyno].read_done = 1;
1649
1650   xfree (buffer);
1651   return err;
1652 }
1653 #endif /* GNUPG_MAJOR_VERSION > 1 */
1654
1655
1656
1657 /* Send the KEYPAIRINFO back. KEY needs to be in the range [1,3].
1658    This is used by the LEARN command. */
1659 static gpg_error_t
1660 send_keypair_info (app_t app, ctrl_t ctrl, int key)
1661 {
1662   int keyno = key - 1;
1663   gpg_error_t err = 0;
1664   /* Note that GnuPG 1.x does not need this and it would be too time
1665      consuming to send it just for the fun of it. */
1666 #if GNUPG_MAJOR_VERSION > 1
1667   unsigned char grip[20];
1668   char gripstr[41];
1669   char idbuf[50];
1670
1671   err = get_public_key (app, keyno);
1672   if (err)
1673     goto leave;
1674
1675   assert (keyno >= 0 && keyno <= 2);
1676   if (!app->app_local->pk[keyno].key)
1677     goto leave; /* No such key - ignore. */
1678
1679   err = keygrip_from_canon_sexp (app->app_local->pk[keyno].key,
1680                                  app->app_local->pk[keyno].keylen,
1681                                  grip);
1682   if (err)
1683     goto leave;
1684
1685   bin2hex (grip, 20, gripstr);
1686
1687   sprintf (idbuf, "OPENPGP.%d", keyno+1);
1688   send_status_info (ctrl, "KEYPAIRINFO",
1689                     gripstr, 40,
1690                     idbuf, strlen (idbuf),
1691                     NULL, (size_t)0);
1692
1693  leave:
1694 #endif /* GNUPG_MAJOR_VERSION > 1 */
1695
1696   return err;
1697 }
1698
1699
1700 /* Handle the LEARN command for OpenPGP.  */
1701 static gpg_error_t
1702 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1703 {
1704   (void)flags;
1705
1706   do_getattr (app, ctrl, "EXTCAP");
1707   do_getattr (app, ctrl, "DISP-NAME");
1708   do_getattr (app, ctrl, "DISP-LANG");
1709   do_getattr (app, ctrl, "DISP-SEX");
1710   do_getattr (app, ctrl, "PUBKEY-URL");
1711   do_getattr (app, ctrl, "LOGIN-DATA");
1712   do_getattr (app, ctrl, "KEY-FPR");
1713   if (app->card_version > 0x0100)
1714     do_getattr (app, ctrl, "KEY-TIME");
1715   do_getattr (app, ctrl, "CA-FPR");
1716   do_getattr (app, ctrl, "CHV-STATUS");
1717   do_getattr (app, ctrl, "SIG-COUNTER");
1718   if (app->app_local->extcap.private_dos)
1719     {
1720       do_getattr (app, ctrl, "PRIVATE-DO-1");
1721       do_getattr (app, ctrl, "PRIVATE-DO-2");
1722       if (app->did_chv2)
1723         do_getattr (app, ctrl, "PRIVATE-DO-3");
1724       if (app->did_chv3)
1725         do_getattr (app, ctrl, "PRIVATE-DO-4");
1726     }
1727   send_keypair_info (app, ctrl, 1);
1728   send_keypair_info (app, ctrl, 2);
1729   send_keypair_info (app, ctrl, 3);
1730   /* Note: We do not send the Cardholder Certificate, because that is
1731      relatively long and for OpenPGP applications not really needed.  */
1732   return 0;
1733 }
1734
1735
1736 /* Handle the READKEY command for OpenPGP.  On success a canonical
1737    encoded S-expression with the public key will get stored at PK and
1738    its length (for assertions) at PKLEN; the caller must release that
1739    buffer. On error PK and PKLEN are not changed and an error code is
1740    returned.  */
1741 static gpg_error_t
1742 do_readkey (app_t app, int advanced, const char *keyid,
1743             unsigned char **pk, size_t *pklen)
1744 {
1745 #if GNUPG_MAJOR_VERSION > 1
1746   gpg_error_t err;
1747   int keyno;
1748   unsigned char *buf;
1749
1750   if (!strcmp (keyid, "OPENPGP.1"))
1751     keyno = 0;
1752   else if (!strcmp (keyid, "OPENPGP.2"))
1753     keyno = 1;
1754   else if (!strcmp (keyid, "OPENPGP.3"))
1755     keyno = 2;
1756   else
1757     return gpg_error (GPG_ERR_INV_ID);
1758
1759   err = get_public_key (app, keyno);
1760   if (err)
1761     return err;
1762
1763   buf = app->app_local->pk[keyno].key;
1764   if (!buf)
1765     return gpg_error (GPG_ERR_NO_PUBKEY);
1766
1767   if (advanced)
1768     {
1769       gcry_sexp_t s_key;
1770
1771       err = gcry_sexp_new (&s_key, buf, app->app_local->pk[keyno].keylen, 0);
1772       if (err)
1773         return err;
1774
1775       *pklen = gcry_sexp_sprint (s_key, GCRYSEXP_FMT_ADVANCED, NULL, 0);
1776       *pk = xtrymalloc (*pklen);
1777       if (!*pk)
1778         {
1779           err = gpg_error_from_syserror ();
1780           *pklen = 0;
1781           return err;
1782         }
1783
1784       gcry_sexp_sprint (s_key, GCRYSEXP_FMT_ADVANCED, *pk, *pklen);
1785       gcry_sexp_release (s_key);
1786       /* Decrement for trailing '\0' */
1787       *pklen = *pklen - 1;
1788     }
1789   else
1790     {
1791       *pklen = app->app_local->pk[keyno].keylen;
1792       *pk = xtrymalloc (*pklen);
1793       if (!*pk)
1794         {
1795           err = gpg_error_from_syserror ();
1796           *pklen = 0;
1797           return err;
1798         }
1799       memcpy (*pk, buf, *pklen);
1800     }
1801
1802   return 0;
1803 #else
1804   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1805 #endif
1806 }
1807
1808 /* Read the standard certificate of an OpenPGP v2 card.  It is
1809    returned in a freshly allocated buffer with that address stored at
1810    CERT and the length of the certificate stored at CERTLEN.  CERTID
1811    needs to be set to "OPENPGP.3".  */
1812 static gpg_error_t
1813 do_readcert (app_t app, const char *certid,
1814              unsigned char **cert, size_t *certlen)
1815 {
1816 #if GNUPG_MAJOR_VERSION > 1
1817   gpg_error_t err;
1818   unsigned char *buffer;
1819   size_t buflen;
1820   void *relptr;
1821
1822   *cert = NULL;
1823   *certlen = 0;
1824   if (strcmp (certid, "OPENPGP.3"))
1825     return gpg_error (GPG_ERR_INV_ID);
1826   if (!app->app_local->extcap.is_v2)
1827     return gpg_error (GPG_ERR_NOT_FOUND);
1828
1829   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1830   if (!relptr)
1831     return gpg_error (GPG_ERR_NOT_FOUND);
1832
1833   if (!buflen)
1834     err = gpg_error (GPG_ERR_NOT_FOUND);
1835   else if (!(*cert = xtrymalloc (buflen)))
1836     err = gpg_error_from_syserror ();
1837   else
1838     {
1839       memcpy (*cert, buffer, buflen);
1840       *certlen = buflen;
1841       err  = 0;
1842     }
1843   xfree (relptr);
1844   return err;
1845 #else
1846   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1847 #endif
1848 }
1849
1850
1851 /* Decide if we use the pinpad of the reader for PIN input according
1852    to the user preference on the card, and the capability of the
1853    reader.  This routine is only called when the reader has pinpad.
1854    Returns 0 if we use pinpad, 1 otherwise.  */
1855 static int
1856 check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1857 {
1858   if (app->app_local->pinpad.specified == 0) /* No preference on card.  */
1859     {
1860       if (pininfo->fixedlen == 0) /* Reader has varlen capability.  */
1861         return 0;                 /* Then, use pinpad.  */
1862       else
1863         /*
1864          * Reader has limited capability, and it may not match PIN of
1865          * the card.
1866          */
1867         return 1;
1868     }
1869
1870   if (admin_pin)
1871     pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
1872   else
1873     pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
1874
1875   if (pininfo->fixedlen == 0    /* User requests disable pinpad.  */
1876       || pininfo->fixedlen < pininfo->minlen
1877       || pininfo->fixedlen > pininfo->maxlen
1878       /* Reader doesn't have the capability to input a PIN which
1879        * length is FIXEDLEN.  */)
1880     return 1;
1881
1882   return 0;
1883 }
1884
1885
1886 /* Verify a CHV either using using the pinentry or if possible by
1887    using a pinpad.  PINCB and PINCB_ARG describe the usual callback
1888    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1889    used with CHV1.  PINVALUE is the address of a pointer which will
1890    receive a newly allocated block with the actual PIN (this is useful
1891    in case that PIN shall be used for another verify operation).  The
1892    caller needs to free this value.  If the function returns with
1893    success and NULL is stored at PINVALUE, the caller should take this
1894    as an indication that the pinpad has been used.
1895    */
1896 static gpg_error_t
1897 verify_a_chv (app_t app,
1898               gpg_error_t (*pincb)(void*, const char *, char **),
1899               void *pincb_arg,
1900               int chvno, unsigned long sigcount, char **pinvalue)
1901 {
1902   int rc = 0;
1903   char *prompt_buffer = NULL;
1904   const char *prompt;
1905   pininfo_t pininfo;
1906   int minlen = 6;
1907
1908   assert (chvno == 1 || chvno == 2);
1909
1910   *pinvalue = NULL;
1911
1912   if (chvno == 2 && app->app_local->flags.def_chv2)
1913     {
1914       /* Special case for def_chv2 mechanism. */
1915       if (opt.verbose)
1916         log_info (_("using default PIN as %s\n"), "CHV2");
1917       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1918       if (rc)
1919         {
1920           /* Verification of CHV2 with the default PIN failed,
1921              although the card pretends to have the default PIN set as
1922              CHV2.  We better disable the def_chv2 flag now. */
1923           log_info (_("failed to use default PIN as %s: %s"
1924                       " - disabling further default use\n"),
1925                     "CHV2", gpg_strerror (rc));
1926           app->app_local->flags.def_chv2 = 0;
1927         }
1928       return rc;
1929     }
1930
1931   memset (&pininfo, 0, sizeof pininfo);
1932   pininfo.fixedlen = -1;
1933   pininfo.minlen = minlen;
1934
1935
1936   if (chvno == 1)
1937     {
1938 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1939       size_t promptsize = strlen (PROMPTSTRING) + 50;
1940
1941       prompt_buffer = xtrymalloc (promptsize);
1942       if (!prompt_buffer)
1943         return gpg_error_from_syserror ();
1944       snprintf (prompt_buffer, promptsize, PROMPTSTRING, sigcount);
1945       prompt = prompt_buffer;
1946 #undef PROMPTSTRING
1947     }
1948   else
1949     prompt = _("||Please enter the PIN");
1950
1951
1952   if (!opt.disable_pinpad
1953       && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
1954       && !check_pinpad_request (app, &pininfo, 0))
1955     {
1956       /* The reader supports the verify command through the pinpad.
1957          Note that the pincb appends a text to the prompt telling the
1958          user to use the pinpad. */
1959       rc = pincb (pincb_arg, prompt, NULL);
1960       prompt = NULL;
1961       xfree (prompt_buffer);
1962       prompt_buffer = NULL;
1963       if (rc)
1964         {
1965           log_info (_("PIN callback returned error: %s\n"),
1966                     gpg_strerror (rc));
1967           return rc;
1968         }
1969       rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
1970       /* Dismiss the prompt. */
1971       pincb (pincb_arg, NULL, NULL);
1972
1973       assert (!*pinvalue);
1974     }
1975   else
1976     {
1977       /* The reader has no pinpad or we don't want to use it. */
1978       rc = pincb (pincb_arg, prompt, pinvalue);
1979       prompt = NULL;
1980       xfree (prompt_buffer);
1981       prompt_buffer = NULL;
1982       if (rc)
1983         {
1984           log_info (_("PIN callback returned error: %s\n"),
1985                     gpg_strerror (rc));
1986           return rc;
1987         }
1988
1989       if (strlen (*pinvalue) < minlen)
1990         {
1991           log_error (_("PIN for CHV%d is too short;"
1992                        " minimum length is %d\n"), chvno, minlen);
1993           xfree (*pinvalue);
1994           *pinvalue = NULL;
1995           return gpg_error (GPG_ERR_BAD_PIN);
1996         }
1997
1998       rc = iso7816_verify (app->slot, 0x80+chvno,
1999                            *pinvalue, strlen (*pinvalue));
2000     }
2001
2002   if (rc)
2003     {
2004       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
2005       xfree (*pinvalue);
2006       *pinvalue = NULL;
2007       flush_cache_after_error (app);
2008     }
2009
2010   return rc;
2011 }
2012
2013
2014 /* Verify CHV2 if required.  Depending on the configuration of the
2015    card CHV1 will also be verified. */
2016 static gpg_error_t
2017 verify_chv2 (app_t app,
2018              gpg_error_t (*pincb)(void*, const char *, char **),
2019              void *pincb_arg)
2020 {
2021   int rc;
2022   char *pinvalue;
2023
2024   if (app->did_chv2)
2025     return 0;  /* We already verified CHV2.  */
2026
2027   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
2028   if (rc)
2029     return rc;
2030   app->did_chv2 = 1;
2031
2032   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
2033     {
2034       /* For convenience we verify CHV1 here too.  We do this only if
2035          the card is not configured to require a verification before
2036          each CHV1 controlled operation (force_chv1) and if we are not
2037          using the pinpad (PINVALUE == NULL). */
2038       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
2039       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2040         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2041       if (rc)
2042         {
2043           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2044           flush_cache_after_error (app);
2045         }
2046       else
2047         app->did_chv1 = 1;
2048     }
2049
2050   xfree (pinvalue);
2051
2052   return rc;
2053 }
2054
2055
2056 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
2057    current sdtate of the card.  */
2058 static gpg_error_t
2059 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
2060 {
2061   void *relptr;
2062   unsigned char *value;
2063   size_t valuelen;
2064   int remaining;
2065   char *prompt;
2066
2067   *r_prompt = NULL;
2068
2069   relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2070   if (!relptr || valuelen < 7)
2071     {
2072       log_error (_("error retrieving CHV status from card\n"));
2073       xfree (relptr);
2074       return gpg_error (GPG_ERR_CARD);
2075     }
2076   if (value[6] == 0)
2077     {
2078       log_info (_("card is permanently locked!\n"));
2079       xfree (relptr);
2080       return gpg_error (GPG_ERR_BAD_PIN);
2081     }
2082   remaining = value[6];
2083   xfree (relptr);
2084
2085   log_info (ngettext("%d Admin PIN attempt remaining before card"
2086                      " is permanently locked\n",
2087                      "%d Admin PIN attempts remaining before card"
2088                      " is permanently locked\n",
2089                      remaining), remaining);
2090
2091   if (remaining < 3)
2092     {
2093       /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
2094          the start of the string.  Use %%0A to force a linefeed.  */
2095       prompt = xtryasprintf (_("|A|Please enter the Admin PIN%%0A"
2096                                "[remaining attempts: %d]"), remaining);
2097     }
2098   else
2099     prompt = xtrystrdup (_("|A|Please enter the Admin PIN"));
2100
2101   if (!prompt)
2102     return gpg_error_from_syserror ();
2103
2104   *r_prompt = prompt;
2105   return 0;
2106 }
2107
2108
2109 /* Verify CHV3 if required. */
2110 static gpg_error_t
2111 verify_chv3 (app_t app,
2112              gpg_error_t (*pincb)(void*, const char *, char **),
2113              void *pincb_arg)
2114 {
2115   int rc = 0;
2116
2117 #if GNUPG_MAJOR_VERSION != 1
2118   if (!opt.allow_admin)
2119     {
2120       log_info (_("access to admin commands is not configured\n"));
2121       return gpg_error (GPG_ERR_EACCES);
2122     }
2123 #endif
2124
2125   if (!app->did_chv3)
2126     {
2127       pininfo_t pininfo;
2128       int minlen = 8;
2129       char *prompt;
2130
2131       memset (&pininfo, 0, sizeof pininfo);
2132       pininfo.fixedlen = -1;
2133       pininfo.minlen = minlen;
2134
2135       rc = build_enter_admin_pin_prompt (app, &prompt);
2136       if (rc)
2137         return rc;
2138
2139       if (!opt.disable_pinpad
2140           && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
2141           && !check_pinpad_request (app, &pininfo, 1))
2142         {
2143           /* The reader supports the verify command through the pinpad. */
2144           rc = pincb (pincb_arg, prompt, NULL);
2145           xfree (prompt);
2146           prompt = NULL;
2147           if (rc)
2148             {
2149               log_info (_("PIN callback returned error: %s\n"),
2150                         gpg_strerror (rc));
2151               return rc;
2152             }
2153           rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
2154           /* Dismiss the prompt. */
2155           pincb (pincb_arg, NULL, NULL);
2156         }
2157       else
2158         {
2159           char *pinvalue;
2160
2161           rc = pincb (pincb_arg, prompt, &pinvalue);
2162           xfree (prompt);
2163           prompt = NULL;
2164           if (rc)
2165             {
2166               log_info (_("PIN callback returned error: %s\n"),
2167                         gpg_strerror (rc));
2168               return rc;
2169             }
2170
2171           if (strlen (pinvalue) < minlen)
2172             {
2173               log_error (_("PIN for CHV%d is too short;"
2174                            " minimum length is %d\n"), 3, minlen);
2175               xfree (pinvalue);
2176               return gpg_error (GPG_ERR_BAD_PIN);
2177             }
2178
2179           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
2180           xfree (pinvalue);
2181         }
2182
2183       if (rc)
2184         {
2185           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
2186           flush_cache_after_error (app);
2187           return rc;
2188         }
2189       app->did_chv3 = 1;
2190     }
2191   return rc;
2192 }
2193
2194
2195 /* Handle the SETATTR operation. All arguments are already basically
2196    checked. */
2197 static gpg_error_t
2198 do_setattr (app_t app, const char *name,
2199             gpg_error_t (*pincb)(void*, const char *, char **),
2200             void *pincb_arg,
2201             const unsigned char *value, size_t valuelen)
2202 {
2203   gpg_error_t rc;
2204   int idx;
2205   static struct {
2206     const char *name;
2207     int tag;
2208     int need_chv;
2209     int special;
2210     unsigned int need_v2:1;
2211   } table[] = {
2212     { "DISP-NAME",    0x005B, 3 },
2213     { "LOGIN-DATA",   0x005E, 3, 2 },
2214     { "DISP-LANG",    0x5F2D, 3 },
2215     { "DISP-SEX",     0x5F35, 3 },
2216     { "PUBKEY-URL",   0x5F50, 3 },
2217     { "CHV-STATUS-1", 0x00C4, 3, 1 },
2218     { "CA-FPR-1",     0x00CA, 3 },
2219     { "CA-FPR-2",     0x00CB, 3 },
2220     { "CA-FPR-3",     0x00CC, 3 },
2221     { "PRIVATE-DO-1", 0x0101, 2 },
2222     { "PRIVATE-DO-2", 0x0102, 3 },
2223     { "PRIVATE-DO-3", 0x0103, 2 },
2224     { "PRIVATE-DO-4", 0x0104, 3 },
2225     { "CERT-3",       0x7F21, 3, 0, 1 },
2226     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
2227     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
2228     { "KEY-ATTR",     0,      0, 3, 1 },
2229     { "AESKEY",       0x00D5, 3, 0, 1 },
2230     { NULL, 0 }
2231   };
2232   int exmode;
2233
2234   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
2235     ;
2236   if (!table[idx].name)
2237     return gpg_error (GPG_ERR_INV_NAME);
2238   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
2239     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
2240
2241   if (table[idx].special == 3)
2242     return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
2243
2244   switch (table[idx].need_chv)
2245     {
2246     case 2:
2247       rc = verify_chv2 (app, pincb, pincb_arg);
2248       break;
2249     case 3:
2250       rc = verify_chv3 (app, pincb, pincb_arg);
2251       break;
2252     default:
2253       rc = 0;
2254     }
2255   if (rc)
2256     return rc;
2257
2258   /* Flush the cache before writing it, so that the next get operation
2259      will reread the data from the card and thus get synced in case of
2260      errors (e.g. data truncated by the card). */
2261   flush_cache_item (app, table[idx].tag);
2262
2263   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
2264     exmode = 1;    /* Use extended length w/o a limit.  */
2265   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
2266     exmode = -254; /* Command chaining with max. 254 bytes.  */
2267   else
2268     exmode = 0;
2269   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
2270   if (rc)
2271     log_error ("failed to set '%s': %s\n", table[idx].name, gpg_strerror (rc));
2272
2273   if (table[idx].special == 1)
2274     app->force_chv1 = (valuelen && *value == 0);
2275   else if (table[idx].special == 2)
2276     parse_login_data (app);
2277
2278   return rc;
2279 }
2280
2281
2282 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
2283    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
2284    PINCB and PINCB_ARG are the usual arguments for the pinentry
2285    callback.  */
2286 static gpg_error_t
2287 do_writecert (app_t app, ctrl_t ctrl,
2288               const char *certidstr,
2289               gpg_error_t (*pincb)(void*, const char *, char **),
2290               void *pincb_arg,
2291               const unsigned char *certdata, size_t certdatalen)
2292 {
2293   (void)ctrl;
2294 #if GNUPG_MAJOR_VERSION > 1
2295   if (strcmp (certidstr, "OPENPGP.3"))
2296     return gpg_error (GPG_ERR_INV_ID);
2297   if (!certdata || !certdatalen)
2298     return gpg_error (GPG_ERR_INV_ARG);
2299   if (!app->app_local->extcap.is_v2)
2300     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2301   if (certdatalen > app->app_local->extcap.max_certlen_3)
2302     return gpg_error (GPG_ERR_TOO_LARGE);
2303   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
2304 #else
2305   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2306 #endif
2307 }
2308
2309
2310
2311 /* Handle the PASSWD command.  The following combinations are
2312    possible:
2313
2314     Flags  CHVNO Vers.  Description
2315     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
2316     RESET    1   2      Verify PW3 and set a new PW1.
2317     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
2318     RESET    2   2      Verify PW3 and set a new Reset Code.
2319     RESET    3   any    Returns GPG_ERR_INV_ID.
2320      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
2321      -       1   2      Verify PW1 and set a new PW1.
2322      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
2323      -       2   2      Verify Reset Code and set a new PW1.
2324      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
2325  */
2326 static gpg_error_t
2327 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
2328                unsigned int flags,
2329                gpg_error_t (*pincb)(void*, const char *, char **),
2330                void *pincb_arg)
2331 {
2332   int rc = 0;
2333   int chvno = atoi (chvnostr);
2334   char *resetcode = NULL;
2335   char *oldpinvalue = NULL;
2336   char *pinvalue = NULL;
2337   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2338   int set_resetcode = 0;
2339   pininfo_t pininfo;
2340   int use_pinpad = 0;
2341   int minlen = 6;
2342
2343   (void)ctrl;
2344   memset (&pininfo, 0, sizeof pininfo);
2345   pininfo.fixedlen = -1;
2346   pininfo.minlen = minlen;
2347
2348   if (reset_mode && chvno == 3)
2349     {
2350       rc = gpg_error (GPG_ERR_INV_ID);
2351       goto leave;
2352     }
2353
2354   if (!app->app_local->extcap.is_v2)
2355     {
2356       /* Version 1 cards.  */
2357
2358       if (reset_mode || chvno == 3)
2359         {
2360           /* We always require that the PIN is entered. */
2361           app->did_chv3 = 0;
2362           rc = verify_chv3 (app, pincb, pincb_arg);
2363           if (rc)
2364             goto leave;
2365         }
2366       else if (chvno == 1 || chvno == 2)
2367         {
2368           /* On a v1.x card CHV1 and CVH2 should always have the same
2369              value, thus we enforce it here.  */
2370           int save_force = app->force_chv1;
2371
2372           app->force_chv1 = 0;
2373           app->did_chv1 = 0;
2374           app->did_chv2 = 0;
2375           rc = verify_chv2 (app, pincb, pincb_arg);
2376           app->force_chv1 = save_force;
2377           if (rc)
2378             goto leave;
2379         }
2380       else
2381         {
2382           rc = gpg_error (GPG_ERR_INV_ID);
2383           goto leave;
2384         }
2385     }
2386   else
2387     {
2388       /* Version 2 cards.  */
2389
2390       if (!opt.disable_pinpad
2391           && !iso7816_check_pinpad (app->slot,
2392                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2393           && !check_pinpad_request (app, &pininfo, chvno == 3))
2394         use_pinpad = 1;
2395
2396       if (reset_mode)
2397         {
2398           /* To reset a PIN the Admin PIN is required. */
2399           use_pinpad = 0;
2400           app->did_chv3 = 0;
2401           rc = verify_chv3 (app, pincb, pincb_arg);
2402           if (rc)
2403             goto leave;
2404
2405           if (chvno == 2)
2406             set_resetcode = 1;
2407         }
2408       else if (chvno == 1 || chvno == 3)
2409         {
2410           if (!use_pinpad)
2411             {
2412               char *promptbuf = NULL;
2413               const char *prompt;
2414
2415               if (chvno == 3)
2416                 {
2417                   minlen = 8;
2418                   rc = build_enter_admin_pin_prompt (app, &promptbuf);
2419                   if (rc)
2420                     goto leave;
2421                   prompt = promptbuf;
2422                 }
2423               else
2424                 prompt = _("||Please enter the PIN");
2425               rc = pincb (pincb_arg, prompt, &oldpinvalue);
2426               xfree (promptbuf);
2427               promptbuf = NULL;
2428               if (rc)
2429                 {
2430                   log_info (_("PIN callback returned error: %s\n"),
2431                             gpg_strerror (rc));
2432                   goto leave;
2433                 }
2434
2435               if (strlen (oldpinvalue) < minlen)
2436                 {
2437                   log_info (_("PIN for CHV%d is too short;"
2438                               " minimum length is %d\n"), chvno, minlen);
2439                   rc = gpg_error (GPG_ERR_BAD_PIN);
2440                   goto leave;
2441                 }
2442             }
2443         }
2444       else if (chvno == 2)
2445         {
2446           /* There is no PW2 for v2 cards.  We use this condition to
2447              allow a PW reset using the Reset Code.  */
2448           void *relptr;
2449           unsigned char *value;
2450           size_t valuelen;
2451           int remaining;
2452
2453           use_pinpad = 0;
2454           minlen = 8;
2455           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2456           if (!relptr || valuelen < 7)
2457             {
2458               log_error (_("error retrieving CHV status from card\n"));
2459               xfree (relptr);
2460               rc = gpg_error (GPG_ERR_CARD);
2461               goto leave;
2462             }
2463           remaining = value[5];
2464           xfree (relptr);
2465           if (!remaining)
2466             {
2467               log_error (_("Reset Code not or not anymore available\n"));
2468               rc = gpg_error (GPG_ERR_BAD_PIN);
2469               goto leave;
2470             }
2471
2472           rc = pincb (pincb_arg,
2473                       _("||Please enter the Reset Code for the card"),
2474                       &resetcode);
2475           if (rc)
2476             {
2477               log_info (_("PIN callback returned error: %s\n"),
2478                         gpg_strerror (rc));
2479               goto leave;
2480             }
2481           if (strlen (resetcode) < minlen)
2482             {
2483               log_info (_("Reset Code is too short; minimum length is %d\n"),
2484                         minlen);
2485               rc = gpg_error (GPG_ERR_BAD_PIN);
2486               goto leave;
2487             }
2488         }
2489       else
2490         {
2491           rc = gpg_error (GPG_ERR_INV_ID);
2492           goto leave;
2493         }
2494     }
2495
2496   if (chvno == 3)
2497     app->did_chv3 = 0;
2498   else
2499     app->did_chv1 = app->did_chv2 = 0;
2500
2501   if (!use_pinpad)
2502     {
2503       /* TRANSLATORS: Do not translate the "|*|" prefixes but
2504          keep it at the start of the string.  We need this elsewhere
2505          to get some infos on the string. */
2506       rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2507                   chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2508                   &pinvalue);
2509       if (rc)
2510         {
2511           log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2512           goto leave;
2513         }
2514     }
2515
2516
2517   if (resetcode)
2518     {
2519       char *buffer;
2520
2521       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2522       if (!buffer)
2523         rc = gpg_error_from_syserror ();
2524       else
2525         {
2526           strcpy (stpcpy (buffer, resetcode), pinvalue);
2527           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2528                                                     buffer, strlen (buffer));
2529           wipememory (buffer, strlen (buffer));
2530           xfree (buffer);
2531         }
2532     }
2533   else if (set_resetcode)
2534     {
2535       if (strlen (pinvalue) < 8)
2536         {
2537           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2538           rc = gpg_error (GPG_ERR_BAD_PIN);
2539         }
2540       else
2541         rc = iso7816_put_data (app->slot, 0, 0xD3,
2542                                pinvalue, strlen (pinvalue));
2543     }
2544   else if (reset_mode)
2545     {
2546       rc = iso7816_reset_retry_counter (app->slot, 0x81,
2547                                         pinvalue, strlen (pinvalue));
2548       if (!rc && !app->app_local->extcap.is_v2)
2549         rc = iso7816_reset_retry_counter (app->slot, 0x82,
2550                                           pinvalue, strlen (pinvalue));
2551     }
2552   else if (!app->app_local->extcap.is_v2)
2553     {
2554       /* Version 1 cards.  */
2555       if (chvno == 1 || chvno == 2)
2556         {
2557           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2558                                               pinvalue, strlen (pinvalue));
2559           if (!rc)
2560             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2561                                                 pinvalue, strlen (pinvalue));
2562         }
2563       else /* CHVNO == 3 */
2564         {
2565           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2566                                               pinvalue, strlen (pinvalue));
2567         }
2568     }
2569   else
2570     {
2571       /* Version 2 cards.  */
2572       assert (chvno == 1 || chvno == 3);
2573
2574       if (use_pinpad)
2575         {
2576           rc = pincb (pincb_arg,
2577                       chvno == 3 ?
2578                       _("||Please enter the Admin PIN and New Admin PIN") :
2579                       _("||Please enter the PIN and New PIN"), NULL);
2580           if (rc)
2581             {
2582               log_info (_("PIN callback returned error: %s\n"),
2583                         gpg_strerror (rc));
2584               goto leave;
2585             }
2586           rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
2587                                                  &pininfo);
2588           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2589         }
2590       else
2591         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2592                                             oldpinvalue, strlen (oldpinvalue),
2593                                             pinvalue, strlen (pinvalue));
2594     }
2595
2596   if (pinvalue)
2597     {
2598       wipememory (pinvalue, strlen (pinvalue));
2599       xfree (pinvalue);
2600     }
2601   if (rc)
2602     flush_cache_after_error (app);
2603
2604  leave:
2605   if (resetcode)
2606     {
2607       wipememory (resetcode, strlen (resetcode));
2608       xfree (resetcode);
2609     }
2610   if (oldpinvalue)
2611     {
2612       wipememory (oldpinvalue, strlen (oldpinvalue));
2613       xfree (oldpinvalue);
2614     }
2615   return rc;
2616 }
2617
2618
2619 /* Check whether a key already exists.  KEYIDX is the index of the key
2620    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2621    error returned if the key already exists.  The flag GENERATING is
2622    only used to print correct messages. */
2623 static gpg_error_t
2624 does_key_exist (app_t app, int keyidx, int generating, int force)
2625 {
2626   const unsigned char *fpr;
2627   unsigned char *buffer;
2628   size_t buflen, n;
2629   int i;
2630
2631   assert (keyidx >=0 && keyidx <= 2);
2632
2633   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2634     {
2635       log_error (_("error reading application data\n"));
2636       return gpg_error (GPG_ERR_GENERAL);
2637     }
2638   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2639   if (!fpr || n < 60)
2640     {
2641       log_error (_("error reading fingerprint DO\n"));
2642       xfree (buffer);
2643       return gpg_error (GPG_ERR_GENERAL);
2644     }
2645   fpr += 20*keyidx;
2646   for (i=0; i < 20 && !fpr[i]; i++)
2647     ;
2648   xfree (buffer);
2649   if (i!=20 && !force)
2650     {
2651       log_error (_("key already exists\n"));
2652       return gpg_error (GPG_ERR_EEXIST);
2653     }
2654   else if (i!=20)
2655     log_info (_("existing key will be replaced\n"));
2656   else if (generating)
2657     log_info (_("generating new key\n"));
2658   else
2659     log_info (_("writing new key\n"));
2660   return 0;
2661 }
2662
2663
2664 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2665    of tag and length.  A LENGTH greater than 65535 is truncated. */
2666 static size_t
2667 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2668 {
2669   unsigned char *p = buffer;
2670
2671   assert (tag <= 0xffff);
2672   if ( tag > 0xff )
2673     *p++ = tag >> 8;
2674   *p++ = tag;
2675   if (length < 128)
2676     *p++ = length;
2677   else if (length < 256)
2678     {
2679       *p++ = 0x81;
2680       *p++ = length;
2681     }
2682   else
2683     {
2684       if (length > 0xffff)
2685         length = 0xffff;
2686       *p++ = 0x82;
2687       *p++ = length >> 8;
2688       *p++ = length;
2689     }
2690
2691   return p - buffer;
2692 }
2693
2694
2695 static gpg_error_t
2696 build_privkey_template (app_t app, int keyno,
2697                         const unsigned char *rsa_n, size_t rsa_n_len,
2698                         const unsigned char *rsa_e, size_t rsa_e_len,
2699                         const unsigned char *rsa_p, size_t rsa_p_len,
2700                         const unsigned char *rsa_q, size_t rsa_q_len,
2701                         const unsigned char *rsa_u, size_t rsa_u_len,
2702                         const unsigned char *rsa_dp, size_t rsa_dp_len,
2703                         const unsigned char *rsa_dq, size_t rsa_dq_len,
2704                         unsigned char **result, size_t *resultlen)
2705 {
2706   size_t rsa_e_reqlen;
2707   unsigned char privkey[7*(1+3+3)];
2708   size_t privkey_len;
2709   unsigned char exthdr[2+2+3];
2710   size_t exthdr_len;
2711   unsigned char suffix[2+3];
2712   size_t suffix_len;
2713   unsigned char *tp;
2714   size_t datalen;
2715   unsigned char *template;
2716   size_t template_size;
2717
2718   *result = NULL;
2719   *resultlen = 0;
2720
2721   switch (app->app_local->keyattr[keyno].rsa.format)
2722     {
2723     case RSA_STD:
2724     case RSA_STD_N:
2725     case RSA_CRT:
2726     case RSA_CRT_N:
2727       break;
2728
2729     default:
2730       return gpg_error (GPG_ERR_INV_VALUE);
2731     }
2732
2733   /* Get the required length for E. Rounded up to the nearest byte  */
2734   rsa_e_reqlen = (app->app_local->keyattr[keyno].rsa.e_bits + 7) / 8;
2735   assert (rsa_e_len <= rsa_e_reqlen);
2736
2737   /* Build the 7f48 cardholder private key template.  */
2738   datalen = 0;
2739   tp = privkey;
2740
2741   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2742   datalen += rsa_e_reqlen;
2743
2744   tp += add_tlv (tp, 0x92, rsa_p_len);
2745   datalen += rsa_p_len;
2746
2747   tp += add_tlv (tp, 0x93, rsa_q_len);
2748   datalen += rsa_q_len;
2749
2750   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
2751       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2752     {
2753       tp += add_tlv (tp, 0x94, rsa_u_len);
2754       datalen += rsa_u_len;
2755       tp += add_tlv (tp, 0x95, rsa_dp_len);
2756       datalen += rsa_dp_len;
2757       tp += add_tlv (tp, 0x96, rsa_dq_len);
2758       datalen += rsa_dq_len;
2759     }
2760
2761   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
2762       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2763     {
2764       tp += add_tlv (tp, 0x97, rsa_n_len);
2765       datalen += rsa_n_len;
2766     }
2767   privkey_len = tp - privkey;
2768
2769   /* Build the extended header list without the private key template.  */
2770   tp = exthdr;
2771   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2772   *tp++ = 0;
2773   tp += add_tlv (tp, 0x7f48, privkey_len);
2774   exthdr_len = tp - exthdr;
2775
2776   /* Build the 5f48 suffix of the data.  */
2777   tp = suffix;
2778   tp += add_tlv (tp, 0x5f48, datalen);
2779   suffix_len = tp - suffix;
2780
2781   /* Now concatenate everything.  */
2782   template_size = (1 + 3   /* 0x4d and len. */
2783                    + exthdr_len
2784                    + privkey_len
2785                    + suffix_len
2786                    + datalen);
2787   tp = template = xtrymalloc_secure (template_size);
2788   if (!template)
2789     return gpg_error_from_syserror ();
2790
2791   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2792   memcpy (tp, exthdr, exthdr_len);
2793   tp += exthdr_len;
2794   memcpy (tp, privkey, privkey_len);
2795   tp += privkey_len;
2796   memcpy (tp, suffix, suffix_len);
2797   tp += suffix_len;
2798
2799   memcpy (tp, rsa_e, rsa_e_len);
2800   if (rsa_e_len < rsa_e_reqlen)
2801     {
2802       /* Right justify E. */
2803       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2804       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2805     }
2806   tp += rsa_e_reqlen;
2807
2808   memcpy (tp, rsa_p, rsa_p_len);
2809   tp += rsa_p_len;
2810
2811   memcpy (tp, rsa_q, rsa_q_len);
2812   tp += rsa_q_len;
2813
2814   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
2815       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2816     {
2817       memcpy (tp, rsa_u, rsa_u_len);
2818       tp += rsa_u_len;
2819       memcpy (tp, rsa_dp, rsa_dp_len);
2820       tp += rsa_dp_len;
2821       memcpy (tp, rsa_dq, rsa_dq_len);
2822       tp += rsa_dq_len;
2823     }
2824
2825   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
2826       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2827     {
2828       memcpy (tp, rsa_n, rsa_n_len);
2829       tp += rsa_n_len;
2830     }
2831
2832   /* Sanity check.  We don't know the exact length because we
2833      allocated 3 bytes for the first length header.  */
2834   assert (tp - template <= template_size);
2835
2836   *result = template;
2837   *resultlen = tp - template;
2838   return 0;
2839 }
2840
2841 static gpg_error_t
2842 build_ecc_privkey_template (app_t app, int keyno,
2843                             const unsigned char *ecc_d, size_t ecc_d_len,
2844                             const unsigned char *ecc_q, size_t ecc_q_len,
2845                             unsigned char **result, size_t *resultlen)
2846 {
2847   unsigned char privkey[2+2];
2848   size_t privkey_len;
2849   unsigned char exthdr[2+2+1];
2850   size_t exthdr_len;
2851   unsigned char suffix[2+1];
2852   size_t suffix_len;
2853   unsigned char *tp;
2854   size_t datalen;
2855   unsigned char *template;
2856   size_t template_size;
2857   int pubkey_required;
2858
2859   pubkey_required = !!(app->app_local->keyattr[keyno].ecc.flags
2860                        & ECC_FLAG_PUBKEY);
2861
2862   *result = NULL;
2863   *resultlen = 0;
2864
2865   /* Build the 7f48 cardholder private key template.  */
2866   datalen = 0;
2867   tp = privkey;
2868
2869   tp += add_tlv (tp, 0x92, ecc_d_len);
2870   datalen += ecc_d_len;
2871
2872   if (pubkey_required)
2873     {
2874       tp += add_tlv (tp, 0x99, ecc_q_len);
2875       datalen += ecc_q_len;
2876     }
2877
2878   privkey_len = tp - privkey;
2879
2880
2881   /* Build the extended header list without the private key template.  */
2882   tp = exthdr;
2883   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2884   *tp++ = 0;
2885   tp += add_tlv (tp, 0x7f48, privkey_len);
2886   exthdr_len = tp - exthdr;
2887
2888   /* Build the 5f48 suffix of the data.  */
2889   tp = suffix;
2890   tp += add_tlv (tp, 0x5f48, datalen);
2891   suffix_len = tp - suffix;
2892
2893   /* Now concatenate everything.  */
2894   template_size = (1 + 1   /* 0x4d and len. */
2895                    + exthdr_len
2896                    + privkey_len
2897                    + suffix_len
2898                    + datalen);
2899   if (exthdr_len + privkey_len + suffix_len + datalen >= 128)
2900     template_size++;
2901   tp = template = xtrymalloc_secure (template_size);
2902   if (!template)
2903     return gpg_error_from_syserror ();
2904
2905   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2906   memcpy (tp, exthdr, exthdr_len);
2907   tp += exthdr_len;
2908   memcpy (tp, privkey, privkey_len);
2909   tp += privkey_len;
2910   memcpy (tp, suffix, suffix_len);
2911   tp += suffix_len;
2912
2913   memcpy (tp, ecc_d, ecc_d_len);
2914   tp += ecc_d_len;
2915
2916   if (pubkey_required)
2917     {
2918       memcpy (tp, ecc_q, ecc_q_len);
2919       tp += ecc_q_len;
2920     }
2921
2922   assert (tp - template == template_size);
2923
2924   *result = template;
2925   *resultlen = tp - template;
2926   return 0;
2927 }
2928
2929
2930 /* Helper for do_writekley to change the size of a key.  Not ethat
2931    this deletes the entire key without asking.  */
2932 static gpg_error_t
2933 change_keyattr (app_t app, int keyno, const unsigned char *buf, size_t buflen,
2934                 gpg_error_t (*pincb)(void*, const char *, char **),
2935                 void *pincb_arg)
2936 {
2937   gpg_error_t err;
2938
2939   assert (keyno >=0 && keyno <= 2);
2940
2941   /* Prepare for storing the key.  */
2942   err = verify_chv3 (app, pincb, pincb_arg);
2943   if (err)
2944     return err;
2945
2946   /* Change the attribute.  */
2947   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buf, buflen);
2948   if (err)
2949     log_error ("error changing key attribute (key=%d)\n", keyno+1);
2950   else
2951     log_info ("key attribute changed (key=%d)\n", keyno+1);
2952   flush_cache (app);
2953   parse_algorithm_attribute (app, keyno);
2954   app->did_chv1 = 0;
2955   app->did_chv2 = 0;
2956   app->did_chv3 = 0;
2957   return err;
2958 }
2959
2960
2961 static gpg_error_t
2962 change_rsa_keyattr (app_t app, int keyno, unsigned int nbits,
2963                     gpg_error_t (*pincb)(void*, const char *, char **),
2964                     void *pincb_arg)
2965 {
2966   gpg_error_t err = 0;
2967   unsigned char *buf;
2968   size_t buflen;
2969   void *relptr;
2970
2971   /* Read the current attributes into a buffer.  */
2972   relptr = get_one_do (app, 0xC1+keyno, &buf, &buflen, NULL);
2973   if (!relptr)
2974     err = gpg_error (GPG_ERR_CARD);
2975   else if (buflen < 6 || buf[0] != PUBKEY_ALGO_RSA)
2976     {
2977       /* Attriutes too short or not an RSA key.  */
2978       xfree (relptr);
2979       err = gpg_error (GPG_ERR_CARD);
2980     }
2981   else
2982     {
2983       /* We only change n_bits and don't touch anything else.  Before we
2984          do so, we round up NBITS to a sensible way in the same way as
2985          gpg's key generation does it.  This may help to sort out problems
2986          with a few bits too short keys.  */
2987       nbits = ((nbits + 31) / 32) * 32;
2988       buf[1] = (nbits >> 8);
2989       buf[2] = nbits;
2990       err = change_keyattr (app, keyno, buf, buflen, pincb, pincb_arg);
2991       xfree (relptr);
2992     }
2993
2994   return err;
2995 }
2996
2997
2998 /* Helper to process an setattr command for name KEY-ATTR.
2999    In (VALUE,VALUELEN), it expects following string:
3000         RSA: "--force <key> <algo> rsa<nbits>"
3001         ECC: "--force <key> <algo> <curvename>"
3002   */
3003 static gpg_error_t
3004 change_keyattr_from_string (app_t app,
3005                             gpg_error_t (*pincb)(void*, const char *, char **),
3006                             void *pincb_arg,
3007                             const void *value, size_t valuelen)
3008 {
3009   gpg_error_t err = 0;
3010   char *string;
3011   int key, keyno, algo;
3012   int n = 0;
3013
3014   /* VALUE is expected to be a string but not guaranteed to be
3015      terminated.  Thus copy it to an allocated buffer first. */
3016   string = xtrymalloc (valuelen+1);
3017   if (!string)
3018     return gpg_error_from_syserror ();
3019   memcpy (string, value, valuelen);
3020   string[valuelen] = 0;
3021
3022   /* Because this function deletes the key we require the string
3023      "--force" in the data to make clear that something serious might
3024      happen.  */
3025   sscanf (string, "--force %d %d %n", &key, &algo, &n);
3026   if (n < 12)
3027     {
3028       err = gpg_error (GPG_ERR_INV_DATA);
3029       goto leave;
3030     }
3031
3032   keyno = key - 1;
3033   if (keyno < 0 || keyno > 2)
3034     err = gpg_error (GPG_ERR_INV_ID);
3035   else if (algo == PUBKEY_ALGO_RSA)
3036     {
3037       unsigned int nbits;
3038
3039       errno = 0;
3040       nbits = strtoul (string+n+3, NULL, 10);
3041       if (errno)
3042         err = gpg_error (GPG_ERR_INV_DATA);
3043       else if (nbits < 1024)
3044         err = gpg_error (GPG_ERR_TOO_SHORT);
3045       else if (nbits > 4096)
3046         err = gpg_error (GPG_ERR_TOO_LARGE);
3047       else
3048         err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3049     }
3050   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
3051            || algo == PUBKEY_ALGO_EDDSA)
3052     {
3053       const char *oidstr;
3054       gcry_mpi_t oid;
3055       const unsigned char *oidbuf;
3056       size_t oid_len;
3057
3058       oidstr = openpgp_curve_to_oid (string+n, NULL);
3059       if (!oidstr)
3060         {
3061           err = gpg_error (GPG_ERR_INV_DATA);
3062           goto leave;
3063         }
3064
3065       err = openpgp_oid_from_str (oidstr, &oid);
3066       if (err)
3067         goto leave;
3068
3069       oidbuf = gcry_mpi_get_opaque (oid, &n);
3070       oid_len = (n+7)/8;
3071
3072       /* We have enough room at STRING.  */
3073       string[0] = algo;
3074       memcpy (string+1, oidbuf+1, oid_len-1);
3075       err = change_keyattr (app, keyno, string, oid_len, pincb, pincb_arg);
3076       gcry_mpi_release (oid);
3077     }
3078   else
3079     err = gpg_error (GPG_ERR_PUBKEY_ALGO);
3080
3081  leave:
3082   xfree (string);
3083   return err;
3084 }
3085
3086
3087 static gpg_error_t
3088 rsa_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3089               void *pincb_arg, int keyno,
3090               const unsigned char *buf, size_t buflen, int depth)
3091 {
3092   gpg_error_t err;
3093   const unsigned char *tok;
3094   size_t toklen;
3095   int last_depth1, last_depth2;
3096   const unsigned char *rsa_n = NULL;
3097   const unsigned char *rsa_e = NULL;
3098   const unsigned char *rsa_p = NULL;
3099   const unsigned char *rsa_q = NULL;
3100   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3101   unsigned int nbits;
3102   unsigned int maxbits;
3103   unsigned char *template = NULL;
3104   unsigned char *tp;
3105   size_t template_len;
3106   unsigned char fprbuf[20];
3107   u32 created_at = 0;
3108
3109   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
3110     {
3111       log_error (_("unsupported algorithm: %s"), "RSA");
3112       err = gpg_error (GPG_ERR_INV_VALUE);
3113       goto leave;
3114     }
3115
3116   last_depth1 = depth;
3117   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3118          && depth && depth >= last_depth1)
3119     {
3120       if (tok)
3121         {
3122           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3123           goto leave;
3124         }
3125       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3126         goto leave;
3127       if (tok && toklen == 1)
3128         {
3129           const unsigned char **mpi;
3130           size_t *mpi_len;
3131
3132           switch (*tok)
3133             {
3134             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
3135             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
3136             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
3137             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
3138             default: mpi = NULL;  mpi_len = NULL; break;
3139             }
3140           if (mpi && *mpi)
3141             {
3142               err = gpg_error (GPG_ERR_DUP_VALUE);
3143               goto leave;
3144             }
3145           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3146             goto leave;
3147           if (tok && mpi)
3148             {
3149               /* Strip off leading zero bytes and save. */
3150               for (;toklen && !*tok; toklen--, tok++)
3151                 ;
3152               *mpi = tok;
3153               *mpi_len = toklen;
3154             }
3155         }
3156       /* Skip until end of list. */
3157       last_depth2 = depth;
3158       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3159              && depth && depth >= last_depth2)
3160         ;
3161       if (err)
3162         goto leave;
3163     }
3164   /* Parse other attributes. */
3165   last_depth1 = depth;
3166   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3167          && depth && depth >= last_depth1)
3168     {
3169       if (tok)
3170         {
3171           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3172           goto leave;
3173         }
3174       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3175         goto leave;
3176       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3177         {
3178           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3179             goto leave;
3180           if (tok)
3181             {
3182               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3183                    tok++, toklen--)
3184                 created_at = created_at*10 + (*tok - '0');
3185             }
3186         }
3187       /* Skip until end of list. */
3188       last_depth2 = depth;
3189       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3190              && depth && depth >= last_depth2)
3191         ;
3192       if (err)
3193         goto leave;
3194     }
3195
3196
3197   /* Check that we have all parameters and that they match the card
3198      description. */
3199   if (!created_at)
3200     {
3201       log_error (_("creation timestamp missing\n"));
3202       err = gpg_error (GPG_ERR_INV_VALUE);
3203       goto leave;
3204     }
3205
3206   maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3207   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
3208   if (opt.verbose)
3209     log_info ("RSA modulus size is %u bits (%u bytes)\n",
3210               nbits, (unsigned int)rsa_n_len);
3211   if (nbits && nbits != maxbits
3212       && app->app_local->extcap.algo_attr_change)
3213     {
3214       /* Try to switch the key to a new length.  */
3215       err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3216       if (!err)
3217         maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3218     }
3219   if (nbits != maxbits)
3220     {
3221       log_error (_("RSA modulus missing or not of size %d bits\n"),
3222                  (int)maxbits);
3223       err = gpg_error (GPG_ERR_BAD_SECKEY);
3224       goto leave;
3225     }
3226
3227   maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
3228   if (maxbits > 32 && !app->app_local->extcap.is_v2)
3229     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
3230   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
3231   if (nbits < 2 || nbits > maxbits)
3232     {
3233       log_error (_("RSA public exponent missing or larger than %d bits\n"),
3234                  (int)maxbits);
3235       err = gpg_error (GPG_ERR_BAD_SECKEY);
3236       goto leave;
3237     }
3238
3239   maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
3240   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
3241   if (nbits != maxbits)
3242     {
3243       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3244                  "P", (int)maxbits);
3245       err = gpg_error (GPG_ERR_BAD_SECKEY);
3246       goto leave;
3247     }
3248   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
3249   if (nbits != maxbits)
3250     {
3251       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3252                  "Q", (int)maxbits);
3253       err = gpg_error (GPG_ERR_BAD_SECKEY);
3254       goto leave;
3255     }
3256
3257   /* We need to remove the cached public key.  */
3258   xfree (app->app_local->pk[keyno].key);
3259   app->app_local->pk[keyno].key = NULL;
3260   app->app_local->pk[keyno].keylen = 0;
3261   app->app_local->pk[keyno].read_done = 0;
3262
3263
3264   if (app->app_local->extcap.is_v2)
3265     {
3266       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
3267       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
3268       gcry_mpi_t mpi_e, mpi_p, mpi_q;
3269       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
3270       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
3271       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
3272       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
3273       int exmode;
3274
3275       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
3276       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
3277       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
3278       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
3279
3280       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
3281       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
3282       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
3283       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
3284       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
3285
3286       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
3287       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
3288       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
3289
3290       gcry_mpi_release (mpi_e);
3291       gcry_mpi_release (mpi_p);
3292       gcry_mpi_release (mpi_q);
3293       gcry_mpi_release (mpi_u);
3294       gcry_mpi_release (mpi_dp);
3295       gcry_mpi_release (mpi_dq);
3296       gcry_mpi_release (mpi_tmp);
3297
3298       /* Build the private key template as described in section 4.3.3.7 of
3299          the OpenPGP card specs version 2.0.  */
3300       err = build_privkey_template (app, keyno,
3301                                     rsa_n, rsa_n_len,
3302                                     rsa_e, rsa_e_len,
3303                                     rsa_p, rsa_p_len,
3304                                     rsa_q, rsa_q_len,
3305                                     rsa_u, rsa_u_len,
3306                                     rsa_dp, rsa_dp_len,
3307                                     rsa_dq, rsa_dq_len,
3308                                     &template, &template_len);
3309       xfree(rsa_u);
3310       xfree(rsa_dp);
3311       xfree(rsa_dq);
3312
3313       if (err)
3314         goto leave;
3315
3316       /* Prepare for storing the key.  */
3317       err = verify_chv3 (app, pincb, pincb_arg);
3318       if (err)
3319         goto leave;
3320
3321       /* Store the key. */
3322       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3323         exmode = 1;    /* Use extended length w/o a limit.  */
3324       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3325         exmode = -254;
3326       else
3327         exmode = 0;
3328       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3329                                   template, template_len);
3330     }
3331   else
3332     {
3333       /* Build the private key template as described in section 4.3.3.6 of
3334          the OpenPGP card specs version 1.1:
3335          0xC0   <length> public exponent
3336          0xC1   <length> prime p
3337          0xC2   <length> prime q
3338       */
3339       assert (rsa_e_len <= 4);
3340       template_len = (1 + 1 + 4
3341                       + 1 + 1 + rsa_p_len
3342                       + 1 + 1 + rsa_q_len);
3343       template = tp = xtrymalloc_secure (template_len);
3344       if (!template)
3345         {
3346           err = gpg_error_from_syserror ();
3347           goto leave;
3348         }
3349       *tp++ = 0xC0;
3350       *tp++ = 4;
3351       memcpy (tp, rsa_e, rsa_e_len);
3352       if (rsa_e_len < 4)
3353         {
3354           /* Right justify E. */
3355           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
3356           memset (tp, 0, 4-rsa_e_len);
3357         }
3358       tp += 4;
3359
3360       *tp++ = 0xC1;
3361       *tp++ = rsa_p_len;
3362       memcpy (tp, rsa_p, rsa_p_len);
3363       tp += rsa_p_len;
3364
3365       *tp++ = 0xC2;
3366       *tp++ = rsa_q_len;
3367       memcpy (tp, rsa_q, rsa_q_len);
3368       tp += rsa_q_len;
3369
3370       assert (tp - template == template_len);
3371
3372       /* Prepare for storing the key.  */
3373       err = verify_chv3 (app, pincb, pincb_arg);
3374       if (err)
3375         goto leave;
3376
3377       /* Store the key. */
3378       err = iso7816_put_data (app->slot, 0,
3379                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
3380                               template, template_len);
3381     }
3382   if (err)
3383     {
3384       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3385       goto leave;
3386     }
3387
3388   err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
3389                    rsa_n, rsa_n_len, rsa_e, rsa_e_len);
3390   if (err)
3391     goto leave;
3392
3393
3394  leave:
3395   xfree (template);
3396   return err;
3397 }
3398
3399
3400 static gpg_error_t
3401 ecc_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3402               void *pincb_arg, int keyno,
3403               const unsigned char *buf, size_t buflen, int depth)
3404 {
3405   gpg_error_t err;
3406   const unsigned char *tok;
3407   size_t toklen;
3408   int last_depth1, last_depth2;
3409   const unsigned char *ecc_q = NULL;
3410   const unsigned char *ecc_d = NULL;
3411   size_t ecc_q_len, ecc_d_len;
3412   const char *curve = NULL;
3413   u32 created_at = 0;
3414   const char *oidstr;
3415   int flag_djb_tweak = 0;
3416   int algo;
3417   gcry_mpi_t oid = NULL;
3418   const unsigned char *oidbuf;
3419   unsigned int n;
3420   size_t oid_len;
3421   unsigned char fprbuf[20];
3422
3423   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3424      curve = "NIST P-256" */
3425   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3426      curve = "secp256k1" */
3427   /* (private-key(ecc(curve%s)(flags eddsa)(q%m)(d%m))(created-at%d)):
3428       curve = "Ed25519" */
3429   last_depth1 = depth;
3430   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3431          && depth && depth >= last_depth1)
3432     {
3433       if (tok)
3434         {
3435           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3436           goto leave;
3437         }
3438       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3439         goto leave;
3440
3441       if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
3442         {
3443           char *curve_name;
3444
3445           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3446             goto leave;
3447
3448           curve_name = xtrymalloc (toklen+1);
3449           if (!curve_name)
3450             {
3451               err = gpg_error_from_syserror ();
3452               goto leave;
3453             }
3454
3455           memcpy (curve_name, tok, toklen);
3456           curve_name[toklen] = 0;
3457           curve = openpgp_is_curve_supported (curve_name, NULL, NULL);
3458           xfree (curve_name);
3459         }
3460       else if (tok && toklen == 5 && !memcmp (tok, "flags", 5))
3461         {
3462           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3463             goto leave;
3464
3465           if (tok)
3466             {
3467               if ((toklen == 5 && !memcmp (tok, "eddsa", 5))
3468                   || (toklen == 9 && !memcmp (tok, "djb-tweak", 9)))
3469                 flag_djb_tweak = 1;
3470             }
3471         }
3472       else if (tok && toklen == 1)
3473         {
3474           const unsigned char **buf2;
3475           size_t *buf2len;
3476           int native = flag_djb_tweak;
3477
3478           switch (*tok)
3479             {
3480             case 'q': buf2 = &ecc_q; buf2len = &ecc_q_len; break;
3481             case 'd': buf2 = &ecc_d; buf2len = &ecc_d_len; native = 0; break;
3482             default: buf2 = NULL;  buf2len = NULL; break;
3483             }
3484           if (buf2 && *buf2)
3485             {
3486               err = gpg_error (GPG_ERR_DUP_VALUE);
3487               goto leave;
3488             }
3489           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3490             goto leave;
3491           if (tok && buf2)
3492             {
3493               if (!native)
3494                 /* Strip off leading zero bytes and save. */
3495                 for (;toklen && !*tok; toklen--, tok++)
3496                   ;
3497
3498               *buf2 = tok;
3499               *buf2len = toklen;
3500             }
3501         }
3502       /* Skip until end of list. */
3503       last_depth2 = depth;
3504       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3505              && depth && depth >= last_depth2)
3506         ;
3507       if (err)
3508         goto leave;
3509     }
3510   /* Parse other attributes. */
3511   last_depth1 = depth;
3512   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3513          && depth && depth >= last_depth1)
3514     {
3515       if (tok)
3516         {
3517           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3518           goto leave;
3519         }
3520       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3521         goto leave;
3522       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3523         {
3524           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3525             goto leave;
3526           if (tok)
3527             {
3528               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3529                    tok++, toklen--)
3530                 created_at = created_at*10 + (*tok - '0');
3531             }
3532         }
3533       /* Skip until end of list. */
3534       last_depth2 = depth;
3535       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3536              && depth && depth >= last_depth2)
3537         ;
3538       if (err)
3539         goto leave;
3540     }
3541
3542
3543   /* Check that we have all parameters and that they match the card
3544      description. */
3545   if (!curve)
3546     {
3547       log_error (_("unsupported curve\n"));
3548       err = gpg_error (GPG_ERR_INV_VALUE);
3549       goto leave;
3550     }
3551   if (!created_at)
3552     {
3553       log_error (_("creation timestamp missing\n"));
3554       err = gpg_error (GPG_ERR_INV_VALUE);
3555       goto leave;
3556     }
3557   if (flag_djb_tweak && keyno != 1)
3558     algo = PUBKEY_ALGO_EDDSA;
3559   else if (keyno == 1)
3560     algo = PUBKEY_ALGO_ECDH;
3561   else
3562     algo = PUBKEY_ALGO_ECDSA;
3563
3564   oidstr = openpgp_curve_to_oid (curve, NULL);
3565   err = openpgp_oid_from_str (oidstr, &oid);
3566   if (err)
3567     goto leave;
3568   oidbuf = gcry_mpi_get_opaque (oid, &n);
3569   if (!oidbuf)
3570     {
3571       err = gpg_error_from_syserror ();
3572       goto leave;
3573     }
3574   oid_len = (n+7)/8;
3575
3576   if (app->ap