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