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