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