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