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