wks: Take name of sendmail from configure.
[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, "Salutation" },
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 #define KDF_DATA_LENGTH_MIN  90
2065 #define KDF_DATA_LENGTH_MAX 110
2066
2067 /* Compute hash if KDF-DO is available.  CHVNO must be 0 for reset
2068    code, 1 or 2 for user pin and 3 for admin pin.
2069  */
2070 static gpg_error_t
2071 pin2hash_if_kdf (app_t app, int chvno, char *pinvalue, int *r_pinlen)
2072 {
2073   gpg_error_t err = 0;
2074   void *relptr = NULL;
2075   unsigned char *buffer;
2076   size_t buflen;
2077
2078   if (app->app_local->extcap.kdf_do
2079       && (relptr = get_one_do (app, 0x00F9, &buffer, &buflen, NULL))
2080       && buflen >= KDF_DATA_LENGTH_MIN && (buffer[2] == 0x03))
2081     {
2082       const char *salt;
2083       unsigned long s2k_count;
2084       char dek[32];
2085       int salt_index;
2086
2087       s2k_count = (((unsigned int)buffer[8] << 24)
2088                    | (buffer[9] << 16) | (buffer[10] << 8) | buffer[11]);
2089
2090       if (buflen == KDF_DATA_LENGTH_MIN)
2091         salt_index =14;
2092       else if (buflen == KDF_DATA_LENGTH_MAX)
2093         salt_index = (chvno==3 ? 34 : (chvno==0 ? 24 : 14));
2094       else
2095         {
2096           err = gpg_error (GPG_ERR_INV_DATA);
2097           goto leave;
2098         }
2099
2100       salt = &buffer[salt_index];
2101       err = gcry_kdf_derive (pinvalue, strlen (pinvalue),
2102                              GCRY_KDF_ITERSALTED_S2K,
2103                              DIGEST_ALGO_SHA256, salt, 8,
2104                              s2k_count, sizeof (dek), dek);
2105       if (!err)
2106         {
2107           /* pinvalue has a buffer of MAXLEN_PIN+1, 32 is OK.  */
2108           *r_pinlen = 32;
2109           memcpy (pinvalue, dek, *r_pinlen);
2110           wipememory (dek, *r_pinlen);
2111         }
2112    }
2113   else
2114     *r_pinlen = strlen (pinvalue);
2115
2116  leave:
2117   xfree (relptr);
2118   return err;
2119 }
2120
2121
2122 /* Verify a CHV either using the pinentry or if possible by
2123    using a pinpad.  PINCB and PINCB_ARG describe the usual callback
2124    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
2125    used with CHV1.  PINVALUE is the address of a pointer which will
2126    receive a newly allocated block with the actual PIN (this is useful
2127    in case that PIN shall be used for another verify operation).  The
2128    caller needs to free this value.  If the function returns with
2129    success and NULL is stored at PINVALUE, the caller should take this
2130    as an indication that the pinpad has been used.
2131    */
2132 static gpg_error_t
2133 verify_a_chv (app_t app,
2134               gpg_error_t (*pincb)(void*, const char *, char **),
2135               void *pincb_arg, int chvno, unsigned long sigcount,
2136               char **pinvalue, int *pinlen)
2137 {
2138   int rc = 0;
2139   char *prompt_buffer = NULL;
2140   const char *prompt;
2141   pininfo_t pininfo;
2142   int minlen = 6;
2143   int remaining;
2144
2145   log_assert (chvno == 1 || chvno == 2);
2146
2147   *pinvalue = NULL;
2148   *pinlen = 0;
2149
2150   remaining = get_remaining_tries (app, 0);
2151   if (remaining == -1)
2152     return gpg_error (GPG_ERR_CARD);
2153
2154   if (chvno == 2 && app->app_local->flags.def_chv2)
2155     {
2156       /* Special case for def_chv2 mechanism. */
2157       if (opt.verbose)
2158         log_info (_("using default PIN as %s\n"), "CHV2");
2159       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
2160       if (rc)
2161         {
2162           /* Verification of CHV2 with the default PIN failed,
2163              although the card pretends to have the default PIN set as
2164              CHV2.  We better disable the def_chv2 flag now. */
2165           log_info (_("failed to use default PIN as %s: %s"
2166                       " - disabling further default use\n"),
2167                     "CHV2", gpg_strerror (rc));
2168           app->app_local->flags.def_chv2 = 0;
2169         }
2170       return rc;
2171     }
2172
2173   memset (&pininfo, 0, sizeof pininfo);
2174   pininfo.fixedlen = -1;
2175   pininfo.minlen = minlen;
2176
2177   {
2178     const char *firstline = _("||Please unlock the card");
2179     char *infoblock = get_prompt_info (app, chvno, sigcount,
2180                                        remaining < 3? remaining : -1);
2181
2182     prompt_buffer = strconcat (firstline, "%0A%0A", infoblock, NULL);
2183     if (prompt_buffer)
2184       prompt = prompt_buffer;
2185     else
2186       prompt = firstline;  /* ENOMEM fallback.  */
2187
2188     xfree (infoblock);
2189   }
2190
2191   if (!opt.disable_pinpad
2192       && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
2193       && !check_pinpad_request (app, &pininfo, 0))
2194     {
2195       /* The reader supports the verify command through the pinpad.
2196          Note that the pincb appends a text to the prompt telling the
2197          user to use the pinpad. */
2198       rc = pincb (pincb_arg, prompt, NULL);
2199       prompt = NULL;
2200       xfree (prompt_buffer);
2201       prompt_buffer = NULL;
2202       if (rc)
2203         {
2204           log_info (_("PIN callback returned error: %s\n"),
2205                     gpg_strerror (rc));
2206           return rc;
2207         }
2208       rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
2209       /* Dismiss the prompt. */
2210       pincb (pincb_arg, NULL, NULL);
2211
2212       log_assert (!*pinvalue);
2213     }
2214   else
2215     {
2216       /* The reader has no pinpad or we don't want to use it. */
2217       rc = pincb (pincb_arg, prompt, pinvalue);
2218       prompt = NULL;
2219       xfree (prompt_buffer);
2220       prompt_buffer = NULL;
2221       if (rc)
2222         {
2223           log_info (_("PIN callback returned error: %s\n"),
2224                     gpg_strerror (rc));
2225           return rc;
2226         }
2227
2228       if (strlen (*pinvalue) < minlen)
2229         {
2230           log_error (_("PIN for CHV%d is too short;"
2231                        " minimum length is %d\n"), chvno, minlen);
2232           xfree (*pinvalue);
2233           *pinvalue = NULL;
2234           return gpg_error (GPG_ERR_BAD_PIN);
2235         }
2236
2237       rc = pin2hash_if_kdf (app, chvno, *pinvalue, pinlen);
2238       if (!rc)
2239         rc = iso7816_verify (app->slot, 0x80+chvno, *pinvalue, *pinlen);
2240     }
2241
2242   if (rc)
2243     {
2244       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
2245       xfree (*pinvalue);
2246       *pinvalue = NULL;
2247       flush_cache_after_error (app);
2248     }
2249
2250   return rc;
2251 }
2252
2253
2254 /* Verify CHV2 if required.  Depending on the configuration of the
2255    card CHV1 will also be verified. */
2256 static gpg_error_t
2257 verify_chv2 (app_t app,
2258              gpg_error_t (*pincb)(void*, const char *, char **),
2259              void *pincb_arg)
2260 {
2261   int rc;
2262   char *pinvalue;
2263   int pinlen;
2264
2265   if (app->did_chv2)
2266     return 0;  /* We already verified CHV2.  */
2267
2268   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue, &pinlen);
2269   if (rc)
2270     return rc;
2271   app->did_chv2 = 1;
2272
2273   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
2274     {
2275       /* For convenience we verify CHV1 here too.  We do this only if
2276          the card is not configured to require a verification before
2277          each CHV1 controlled operation (force_chv1) and if we are not
2278          using the pinpad (PINVALUE == NULL). */
2279       rc = iso7816_verify (app->slot, 0x81, pinvalue, pinlen);
2280       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2281         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2282       if (rc)
2283         {
2284           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2285           flush_cache_after_error (app);
2286         }
2287       else
2288         app->did_chv1 = 1;
2289     }
2290
2291   xfree (pinvalue);
2292
2293   return rc;
2294 }
2295
2296
2297 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
2298    current sdtate of the card.  */
2299 static gpg_error_t
2300 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
2301 {
2302   int remaining;
2303   char *prompt;
2304   char *infoblock;
2305
2306   *r_prompt = NULL;
2307
2308   remaining = get_remaining_tries (app, 1);
2309   if (remaining == -1)
2310     return gpg_error (GPG_ERR_CARD);
2311   if (!remaining)
2312     {
2313       log_info (_("card is permanently locked!\n"));
2314       return gpg_error (GPG_ERR_BAD_PIN);
2315     }
2316
2317   log_info (ngettext("%d Admin PIN attempt remaining before card"
2318                      " is permanently locked\n",
2319                      "%d Admin PIN attempts remaining before card"
2320                      " is permanently locked\n",
2321                      remaining), remaining);
2322
2323   infoblock = get_prompt_info (app, 3, 0, remaining < 3? remaining : -1);
2324
2325   /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
2326      the start of the string.  Use %0A (single percent) for a linefeed.  */
2327   prompt = strconcat (_("|A|Please enter the Admin PIN"),
2328                       "%0A%0A", infoblock, NULL);
2329   xfree (infoblock);
2330   if (!prompt)
2331     return gpg_error_from_syserror ();
2332
2333   *r_prompt = prompt;
2334   return 0;
2335 }
2336
2337
2338 /* Verify CHV3 if required. */
2339 static gpg_error_t
2340 verify_chv3 (app_t app,
2341              gpg_error_t (*pincb)(void*, const char *, char **),
2342              void *pincb_arg)
2343 {
2344   int rc = 0;
2345
2346 #if GNUPG_MAJOR_VERSION != 1
2347   if (!opt.allow_admin)
2348     {
2349       log_info (_("access to admin commands is not configured\n"));
2350       return gpg_error (GPG_ERR_EACCES);
2351     }
2352 #endif
2353
2354   if (!app->did_chv3)
2355     {
2356       pininfo_t pininfo;
2357       int minlen = 8;
2358       char *prompt;
2359
2360       memset (&pininfo, 0, sizeof pininfo);
2361       pininfo.fixedlen = -1;
2362       pininfo.minlen = minlen;
2363
2364       rc = build_enter_admin_pin_prompt (app, &prompt);
2365       if (rc)
2366         return rc;
2367
2368       if (!opt.disable_pinpad
2369           && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
2370           && !check_pinpad_request (app, &pininfo, 1))
2371         {
2372           /* The reader supports the verify command through the pinpad. */
2373           rc = pincb (pincb_arg, prompt, NULL);
2374           xfree (prompt);
2375           prompt = NULL;
2376           if (rc)
2377             {
2378               log_info (_("PIN callback returned error: %s\n"),
2379                         gpg_strerror (rc));
2380               return rc;
2381             }
2382           rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
2383           /* Dismiss the prompt. */
2384           pincb (pincb_arg, NULL, NULL);
2385         }
2386       else
2387         {
2388           char *pinvalue;
2389           int pinlen;
2390
2391           rc = pincb (pincb_arg, prompt, &pinvalue);
2392           xfree (prompt);
2393           prompt = NULL;
2394           if (rc)
2395             {
2396               log_info (_("PIN callback returned error: %s\n"),
2397                         gpg_strerror (rc));
2398               return rc;
2399             }
2400
2401           if (strlen (pinvalue) < minlen)
2402             {
2403               log_error (_("PIN for CHV%d is too short;"
2404                            " minimum length is %d\n"), 3, minlen);
2405               xfree (pinvalue);
2406               return gpg_error (GPG_ERR_BAD_PIN);
2407             }
2408
2409           rc = pin2hash_if_kdf (app, 3, pinvalue, &pinlen);
2410           if (!rc)
2411             rc = iso7816_verify (app->slot, 0x83, pinvalue, pinlen);
2412           xfree (pinvalue);
2413         }
2414
2415       if (rc)
2416         {
2417           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
2418           flush_cache_after_error (app);
2419           return rc;
2420         }
2421       app->did_chv3 = 1;
2422     }
2423   return rc;
2424 }
2425
2426
2427 /* Handle the SETATTR operation. All arguments are already basically
2428    checked. */
2429 static gpg_error_t
2430 do_setattr (app_t app, const char *name,
2431             gpg_error_t (*pincb)(void*, const char *, char **),
2432             void *pincb_arg,
2433             const unsigned char *value, size_t valuelen)
2434 {
2435   gpg_error_t rc;
2436   int idx;
2437   static struct {
2438     const char *name;
2439     int tag;
2440     int need_chv;
2441     int special;
2442     unsigned int need_v2:1;
2443   } table[] = {
2444     { "DISP-NAME",    0x005B, 3 },
2445     { "LOGIN-DATA",   0x005E, 3, 2 },
2446     { "DISP-LANG",    0x5F2D, 3 },
2447     { "DISP-SEX",     0x5F35, 3 },
2448     { "PUBKEY-URL",   0x5F50, 3 },
2449     { "CHV-STATUS-1", 0x00C4, 3, 1 },
2450     { "CA-FPR-1",     0x00CA, 3 },
2451     { "CA-FPR-2",     0x00CB, 3 },
2452     { "CA-FPR-3",     0x00CC, 3 },
2453     { "PRIVATE-DO-1", 0x0101, 2 },
2454     { "PRIVATE-DO-2", 0x0102, 3 },
2455     { "PRIVATE-DO-3", 0x0103, 2 },
2456     { "PRIVATE-DO-4", 0x0104, 3 },
2457     { "CERT-3",       0x7F21, 3, 0, 1 },
2458     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
2459     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
2460     { "KEY-ATTR",     0,      0, 3, 1 },
2461     { "AESKEY",       0x00D5, 3, 0, 1 },
2462     { "KDF",          0x00F9, 3, 4, 1 },
2463     { NULL, 0 }
2464   };
2465   int exmode;
2466
2467   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
2468     ;
2469   if (!table[idx].name)
2470     return gpg_error (GPG_ERR_INV_NAME);
2471   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
2472     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
2473
2474   if (table[idx].special == 3)
2475     return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
2476
2477   switch (table[idx].need_chv)
2478     {
2479     case 2:
2480       rc = verify_chv2 (app, pincb, pincb_arg);
2481       break;
2482     case 3:
2483       rc = verify_chv3 (app, pincb, pincb_arg);
2484       break;
2485     default:
2486       rc = 0;
2487     }
2488   if (rc)
2489     return rc;
2490
2491   /* Flush the cache before writing it, so that the next get operation
2492      will reread the data from the card and thus get synced in case of
2493      errors (e.g. data truncated by the card). */
2494   flush_cache_item (app, table[idx].tag);
2495
2496   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
2497     exmode = 1;    /* Use extended length w/o a limit.  */
2498   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
2499     exmode = -254; /* Command chaining with max. 254 bytes.  */
2500   else
2501     exmode = 0;
2502   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
2503   if (rc)
2504     log_error ("failed to set '%s': %s\n", table[idx].name, gpg_strerror (rc));
2505
2506   if (table[idx].special == 1)
2507     app->force_chv1 = (valuelen && *value == 0);
2508   else if (table[idx].special == 2)
2509     parse_login_data (app);
2510   else if (table[idx].special == 4)
2511     {
2512       app->did_chv1 = 0;
2513       app->did_chv2 = 0;
2514       app->did_chv3 = 0;
2515     }
2516
2517   return rc;
2518 }
2519
2520
2521 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
2522    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
2523    PINCB and PINCB_ARG are the usual arguments for the pinentry
2524    callback.  */
2525 static gpg_error_t
2526 do_writecert (app_t app, ctrl_t ctrl,
2527               const char *certidstr,
2528               gpg_error_t (*pincb)(void*, const char *, char **),
2529               void *pincb_arg,
2530               const unsigned char *certdata, size_t certdatalen)
2531 {
2532   (void)ctrl;
2533 #if GNUPG_MAJOR_VERSION > 1
2534   if (strcmp (certidstr, "OPENPGP.3"))
2535     return gpg_error (GPG_ERR_INV_ID);
2536   if (!certdata || !certdatalen)
2537     return gpg_error (GPG_ERR_INV_ARG);
2538   if (!app->app_local->extcap.is_v2)
2539     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2540   if (certdatalen > app->app_local->extcap.max_certlen_3)
2541     return gpg_error (GPG_ERR_TOO_LARGE);
2542   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
2543 #else
2544   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2545 #endif
2546 }
2547
2548
2549
2550 /* Handle the PASSWD command.  The following combinations are
2551    possible:
2552
2553     Flags  CHVNO Vers.  Description
2554     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
2555     RESET    1   2      Verify PW3 and set a new PW1.
2556     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
2557     RESET    2   2      Verify PW3 and set a new Reset Code.
2558     RESET    3   any    Returns GPG_ERR_INV_ID.
2559      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
2560      -       1   2      Verify PW1 and set a new PW1.
2561      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
2562      -       2   2      Verify Reset Code and set a new PW1.
2563      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
2564  */
2565 static gpg_error_t
2566 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
2567                unsigned int flags,
2568                gpg_error_t (*pincb)(void*, const char *, char **),
2569                void *pincb_arg)
2570 {
2571   int rc = 0;
2572   int chvno = atoi (chvnostr);
2573   char *resetcode = NULL;
2574   char *oldpinvalue = NULL;
2575   char *pinvalue = NULL;
2576   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2577   int set_resetcode = 0;
2578   pininfo_t pininfo;
2579   int use_pinpad = 0;
2580   int minlen = 6;
2581   int pinlen0 = 0;
2582   int pinlen = 0;
2583
2584   (void)ctrl;
2585   memset (&pininfo, 0, sizeof pininfo);
2586   pininfo.fixedlen = -1;
2587   pininfo.minlen = minlen;
2588
2589   if (reset_mode && chvno == 3)
2590     {
2591       rc = gpg_error (GPG_ERR_INV_ID);
2592       goto leave;
2593     }
2594
2595   if (!app->app_local->extcap.is_v2)
2596     {
2597       /* Version 1 cards.  */
2598
2599       if (reset_mode || chvno == 3)
2600         {
2601           /* We always require that the PIN is entered. */
2602           app->did_chv3 = 0;
2603           rc = verify_chv3 (app, pincb, pincb_arg);
2604           if (rc)
2605             goto leave;
2606         }
2607       else if (chvno == 1 || chvno == 2)
2608         {
2609           /* On a v1.x card CHV1 and CVH2 should always have the same
2610              value, thus we enforce it here.  */
2611           int save_force = app->force_chv1;
2612
2613           app->force_chv1 = 0;
2614           app->did_chv1 = 0;
2615           app->did_chv2 = 0;
2616           rc = verify_chv2 (app, pincb, pincb_arg);
2617           app->force_chv1 = save_force;
2618           if (rc)
2619             goto leave;
2620         }
2621       else
2622         {
2623           rc = gpg_error (GPG_ERR_INV_ID);
2624           goto leave;
2625         }
2626     }
2627   else
2628     {
2629       /* Version 2 cards.  */
2630
2631       if (!opt.disable_pinpad
2632           && !iso7816_check_pinpad (app->slot,
2633                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2634           && !check_pinpad_request (app, &pininfo, chvno == 3))
2635         use_pinpad = 1;
2636
2637       if (reset_mode)
2638         {
2639           /* To reset a PIN the Admin PIN is required. */
2640           use_pinpad = 0;
2641           app->did_chv3 = 0;
2642           rc = verify_chv3 (app, pincb, pincb_arg);
2643           if (rc)
2644             goto leave;
2645
2646           if (chvno == 2)
2647             set_resetcode = 1;
2648         }
2649       else if (chvno == 1 || chvno == 3)
2650         {
2651           if (!use_pinpad)
2652             {
2653               char *promptbuf = NULL;
2654               const char *prompt;
2655
2656               if (chvno == 3)
2657                 {
2658                   minlen = 8;
2659                   rc = build_enter_admin_pin_prompt (app, &promptbuf);
2660                   if (rc)
2661                     goto leave;
2662                   prompt = promptbuf;
2663                 }
2664               else
2665                 prompt = _("||Please enter the PIN");
2666               rc = pincb (pincb_arg, prompt, &oldpinvalue);
2667               xfree (promptbuf);
2668               promptbuf = NULL;
2669               if (rc)
2670                 {
2671                   log_info (_("PIN callback returned error: %s\n"),
2672                             gpg_strerror (rc));
2673                   goto leave;
2674                 }
2675
2676               if (strlen (oldpinvalue) < minlen)
2677                 {
2678                   log_info (_("PIN for CHV%d is too short;"
2679                               " minimum length is %d\n"), chvno, minlen);
2680                   rc = gpg_error (GPG_ERR_BAD_PIN);
2681                   goto leave;
2682                 }
2683             }
2684         }
2685       else if (chvno == 2)
2686         {
2687           /* There is no PW2 for v2 cards.  We use this condition to
2688              allow a PW reset using the Reset Code.  */
2689           void *relptr;
2690           unsigned char *value;
2691           size_t valuelen;
2692           int remaining;
2693
2694           use_pinpad = 0;
2695           minlen = 8;
2696           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2697           if (!relptr || valuelen < 7)
2698             {
2699               log_error (_("error retrieving CHV status from card\n"));
2700               xfree (relptr);
2701               rc = gpg_error (GPG_ERR_CARD);
2702               goto leave;
2703             }
2704           remaining = value[5];
2705           xfree (relptr);
2706           if (!remaining)
2707             {
2708               log_error (_("Reset Code not or not anymore available\n"));
2709               rc = gpg_error (GPG_ERR_BAD_PIN);
2710               goto leave;
2711             }
2712
2713           rc = pincb (pincb_arg,
2714                       _("||Please enter the Reset Code for the card"),
2715                       &resetcode);
2716           if (rc)
2717             {
2718               log_info (_("PIN callback returned error: %s\n"),
2719                         gpg_strerror (rc));
2720               goto leave;
2721             }
2722           if (strlen (resetcode) < minlen)
2723             {
2724               log_info (_("Reset Code is too short; minimum length is %d\n"),
2725                         minlen);
2726               rc = gpg_error (GPG_ERR_BAD_PIN);
2727               goto leave;
2728             }
2729         }
2730       else
2731         {
2732           rc = gpg_error (GPG_ERR_INV_ID);
2733           goto leave;
2734         }
2735     }
2736
2737   if (chvno == 3)
2738     app->did_chv3 = 0;
2739   else
2740     app->did_chv1 = app->did_chv2 = 0;
2741
2742   if (!use_pinpad)
2743     {
2744       /* TRANSLATORS: Do not translate the "|*|" prefixes but
2745          keep it at the start of the string.  We need this elsewhere
2746          to get some infos on the string. */
2747       rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2748                   chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2749                   &pinvalue);
2750       if (rc || pinvalue == NULL)
2751         {
2752           log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2753           goto leave;
2754         }
2755     }
2756
2757
2758   if (resetcode)
2759     {
2760       char *buffer;
2761
2762       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2763       if (!buffer)
2764         rc = gpg_error_from_syserror ();
2765       else
2766         {
2767           strcpy (buffer, resetcode);
2768           rc = pin2hash_if_kdf (app, 0, buffer, &pinlen0);
2769           if (!rc)
2770             {
2771               strcpy (buffer+pinlen0, pinvalue);
2772               rc = pin2hash_if_kdf (app, 0, buffer+pinlen0, &pinlen);
2773             }
2774           if (!rc)
2775             rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2776                                                       buffer, pinlen0+pinlen);
2777           wipememory (buffer, pinlen0 + pinlen);
2778           xfree (buffer);
2779         }
2780     }
2781   else if (set_resetcode)
2782     {
2783       if (strlen (pinvalue) < 8)
2784         {
2785           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2786           rc = gpg_error (GPG_ERR_BAD_PIN);
2787         }
2788       else
2789         {
2790           rc = pin2hash_if_kdf (app, 0, pinvalue, &pinlen);
2791           if (!rc)
2792             rc = iso7816_put_data (app->slot, 0, 0xD3, pinvalue, pinlen);
2793         }
2794     }
2795   else if (reset_mode)
2796     {
2797       rc = pin2hash_if_kdf (app, 1, pinvalue, &pinlen);
2798       if (!rc)
2799         rc = iso7816_reset_retry_counter (app->slot, 0x81, pinvalue, pinlen);
2800       if (!rc && !app->app_local->extcap.is_v2)
2801         rc = iso7816_reset_retry_counter (app->slot, 0x82, pinvalue, pinlen);
2802     }
2803   else if (!app->app_local->extcap.is_v2)
2804     {
2805       /* Version 1 cards.  */
2806       if (chvno == 1 || chvno == 2)
2807         {
2808           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2809                                               pinvalue, strlen (pinvalue));
2810           if (!rc)
2811             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2812                                                 pinvalue, strlen (pinvalue));
2813         }
2814       else /* CHVNO == 3 */
2815         {
2816           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2817                                               pinvalue, strlen (pinvalue));
2818         }
2819     }
2820   else
2821     {
2822       /* Version 2 cards.  */
2823       assert (chvno == 1 || chvno == 3);
2824
2825       if (use_pinpad)
2826         {
2827           rc = pincb (pincb_arg,
2828                       chvno == 3 ?
2829                       _("||Please enter the Admin PIN and New Admin PIN") :
2830                       _("||Please enter the PIN and New PIN"), NULL);
2831           if (rc)
2832             {
2833               log_info (_("PIN callback returned error: %s\n"),
2834                         gpg_strerror (rc));
2835               goto leave;
2836             }
2837           rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
2838                                                  &pininfo);
2839           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2840         }
2841       else
2842         {
2843           rc = pin2hash_if_kdf (app, chvno, oldpinvalue, &pinlen0);
2844           if (!rc)
2845             rc = pin2hash_if_kdf (app, chvno, pinvalue, &pinlen);
2846           if (!rc)
2847             rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2848                                                 oldpinvalue, pinlen0,
2849                                                 pinvalue, pinlen);
2850         }
2851     }
2852
2853   if (pinvalue)
2854     {
2855       wipememory (pinvalue, pinlen);
2856       xfree (pinvalue);
2857     }
2858   if (rc)
2859     flush_cache_after_error (app);
2860
2861  leave:
2862   if (resetcode)
2863     {
2864       wipememory (resetcode, strlen (resetcode));
2865       xfree (resetcode);
2866     }
2867   if (oldpinvalue)
2868     {
2869       wipememory (oldpinvalue, pinlen0);
2870       xfree (oldpinvalue);
2871     }
2872   return rc;
2873 }
2874
2875
2876 /* Check whether a key already exists.  KEYIDX is the index of the key
2877    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2878    error returned if the key already exists.  The flag GENERATING is
2879    only used to print correct messages. */
2880 static gpg_error_t
2881 does_key_exist (app_t app, int keyidx, int generating, int force)
2882 {
2883   const unsigned char *fpr;
2884   unsigned char *buffer;
2885   size_t buflen, n;
2886   int i;
2887
2888   assert (keyidx >=0 && keyidx <= 2);
2889
2890   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2891     {
2892       log_error (_("error reading application data\n"));
2893       return gpg_error (GPG_ERR_GENERAL);
2894     }
2895   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2896   if (!fpr || n < 60)
2897     {
2898       log_error (_("error reading fingerprint DO\n"));
2899       xfree (buffer);
2900       return gpg_error (GPG_ERR_GENERAL);
2901     }
2902   fpr += 20*keyidx;
2903   for (i=0; i < 20 && !fpr[i]; i++)
2904     ;
2905   xfree (buffer);
2906   if (i!=20 && !force)
2907     {
2908       log_error (_("key already exists\n"));
2909       return gpg_error (GPG_ERR_EEXIST);
2910     }
2911   else if (i!=20)
2912     log_info (_("existing key will be replaced\n"));
2913   else if (generating)
2914     log_info (_("generating new key\n"));
2915   else
2916     log_info (_("writing new key\n"));
2917   return 0;
2918 }
2919
2920
2921 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2922    of tag and length.  A LENGTH greater than 65535 is truncated. */
2923 static size_t
2924 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2925 {
2926   unsigned char *p = buffer;
2927
2928   assert (tag <= 0xffff);
2929   if ( tag > 0xff )
2930     *p++ = tag >> 8;
2931   *p++ = tag;
2932   if (length < 128)
2933     *p++ = length;
2934   else if (length < 256)
2935     {
2936       *p++ = 0x81;
2937       *p++ = length;
2938     }
2939   else
2940     {
2941       if (length > 0xffff)
2942         length = 0xffff;
2943       *p++ = 0x82;
2944       *p++ = length >> 8;
2945       *p++ = length;
2946     }
2947
2948   return p - buffer;
2949 }
2950
2951
2952 static gpg_error_t
2953 build_privkey_template (app_t app, int keyno,
2954                         const unsigned char *rsa_n, size_t rsa_n_len,
2955                         const unsigned char *rsa_e, size_t rsa_e_len,
2956                         const unsigned char *rsa_p, size_t rsa_p_len,
2957                         const unsigned char *rsa_q, size_t rsa_q_len,
2958                         const unsigned char *rsa_u, size_t rsa_u_len,
2959                         const unsigned char *rsa_dp, size_t rsa_dp_len,
2960                         const unsigned char *rsa_dq, size_t rsa_dq_len,
2961                         unsigned char **result, size_t *resultlen)
2962 {
2963   size_t rsa_e_reqlen;
2964   unsigned char privkey[7*(1+3+3)];
2965   size_t privkey_len;
2966   unsigned char exthdr[2+2+3];
2967   size_t exthdr_len;
2968   unsigned char suffix[2+3];
2969   size_t suffix_len;
2970   unsigned char *tp;
2971   size_t datalen;
2972   unsigned char *template;
2973   size_t template_size;
2974
2975   *result = NULL;
2976   *resultlen = 0;
2977
2978   switch (app->app_local->keyattr[keyno].rsa.format)
2979     {
2980     case RSA_STD:
2981     case RSA_STD_N:
2982     case RSA_CRT:
2983     case RSA_CRT_N:
2984       break;
2985
2986     default:
2987       return gpg_error (GPG_ERR_INV_VALUE);
2988     }
2989
2990   /* Get the required length for E. Rounded up to the nearest byte  */
2991   rsa_e_reqlen = (app->app_local->keyattr[keyno].rsa.e_bits + 7) / 8;
2992   assert (rsa_e_len <= rsa_e_reqlen);
2993
2994   /* Build the 7f48 cardholder private key template.  */
2995   datalen = 0;
2996   tp = privkey;
2997
2998   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2999   datalen += rsa_e_reqlen;
3000
3001   tp += add_tlv (tp, 0x92, rsa_p_len);
3002   datalen += rsa_p_len;
3003
3004   tp += add_tlv (tp, 0x93, rsa_q_len);
3005   datalen += rsa_q_len;
3006
3007   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
3008       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3009     {
3010       tp += add_tlv (tp, 0x94, rsa_u_len);
3011       datalen += rsa_u_len;
3012       tp += add_tlv (tp, 0x95, rsa_dp_len);
3013       datalen += rsa_dp_len;
3014       tp += add_tlv (tp, 0x96, rsa_dq_len);
3015       datalen += rsa_dq_len;
3016     }
3017
3018   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
3019       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3020     {
3021       tp += add_tlv (tp, 0x97, rsa_n_len);
3022       datalen += rsa_n_len;
3023     }
3024   privkey_len = tp - privkey;
3025
3026   /* Build the extended header list without the private key template.  */
3027   tp = exthdr;
3028   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
3029   *tp++ = 0;
3030   tp += add_tlv (tp, 0x7f48, privkey_len);
3031   exthdr_len = tp - exthdr;
3032
3033   /* Build the 5f48 suffix of the data.  */
3034   tp = suffix;
3035   tp += add_tlv (tp, 0x5f48, datalen);
3036   suffix_len = tp - suffix;
3037
3038   /* Now concatenate everything.  */
3039   template_size = (1 + 3   /* 0x4d and len. */
3040                    + exthdr_len
3041                    + privkey_len
3042                    + suffix_len
3043                    + datalen);
3044   tp = template = xtrymalloc_secure (template_size);
3045   if (!template)
3046     return gpg_error_from_syserror ();
3047
3048   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
3049   memcpy (tp, exthdr, exthdr_len);
3050   tp += exthdr_len;
3051   memcpy (tp, privkey, privkey_len);
3052   tp += privkey_len;
3053   memcpy (tp, suffix, suffix_len);
3054   tp += suffix_len;
3055
3056   memcpy (tp, rsa_e, rsa_e_len);
3057   if (rsa_e_len < rsa_e_reqlen)
3058     {
3059       /* Right justify E. */
3060       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
3061       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
3062     }
3063   tp += rsa_e_reqlen;
3064
3065   memcpy (tp, rsa_p, rsa_p_len);
3066   tp += rsa_p_len;
3067
3068   memcpy (tp, rsa_q, rsa_q_len);
3069   tp += rsa_q_len;
3070
3071   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
3072       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3073     {
3074       memcpy (tp, rsa_u, rsa_u_len);
3075       tp += rsa_u_len;
3076       memcpy (tp, rsa_dp, rsa_dp_len);
3077       tp += rsa_dp_len;
3078       memcpy (tp, rsa_dq, rsa_dq_len);
3079       tp += rsa_dq_len;
3080     }
3081
3082   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
3083       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3084     {
3085       memcpy (tp, rsa_n, rsa_n_len);
3086       tp += rsa_n_len;
3087     }
3088
3089   /* Sanity check.  We don't know the exact length because we
3090      allocated 3 bytes for the first length header.  */
3091   assert (tp - template <= template_size);
3092
3093   *result = template;
3094   *resultlen = tp - template;
3095   return 0;
3096 }
3097
3098 static gpg_error_t
3099 build_ecc_privkey_template (app_t app, int keyno,
3100                             const unsigned char *ecc_d, size_t ecc_d_len,
3101                             const unsigned char *ecc_q, size_t ecc_q_len,
3102                             unsigned char **result, size_t *resultlen)
3103 {
3104   unsigned char privkey[2+2];
3105   size_t privkey_len;
3106   unsigned char exthdr[2+2+1];
3107   size_t exthdr_len;
3108   unsigned char suffix[2+1];
3109   size_t suffix_len;
3110   unsigned char *tp;
3111   size_t datalen;
3112   unsigned char *template;
3113   size_t template_size;
3114   int pubkey_required;
3115
3116   pubkey_required = !!(app->app_local->keyattr[keyno].ecc.flags
3117                        & ECC_FLAG_PUBKEY);
3118
3119   *result = NULL;
3120   *resultlen = 0;
3121
3122   /* Build the 7f48 cardholder private key template.  */
3123   datalen = 0;
3124   tp = privkey;
3125
3126   tp += add_tlv (tp, 0x92, ecc_d_len);
3127   datalen += ecc_d_len;
3128
3129   if (pubkey_required)
3130     {
3131       tp += add_tlv (tp, 0x99, ecc_q_len);
3132       datalen += ecc_q_len;
3133     }
3134
3135   privkey_len = tp - privkey;
3136
3137
3138   /* Build the extended header list without the private key template.  */
3139   tp = exthdr;
3140   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
3141   *tp++ = 0;
3142   tp += add_tlv (tp, 0x7f48, privkey_len);
3143   exthdr_len = tp - exthdr;
3144
3145   /* Build the 5f48 suffix of the data.  */
3146   tp = suffix;
3147   tp += add_tlv (tp, 0x5f48, datalen);
3148   suffix_len = tp - suffix;
3149
3150   /* Now concatenate everything.  */
3151   template_size = (1 + 1   /* 0x4d and len. */
3152                    + exthdr_len
3153                    + privkey_len
3154                    + suffix_len
3155                    + datalen);
3156   if (exthdr_len + privkey_len + suffix_len + datalen >= 128)
3157     template_size++;
3158   tp = template = xtrymalloc_secure (template_size);
3159   if (!template)
3160     return gpg_error_from_syserror ();
3161
3162   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
3163   memcpy (tp, exthdr, exthdr_len);
3164   tp += exthdr_len;
3165   memcpy (tp, privkey, privkey_len);
3166   tp += privkey_len;
3167   memcpy (tp, suffix, suffix_len);
3168   tp += suffix_len;
3169
3170   memcpy (tp, ecc_d, ecc_d_len);
3171   tp += ecc_d_len;
3172
3173   if (pubkey_required)
3174     {
3175       memcpy (tp, ecc_q, ecc_q_len);
3176       tp += ecc_q_len;
3177     }
3178
3179   assert (tp - template == template_size);
3180
3181   *result = template;
3182   *resultlen = tp - template;
3183   return 0;
3184 }
3185
3186
3187 /* Helper for do_writekley to change the size of a key.  Not ethat
3188    this deletes the entire key without asking.  */
3189 static gpg_error_t
3190 change_keyattr (app_t app, int keyno, const unsigned char *buf, size_t buflen,
3191                 gpg_error_t (*pincb)(void*, const char *, char **),
3192                 void *pincb_arg)
3193 {
3194   gpg_error_t err;
3195
3196   assert (keyno >=0 && keyno <= 2);
3197
3198   /* Prepare for storing the key.  */
3199   err = verify_chv3 (app, pincb, pincb_arg);
3200   if (err)
3201     return err;
3202
3203   /* Change the attribute.  */
3204   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buf, buflen);
3205   if (err)
3206     log_error ("error changing key attribute (key=%d)\n", keyno+1);
3207   else
3208     log_info ("key attribute changed (key=%d)\n", keyno+1);
3209   flush_cache (app);
3210   parse_algorithm_attribute (app, keyno);
3211   app->did_chv1 = 0;
3212   app->did_chv2 = 0;
3213   app->did_chv3 = 0;
3214   return err;
3215 }
3216
3217
3218 static gpg_error_t
3219 change_rsa_keyattr (app_t app, int keyno, unsigned int nbits,
3220                     gpg_error_t (*pincb)(void*, const char *, char **),
3221                     void *pincb_arg)
3222 {
3223   gpg_error_t err = 0;
3224   unsigned char *buf;
3225   size_t buflen;
3226   void *relptr;
3227
3228   /* Read the current attributes into a buffer.  */
3229   relptr = get_one_do (app, 0xC1+keyno, &buf, &buflen, NULL);
3230   if (!relptr)
3231     err = gpg_error (GPG_ERR_CARD);
3232   else if (buflen < 6)
3233     {
3234       /* Attributes too short.  */
3235       xfree (relptr);
3236       err = gpg_error (GPG_ERR_CARD);
3237     }
3238   else
3239     {
3240       /* If key attribute was RSA, we only change n_bits and don't
3241          touch anything else.  Before we do so, we round up NBITS to a
3242          sensible way in the same way as gpg's key generation does it.
3243          This may help to sort out problems with a few bits too short
3244          keys.  */
3245       nbits = ((nbits + 31) / 32) * 32;
3246       buf[1] = (nbits >> 8);
3247       buf[2] = nbits;
3248
3249       /* If it was not RSA, we need to fill other parts.  */
3250       if (buf[0] != PUBKEY_ALGO_RSA)
3251         {
3252           buf[0] = PUBKEY_ALGO_RSA;
3253           buf[3] = 0;
3254           buf[4] = 32;
3255           buf[5] = 0;
3256           buflen = 6;
3257         }
3258
3259       err = change_keyattr (app, keyno, buf, buflen, pincb, pincb_arg);
3260       xfree (relptr);
3261     }
3262
3263   return err;
3264 }
3265
3266
3267 /* Helper to process an setattr command for name KEY-ATTR.
3268    In (VALUE,VALUELEN), it expects following string:
3269         RSA: "--force <key> <algo> rsa<nbits>"
3270         ECC: "--force <key> <algo> <curvename>"
3271   */
3272 static gpg_error_t
3273 change_keyattr_from_string (app_t app,
3274                             gpg_error_t (*pincb)(void*, const char *, char **),
3275                             void *pincb_arg,
3276                             const void *value, size_t valuelen)
3277 {
3278   gpg_error_t err = 0;
3279   char *string;
3280   int key, keyno, algo;
3281   int n = 0;
3282
3283   /* VALUE is expected to be a string but not guaranteed to be
3284      terminated.  Thus copy it to an allocated buffer first. */
3285   string = xtrymalloc (valuelen+1);
3286   if (!string)
3287     return gpg_error_from_syserror ();
3288   memcpy (string, value, valuelen);
3289   string[valuelen] = 0;
3290
3291   /* Because this function deletes the key we require the string
3292      "--force" in the data to make clear that something serious might
3293      happen.  */
3294   sscanf (string, "--force %d %d %n", &key, &algo, &n);
3295   if (n < 12)
3296     {
3297       err = gpg_error (GPG_ERR_INV_DATA);
3298       goto leave;
3299     }
3300
3301   keyno = key - 1;
3302   if (keyno < 0 || keyno > 2)
3303     err = gpg_error (GPG_ERR_INV_ID);
3304   else if (algo == PUBKEY_ALGO_RSA)
3305     {
3306       unsigned int nbits;
3307
3308       errno = 0;
3309       nbits = strtoul (string+n+3, NULL, 10);
3310       if (errno)
3311         err = gpg_error (GPG_ERR_INV_DATA);
3312       else if (nbits < 1024)
3313         err = gpg_error (GPG_ERR_TOO_SHORT);
3314       else if (nbits > 4096)
3315         err = gpg_error (GPG_ERR_TOO_LARGE);
3316       else
3317         err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3318     }
3319   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
3320            || algo == PUBKEY_ALGO_EDDSA)
3321     {
3322       const char *oidstr;
3323       gcry_mpi_t oid;
3324       const unsigned char *oidbuf;
3325       size_t oid_len;
3326
3327       oidstr = openpgp_curve_to_oid (string+n, NULL);
3328       if (!oidstr)
3329         {
3330           err = gpg_error (GPG_ERR_INV_DATA);
3331           goto leave;
3332         }
3333
3334       err = openpgp_oid_from_str (oidstr, &oid);
3335       if (err)
3336         goto leave;
3337
3338       oidbuf = gcry_mpi_get_opaque (oid, &n);
3339       oid_len = (n+7)/8;
3340
3341       /* We have enough room at STRING.  */
3342       string[0] = algo;
3343       memcpy (string+1, oidbuf+1, oid_len-1);
3344       err = change_keyattr (app, keyno, string, oid_len, pincb, pincb_arg);
3345       gcry_mpi_release (oid);
3346     }
3347   else
3348     err = gpg_error (GPG_ERR_PUBKEY_ALGO);
3349
3350  leave:
3351   xfree (string);
3352   return err;
3353 }
3354
3355
3356 static gpg_error_t
3357 rsa_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3358               void *pincb_arg, int keyno,
3359               const unsigned char *buf, size_t buflen, int depth)
3360 {
3361   gpg_error_t err;
3362   const unsigned char *tok;
3363   size_t toklen;
3364   int last_depth1, last_depth2;
3365   const unsigned char *rsa_n = NULL;
3366   const unsigned char *rsa_e = NULL;
3367   const unsigned char *rsa_p = NULL;
3368   const unsigned char *rsa_q = NULL;
3369   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3370   unsigned int nbits;
3371   unsigned int maxbits;
3372   unsigned char *template = NULL;
3373   unsigned char *tp;
3374   size_t template_len;
3375   unsigned char fprbuf[20];
3376   u32 created_at = 0;
3377
3378   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
3379     {
3380       log_error (_("unsupported algorithm: %s"), "RSA");
3381       err = gpg_error (GPG_ERR_INV_VALUE);
3382       goto leave;
3383     }
3384
3385   last_depth1 = depth;
3386   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3387          && depth && depth >= last_depth1)
3388     {
3389       if (tok)
3390         {
3391           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3392           goto leave;
3393         }
3394       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3395         goto leave;
3396       if (tok && toklen == 1)
3397         {
3398           const unsigned char **mpi;
3399           size_t *mpi_len;
3400
3401           switch (*tok)
3402             {
3403             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
3404             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
3405             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
3406             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
3407             default: mpi = NULL;  mpi_len = NULL; break;
3408             }
3409           if (mpi && *mpi)
3410             {
3411               err = gpg_error (GPG_ERR_DUP_VALUE);
3412               goto leave;
3413             }
3414           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3415             goto leave;
3416           if (tok && mpi)
3417             {
3418               /* Strip off leading zero bytes and save. */
3419               for (;toklen && !*tok; toklen--, tok++)
3420                 ;
3421               *mpi = tok;
3422               *mpi_len = toklen;
3423             }
3424         }
3425       /* Skip until end of list. */
3426       last_depth2 = depth;
3427       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3428              && depth && depth >= last_depth2)
3429         ;
3430       if (err)
3431         goto leave;
3432     }
3433   /* Parse other attributes. */
3434   last_depth1 = depth;
3435   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3436          && depth && depth >= last_depth1)
3437     {
3438       if (tok)
3439         {
3440           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3441           goto leave;
3442         }
3443       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3444         goto leave;
3445       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3446         {
3447           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3448             goto leave;
3449           if (tok)
3450             {
3451               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3452                    tok++, toklen--)
3453                 created_at = created_at*10 + (*tok - '0');
3454             }
3455         }
3456       /* Skip until end of list. */
3457       last_depth2 = depth;
3458       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3459              && depth && depth >= last_depth2)
3460         ;
3461       if (err)
3462         goto leave;
3463     }
3464
3465
3466   /* Check that we have all parameters and that they match the card
3467      description. */
3468   if (!created_at)
3469     {
3470       log_error (_("creation timestamp missing\n"));
3471       err = gpg_error (GPG_ERR_INV_VALUE);
3472       goto leave;
3473     }
3474
3475   maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3476   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
3477   if (opt.verbose)
3478     log_info ("RSA modulus size is %u bits\n", nbits);
3479   if (nbits && nbits != maxbits
3480       && app->app_local->extcap.algo_attr_change)
3481     {
3482       /* Try to switch the key to a new length.  */
3483       err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3484       if (!err)
3485         maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3486     }
3487   if (nbits != maxbits)
3488     {
3489       log_error (_("RSA modulus missing or not of size %d bits\n"),
3490                  (int)maxbits);
3491       err = gpg_error (GPG_ERR_BAD_SECKEY);
3492       goto leave;
3493     }
3494
3495   maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
3496   if (maxbits > 32 && !app->app_local->extcap.is_v2)
3497     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
3498   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
3499   if (nbits < 2 || nbits > maxbits)
3500     {
3501       log_error (_("RSA public exponent missing or larger than %d bits\n"),
3502                  (int)maxbits);
3503       err = gpg_error (GPG_ERR_BAD_SECKEY);
3504       goto leave;
3505     }
3506
3507   maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
3508   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
3509   if (nbits != maxbits)
3510     {
3511       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3512                  "P", (int)maxbits);
3513       err = gpg_error (GPG_ERR_BAD_SECKEY);
3514       goto leave;
3515     }
3516   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
3517   if (nbits != maxbits)
3518     {
3519       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3520                  "Q", (int)maxbits);
3521       err = gpg_error (GPG_ERR_BAD_SECKEY);
3522       goto leave;
3523     }
3524
3525   /* We need to remove the cached public key.  */
3526   xfree (app->app_local->pk[keyno].key);
3527   app->app_local->pk[keyno].key = NULL;
3528   app->app_local->pk[keyno].keylen = 0;
3529   app->app_local->pk[keyno].read_done = 0;
3530
3531
3532   if (app->app_local->extcap.is_v2)
3533     {
3534       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
3535       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
3536       gcry_mpi_t mpi_e, mpi_p, mpi_q;
3537       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
3538       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
3539       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
3540       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
3541       int exmode;
3542
3543       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
3544       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
3545       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
3546       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
3547
3548       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
3549       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
3550       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
3551       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
3552       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
3553
3554       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
3555       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
3556       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
3557
3558       gcry_mpi_release (mpi_e);
3559       gcry_mpi_release (mpi_p);
3560       gcry_mpi_release (mpi_q);
3561       gcry_mpi_release (mpi_u);
3562       gcry_mpi_release (mpi_dp);
3563       gcry_mpi_release (mpi_dq);
3564       gcry_mpi_release (mpi_tmp);
3565
3566       /* Build the private key template as described in section 4.3.3.7 of
3567          the OpenPGP card specs version 2.0.  */
3568       err = build_privkey_template (app, keyno,
3569                                     rsa_n, rsa_n_len,
3570                                     rsa_e, rsa_e_len,
3571                                     rsa_p, rsa_p_len,
3572                                     rsa_q, rsa_q_len,
3573                                     rsa_u, rsa_u_len,
3574                                     rsa_dp, rsa_dp_len,
3575                                     rsa_dq, rsa_dq_len,
3576                                     &template, &template_len);
3577       xfree(rsa_u);
3578       xfree(rsa_dp);
3579       xfree(rsa_dq);
3580