build: Build gpg-pair-tool only when there is newer libgcrypt.
[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 #include "scdaemon.h"
54 #include "../common/util.h"
55 #include "../common/i18n.h"
56 #include "iso7816.h"
57 #include "../common/tlv.h"
58 #include "../common/host2net.h"
59 #include "../common/openpgpdefs.h"
60
61
62
63 /* The AID of this application.  */
64 static char const openpgp_aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
65
66
67 /* A table describing the DOs of the card.  */
68 static struct {
69   int tag;
70   int constructed;
71   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
72   unsigned int binary:1;
73   unsigned int dont_cache:1;
74   unsigned int flush_on_error:1;
75   unsigned int get_immediate_in_v11:1; /* Enable a hack to bypass the cache of
76                                  this data object if it is used in 1.1
77                                  and later versions of the card.  This
78                                  does not work with composite DO and
79                                  is currently only useful for the CHV
80                                  status bytes. */
81   unsigned int try_extlen:2;           /* Large object; try to use an extended
82                                  length APDU when !=0.  The size is
83                                  determined by extcap.max_certlen_3
84                                  when == 1, and by extcap.max_special_do
85                                  when == 2.  */
86   char *desc;
87 } data_objects[] = {
88   { 0x005E, 0,    0, 1, 0, 0, 0, 2, "Login Data" },
89   { 0x5F50, 0,    0, 0, 0, 0, 0, 2, "URL" },
90   { 0x5F52, 0,    0, 1, 0, 0, 0, 0, "Historical Bytes" },
91   { 0x0065, 1,    0, 1, 0, 0, 0, 0, "Cardholder Related Data"},
92   { 0x005B, 0, 0x65, 0, 0, 0, 0, 0, "Name" },
93   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, 0, "Language preferences" },
94   { 0x5F35, 0, 0x65, 0, 0, 0, 0, 0, "Salutation" },
95   { 0x006E, 1,    0, 1, 0, 0, 0, 0, "Application Related Data" },
96   { 0x004F, 0, 0x6E, 1, 0, 0, 0, 0, "AID" },
97   { 0x0073, 1,    0, 1, 0, 0, 0, 0, "Discretionary Data Objects" },
98   { 0x0047, 0, 0x6E, 1, 1, 0, 0, 0, "Card Capabilities" },
99   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, 0, "Extended Card Capabilities" },
100   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Signature" },
101   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Decryption" },
102   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Authentication" },
103   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, 0, "CHV Status Bytes" },
104   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, 0, "Fingerprints" },
105   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, 0, "CA Fingerprints" },
106   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, 0, "Generation time" },
107   { 0x007A, 1,    0, 1, 0, 0, 0, 0, "Security Support Template" },
108   { 0x0093, 0, 0x7A, 1, 1, 0, 0, 0, "Digital Signature Counter" },
109   { 0x0101, 0,    0, 0, 0, 0, 0, 2, "Private DO 1"},
110   { 0x0102, 0,    0, 0, 0, 0, 0, 2, "Private DO 2"},
111   { 0x0103, 0,    0, 0, 0, 0, 0, 2, "Private DO 3"},
112   { 0x0104, 0,    0, 0, 0, 0, 0, 2, "Private DO 4"},
113   { 0x7F21, 1,    0, 1, 0, 0, 0, 1, "Cardholder certificate"},
114   /* V3.0 */
115   { 0x7F74, 0, 0x6E, 1, 0, 0, 0, 0, "General Feature Management"},
116   { 0x00D5, 0,    0, 1, 0, 0, 0, 0, "AES key data"},
117   { 0x00D6, 0, 0x6E, 1, 0, 0, 0, 0, "UIF for Signature"},
118   { 0x00D7, 0, 0x6E, 1, 0, 0, 0, 0, "UIF for Decryption"},
119   { 0x00D8, 0, 0x6E, 1, 0, 0, 0, 0, "UIF for Authentication"},
120   { 0x00F9, 0,    0, 1, 0, 0, 0, 0, "KDF data object"},
121   { 0 }
122 };
123
124
125 /* Type of keys.  */
126 typedef enum
127   {
128     KEY_TYPE_ECC,
129     KEY_TYPE_RSA,
130   }
131 key_type_t;
132
133
134 /* The format of RSA private keys.  */
135 typedef enum
136   {
137     RSA_UNKNOWN_FMT,
138     RSA_STD,
139     RSA_STD_N,
140     RSA_CRT,
141     RSA_CRT_N
142   }
143 rsa_key_format_t;
144
145
146 /* One cache item for DOs.  */
147 struct cache_s {
148   struct cache_s *next;
149   int tag;
150   size_t length;
151   unsigned char data[1];
152 };
153
154
155 /* Object with application (i.e. OpenPGP card) specific data.  */
156 struct app_local_s {
157   /* A linked list with cached DOs.  */
158   struct cache_s *cache;
159
160   /* Keep track of the public keys.  */
161   struct
162   {
163     int read_done;   /* True if we have at least tried to read them.  */
164     unsigned char *key; /* This is a malloced buffer with a canonical
165                            encoded S-expression encoding a public
166                            key. Might be NULL if key is not
167                            available.  */
168     size_t keylen;      /* The length of the above S-expression.  This
169                            is usually only required for cross checks
170                            because the length of an S-expression is
171                            implicitly available.  */
172     unsigned char keygrip_str[41]; /* The keygrip, null terminated */
173   } pk[3];
174
175   unsigned char status_indicator; /* The card status indicator.  */
176
177   unsigned int manufacturer:16;   /* Manufacturer ID from the s/n.  */
178
179   /* Keep track of the ISO card capabilities.  */
180   struct
181   {
182     unsigned int cmd_chaining:1;  /* Command chaining is supported.  */
183     unsigned int ext_lc_le:1;     /* Extended Lc and Le are supported.  */
184   } cardcap;
185
186   /* Keep track of extended card capabilities.  */
187   struct
188   {
189     unsigned int is_v2:1;              /* Compatible to v2 or later.        */
190     unsigned int extcap_v3:1;          /* Extcap is in v3 format.           */
191     unsigned int has_button:1;         /* Has confirmation button or not.   */
192
193     unsigned int sm_supported:1;       /* Secure Messaging is supported.    */
194     unsigned int get_challenge:1;
195     unsigned int key_import:1;
196     unsigned int change_force_chv:1;
197     unsigned int private_dos:1;
198     unsigned int algo_attr_change:1;   /* Algorithm attributes changeable.  */
199     unsigned int has_decrypt:1;        /* Support symmetric decryption.     */
200     unsigned int kdf_do:1;                /* Support KDF DO.                */
201
202     unsigned int sm_algo:2;            /* Symmetric crypto algo for SM.     */
203     unsigned int pin_blk2:1;           /* PIN block 2 format supported.     */
204     unsigned int mse:1;                /* MSE command supported.            */
205     unsigned int max_certlen_3:16;
206     unsigned int max_get_challenge:16; /* Maximum size for get_challenge.   */
207     unsigned int max_special_do:16;    /* Maximum size for special DOs.     */
208   } extcap;
209
210   /* Flags used to control the application.  */
211   struct
212   {
213     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
214     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
215   } flags;
216
217   /* Pinpad request specified on card.  */
218   struct
219   {
220     unsigned int specified:1;
221     int fixedlen_user;
222     int fixedlen_admin;
223   } pinpad;
224
225    struct
226    {
227     key_type_t key_type;
228     union {
229       struct {
230         unsigned int n_bits;     /* Size of the modulus in bits.  The rest
231                                     of this strucuire is only valid if
232                                     this is not 0.  */
233         unsigned int e_bits;     /* Size of the public exponent in bits.  */
234         rsa_key_format_t format;
235       } rsa;
236       struct {
237         const char *curve;
238         int flags;
239       } ecc;
240     };
241    } keyattr[3];
242 };
243
244 #define ECC_FLAG_DJB_TWEAK (1 << 0)
245 #define ECC_FLAG_PUBKEY    (1 << 1)
246
247
248 /***** Local prototypes  *****/
249 static unsigned long convert_sig_counter_value (const unsigned char *value,
250                                                 size_t valuelen);
251 static unsigned long get_sig_counter (app_t app);
252 static gpg_error_t do_auth (app_t app, const char *keyidstr,
253                             gpg_error_t (*pincb)(void*, const char *, char **),
254                             void *pincb_arg,
255                             const void *indata, size_t indatalen,
256                             unsigned char **outdata, size_t *outdatalen);
257 static void parse_algorithm_attribute (app_t app, int keyno);
258 static gpg_error_t change_keyattr_from_string
259                            (app_t app,
260                             gpg_error_t (*pincb)(void*, const char *, char **),
261                             void *pincb_arg,
262                             const void *value, size_t valuelen);
263
264
265
266
267 \f
268 /* Deconstructor. */
269 static void
270 do_deinit (app_t app)
271 {
272   if (app && app->app_local)
273     {
274       struct cache_s *c, *c2;
275       int i;
276
277       for (c = app->app_local->cache; c; c = c2)
278         {
279           c2 = c->next;
280           xfree (c);
281         }
282
283       for (i=0; i < DIM (app->app_local->pk); i++)
284         {
285           xfree (app->app_local->pk[i].key);
286           app->app_local->pk[i].read_done = 0;
287         }
288       xfree (app->app_local);
289       app->app_local = NULL;
290     }
291 }
292
293
294 /* Wrapper around iso7816_get_data which first tries to get the data
295    from the cache.  With GET_IMMEDIATE passed as true, the cache is
296    bypassed.  With TRY_EXTLEN extended lengths APDUs are use if
297    supported by the card.  */
298 static gpg_error_t
299 get_cached_data (app_t app, int tag,
300                  unsigned char **result, size_t *resultlen,
301                  int get_immediate, int try_extlen)
302 {
303   gpg_error_t err;
304   int i;
305   unsigned char *p;
306   size_t len;
307   struct cache_s *c;
308   int exmode;
309
310   *result = NULL;
311   *resultlen = 0;
312
313   if (!get_immediate)
314     {
315       for (c=app->app_local->cache; c; c = c->next)
316         if (c->tag == tag)
317           {
318             if(c->length)
319               {
320                 p = xtrymalloc (c->length);
321                 if (!p)
322                   return gpg_error (gpg_err_code_from_errno (errno));
323                 memcpy (p, c->data, c->length);
324                 *result = p;
325               }
326
327             *resultlen = c->length;
328
329             return 0;
330           }
331     }
332
333   if (try_extlen && app->app_local->cardcap.ext_lc_le)
334     {
335       if (try_extlen == 1)
336         exmode = app->app_local->extcap.max_certlen_3;
337       else if (try_extlen == 2 && app->app_local->extcap.extcap_v3)
338         exmode = app->app_local->extcap.max_special_do;
339       else
340         exmode = 0;
341     }
342   else
343     exmode = 0;
344
345   err = iso7816_get_data (app_get_slot (app), exmode, tag, &p, &len);
346   if (err)
347     return err;
348   if (len)
349     *result = p;
350   *resultlen = len;
351
352   /* Check whether we should cache this object. */
353   if (get_immediate)
354     return 0;
355
356   for (i=0; data_objects[i].tag; i++)
357     if (data_objects[i].tag == tag)
358       {
359         if (data_objects[i].dont_cache)
360           return 0;
361         break;
362       }
363
364   /* Okay, cache it. */
365   for (c=app->app_local->cache; c; c = c->next)
366     assert (c->tag != tag);
367
368   c = xtrymalloc (sizeof *c + len);
369   if (c)
370     {
371       if (len)
372         memcpy (c->data, p, len);
373       else
374         xfree (p);
375       c->length = len;
376       c->tag = tag;
377       c->next = app->app_local->cache;
378       app->app_local->cache = c;
379     }
380
381   return 0;
382 }
383
384 /* Remove DO at TAG from the cache. */
385 static void
386 flush_cache_item (app_t app, int tag)
387 {
388   struct cache_s *c, *cprev;
389   int i;
390
391   if (!app->app_local)
392     return;
393
394   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
395     if (c->tag == tag)
396       {
397         if (cprev)
398           cprev->next = c->next;
399         else
400           app->app_local->cache = c->next;
401         xfree (c);
402
403         for (c=app->app_local->cache; c ; c = c->next)
404           {
405             assert (c->tag != tag); /* Oops: duplicated entry. */
406           }
407         return;
408       }
409
410   /* Try again if we have an outer tag. */
411   for (i=0; data_objects[i].tag; i++)
412     if (data_objects[i].tag == tag && data_objects[i].get_from
413         && data_objects[i].get_from != tag)
414       flush_cache_item (app, data_objects[i].get_from);
415 }
416
417 /* Flush all entries from the cache which might be out of sync after
418    an error. */
419 static void
420 flush_cache_after_error (app_t app)
421 {
422   int i;
423
424   for (i=0; data_objects[i].tag; i++)
425     if (data_objects[i].flush_on_error)
426       flush_cache_item (app, data_objects[i].tag);
427 }
428
429
430 /* Flush the entire cache. */
431 static void
432 flush_cache (app_t app)
433 {
434   if (app && app->app_local)
435     {
436       struct cache_s *c, *c2;
437
438       for (c = app->app_local->cache; c; c = c2)
439         {
440           c2 = c->next;
441           xfree (c);
442         }
443       app->app_local->cache = NULL;
444     }
445 }
446
447
448 /* Get the DO identified by TAG from the card in SLOT and return a
449    buffer with its content in RESULT and NBYTES.  The return value is
450    NULL if not found or a pointer which must be used to release the
451    buffer holding value. */
452 static void *
453 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
454             int *r_rc)
455 {
456   int rc, i;
457   unsigned char *buffer;
458   size_t buflen;
459   unsigned char *value;
460   size_t valuelen;
461   int dummyrc;
462   int exmode;
463
464   if (!r_rc)
465     r_rc = &dummyrc;
466
467   *result = NULL;
468   *nbytes = 0;
469   *r_rc = 0;
470   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
471     ;
472
473   if (app->appversion > 0x0100 && data_objects[i].get_immediate_in_v11)
474     {
475       exmode = 0;
476       rc = iso7816_get_data (app_get_slot (app), exmode, tag, &buffer, &buflen);
477       if (rc)
478         {
479           *r_rc = rc;
480           return NULL;
481         }
482       *result = buffer;
483       *nbytes = buflen;
484       return buffer;
485     }
486
487   value = NULL;
488   rc = -1;
489   if (data_objects[i].tag && data_objects[i].get_from)
490     {
491       rc = get_cached_data (app, data_objects[i].get_from,
492                             &buffer, &buflen,
493                             (data_objects[i].dont_cache
494                              || data_objects[i].get_immediate_in_v11),
495                             data_objects[i].try_extlen);
496       if (!rc)
497         {
498           const unsigned char *s;
499
500           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
501           if (!s)
502             value = NULL; /* not found */
503           else if (valuelen > buflen - (s - buffer))
504             {
505               log_error ("warning: constructed DO too short\n");
506               value = NULL;
507               xfree (buffer); buffer = NULL;
508             }
509           else
510             value = buffer + (s - buffer);
511         }
512     }
513
514   if (!value) /* Not in a constructed DO, try simple. */
515     {
516       rc = get_cached_data (app, tag, &buffer, &buflen,
517                             (data_objects[i].dont_cache
518                              || data_objects[i].get_immediate_in_v11),
519                             data_objects[i].try_extlen);
520       if (!rc)
521         {
522           value = buffer;
523           valuelen = buflen;
524         }
525     }
526
527   if (!rc)
528     {
529       *nbytes = valuelen;
530       *result = value;
531       return buffer;
532     }
533   *r_rc = rc;
534   return NULL;
535 }
536
537
538 static void
539 dump_all_do (int slot)
540 {
541   int rc, i, j;
542   unsigned char *buffer;
543   size_t buflen;
544
545   for (i=0; data_objects[i].tag; i++)
546     {
547       if (data_objects[i].get_from)
548         continue;
549
550       /* We don't try extended length APDU because such large DO would
551          be pretty useless in a log file.  */
552       rc = iso7816_get_data (slot, 0, data_objects[i].tag, &buffer, &buflen);
553       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
554         ;
555       else if (rc)
556         log_info ("DO '%s' not available: %s\n",
557                   data_objects[i].desc, gpg_strerror (rc));
558       else
559         {
560           if (data_objects[i].binary)
561             {
562               log_info ("DO '%s': ", data_objects[i].desc);
563               log_printhex (buffer, buflen, "");
564             }
565           else
566             log_info ("DO '%s': '%.*s'\n",
567                       data_objects[i].desc,
568                       (int)buflen, buffer); /* FIXME: sanitize */
569
570           if (data_objects[i].constructed)
571             {
572               for (j=0; data_objects[j].tag; j++)
573                 {
574                   const unsigned char *value;
575                   size_t valuelen;
576
577                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
578                     continue;
579                   value = find_tlv_unchecked (buffer, buflen,
580                                               data_objects[j].tag, &valuelen);
581                   if (!value)
582                     ; /* not found */
583                   else if (valuelen > buflen - (value - buffer))
584                     log_error ("warning: constructed DO too short\n");
585                   else
586                     {
587                       if (data_objects[j].binary)
588                         {
589                           log_info ("DO '%s': ", data_objects[j].desc);
590                           if (valuelen > 200)
591                             log_info ("[%u]\n", (unsigned int)valuelen);
592                           else
593                             log_printhex (value, valuelen, "");
594                         }
595                       else
596                         log_info ("DO '%s': '%.*s'\n",
597                                   data_objects[j].desc,
598                                   (int)valuelen, value); /* FIXME: sanitize */
599                     }
600                 }
601             }
602         }
603       xfree (buffer); buffer = NULL;
604     }
605 }
606
607
608 /* Count the number of bits, assuming the A represents an unsigned big
609    integer of length LEN bytes. */
610 static unsigned int
611 count_bits (const unsigned char *a, size_t len)
612 {
613   unsigned int n = len * 8;
614   int i;
615
616   for (; len && !*a; len--, a++, n -=8)
617     ;
618   if (len)
619     {
620       for (i=7; i && !(*a & (1<<i)); i--)
621         n--;
622     }
623   return n;
624 }
625
626 /* GnuPG makes special use of the login-data DO, this function parses
627    the login data to store the flags for later use.  It may be called
628    at any time and should be called after changing the login-data DO.
629
630    Everything up to a LF is considered a mailbox or account name.  If
631    the first LF is followed by DC4 (0x14) control sequence are
632    expected up to the next LF.  Control sequences are separated by FS
633    (0x18) and consist of key=value pairs.  There are two keys defined:
634
635     F=<flags>
636
637     Where FLAGS is a plain hexadecimal number representing flag values.
638     The lsb is here the rightmost bit.  Defined flags bits are:
639
640       Bit 0 = CHV1 and CHV2 are not synchronized
641       Bit 1 = CHV2 has been set to the default PIN of "123456"
642               (this implies that bit 0 is also set).
643
644     P=<pinpad-request>
645
646     Where PINPAD_REQUEST is in the format of: <n> or <n>,<m>.
647     N for user PIN, M for admin PIN.  If M is missing it means M=N.
648     0 means to force not to use pinpad.
649
650 */
651 static void
652 parse_login_data (app_t app)
653 {
654   unsigned char *buffer, *p;
655   size_t buflen, len;
656   void *relptr;
657
658   /* Set defaults.  */
659   app->app_local->flags.no_sync = 0;
660   app->app_local->flags.def_chv2 = 0;
661   app->app_local->pinpad.specified = 0;
662   app->app_local->pinpad.fixedlen_user = -1;
663   app->app_local->pinpad.fixedlen_admin = -1;
664
665   /* Read the DO.  */
666   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
667   if (!relptr)
668     return; /* Ooops. */
669   for (; buflen; buflen--, buffer++)
670     if (*buffer == '\n')
671       break;
672   if (buflen < 2 || buffer[1] != '\x14')
673     {
674       xfree (relptr);
675       return; /* No control sequences.  */
676     }
677
678   buflen--;
679   buffer++;
680   do
681     {
682       buflen--;
683       buffer++;
684       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
685         {
686           /* Flags control sequence found.  */
687           int lastdig = 0;
688
689           /* For now we are only interested in the last digit, so skip
690              any leading digits but bail out on invalid characters. */
691           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
692             lastdig = xtoi_1 (p);
693           buffer = p;
694           buflen = len;
695           if (len && !(*p == '\n' || *p == '\x18'))
696             goto next;  /* Invalid characters in field.  */
697           app->app_local->flags.no_sync = !!(lastdig & 1);
698           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
699         }
700       else if (buflen > 1 && *buffer == 'P' && buffer[1] == '=')
701         {
702           /* Pinpad request control sequence found.  */
703           buffer += 2;
704           buflen -= 2;
705
706           if (buflen)
707             {
708               if (digitp (buffer))
709                 {
710                   char *q;
711                   int n, m;
712
713                   n = strtol (buffer, &q, 10);
714                   if (q >= (char *)buffer + buflen
715                       || *q == '\x18' || *q == '\n')
716                     m = n;
717                   else
718                     {
719                       if (*q++ != ',' || !digitp (q))
720                         goto next;
721                       m = strtol (q, &q, 10);
722                     }
723
724                   if (buflen < ((unsigned char *)q - buffer))
725                     break;
726
727                   buflen -= ((unsigned char *)q - buffer);
728                   buffer = q;
729
730                   if (buflen && !(*buffer == '\n' || *buffer == '\x18'))
731                     goto next;
732                   app->app_local->pinpad.specified = 1;
733                   app->app_local->pinpad.fixedlen_user = n;
734                   app->app_local->pinpad.fixedlen_admin = m;
735                 }
736             }
737         }
738     next:
739       /* Skip to FS (0x18) or LF (\n).  */
740       for (; buflen && *buffer != '\x18' && *buffer != '\n'; buflen--)
741         buffer++;
742     }
743   while (buflen && *buffer != '\n');
744
745   xfree (relptr);
746 }
747
748
749 #define MAX_ARGS_STORE_FPR 3
750
751 /* Note, that FPR must be at least 20 bytes. */
752 static gpg_error_t
753 store_fpr (app_t app, int keynumber, u32 timestamp, unsigned char *fpr,
754            int algo, ...)
755 {
756   unsigned int n, nbits;
757   unsigned char *buffer, *p;
758   int tag, tag2;
759   int rc;
760   const unsigned char *m[MAX_ARGS_STORE_FPR];
761   size_t mlen[MAX_ARGS_STORE_FPR];
762   va_list ap;
763   int argc;
764   int i;
765
766   n = 6;    /* key packet version, 4-byte timestamps, and algorithm */
767   if (algo == PUBKEY_ALGO_ECDH)
768     argc = 3;
769   else
770     argc = 2;
771
772   va_start (ap, algo);
773   for (i = 0; i < argc; i++)
774     {
775       m[i] = va_arg (ap, const unsigned char *);
776       mlen[i] = va_arg (ap, size_t);
777       if (algo == PUBKEY_ALGO_RSA || i == 1)
778         n += 2;
779       n += mlen[i];
780     }
781   va_end (ap);
782
783   p = buffer = xtrymalloc (3 + n);
784   if (!buffer)
785     return gpg_error_from_syserror ();
786
787   *p++ = 0x99;     /* ctb */
788   *p++ = n >> 8;   /* 2 byte length header */
789   *p++ = n;
790   *p++ = 4;        /* key packet version */
791   *p++ = timestamp >> 24;
792   *p++ = timestamp >> 16;
793   *p++ = timestamp >>  8;
794   *p++ = timestamp;
795   *p++ = algo;
796
797   for (i = 0; i < argc; i++)
798     {
799       if (algo == PUBKEY_ALGO_RSA || i == 1)
800         {
801           nbits = count_bits (m[i], mlen[i]);
802           *p++ = nbits >> 8;
803           *p++ = nbits;
804         }
805       memcpy (p, m[i], mlen[i]);
806       p += mlen[i];
807     }
808
809   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
810
811   xfree (buffer);
812
813   tag = (app->appversion > 0x0007? 0xC7 : 0xC6) + keynumber;
814   flush_cache_item (app, 0xC5);
815   tag2 = 0xCE + keynumber;
816   flush_cache_item (app, 0xCD);
817
818   rc = iso7816_put_data (app_get_slot (app), 0, tag, fpr, 20);
819   if (rc)
820     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
821
822   if (!rc && app->appversion > 0x0100)
823     {
824       unsigned char buf[4];
825
826       buf[0] = timestamp >> 24;
827       buf[1] = timestamp >> 16;
828       buf[2] = timestamp >>  8;
829       buf[3] = timestamp;
830
831       rc = iso7816_put_data (app_get_slot (app), 0, tag2, buf, 4);
832       if (rc)
833         log_error (_("failed to store the creation date: %s\n"),
834                    gpg_strerror (rc));
835     }
836
837   return rc;
838 }
839
840
841 static void
842 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
843                       int number, const unsigned char *fpr)
844 {
845   int i;
846   char buf[41];
847   char numbuf[25];
848
849   for (i=0; i < 20 && !fpr[i]; i++)
850     ;
851   if (i==20)
852     return; /* All zero. */
853   bin2hex (fpr, 20, buf);
854   if (number == -1)
855     *numbuf = 0; /* Don't print the key number */
856   else
857     sprintf (numbuf, "%d", number);
858   send_status_info (ctrl, keyword,
859                     numbuf, (size_t)strlen(numbuf),
860                     buf, (size_t)strlen (buf), NULL, 0);
861 }
862
863 static void
864 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
865                           int number, const unsigned char *stamp)
866 {
867   char numbuf1[50], numbuf2[50];
868   unsigned long value;
869
870   value = buf32_to_ulong (stamp);
871   if (!value)
872     return;
873   sprintf (numbuf1, "%d", number);
874   sprintf (numbuf2, "%lu", value);
875   send_status_info (ctrl, keyword,
876                     numbuf1, (size_t)strlen(numbuf1),
877                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
878 }
879
880 static void
881 send_key_data (ctrl_t ctrl, const char *name,
882                const unsigned char *a, size_t alen)
883 {
884   char *buffer, *buf;
885   size_t buflen;
886
887   buffer = buf = bin2hex (a, alen, NULL);
888   if (!buffer)
889     {
890       log_error ("memory allocation error in send_key_data\n");
891       return;
892     }
893   buflen = strlen (buffer);
894
895   /* 768 is the hexified size for the modulus of an 3072 bit key.  We
896      use extra chunks to transmit larger data (i.e for 4096 bit).  */
897   for ( ;buflen > 768; buflen -= 768, buf += 768)
898     send_status_info (ctrl, "KEY-DATA",
899                       "-", 1,
900                       buf, 768,
901                       NULL, 0);
902   send_status_info (ctrl, "KEY-DATA",
903                     name, (size_t)strlen(name),
904                     buf, buflen,
905                     NULL, 0);
906   xfree (buffer);
907 }
908
909
910 static void
911 send_key_attr (ctrl_t ctrl, app_t app, const char *keyword, int keyno)
912 {
913   char buffer[200];
914
915   assert (keyno >=0 && keyno < DIM(app->app_local->keyattr));
916
917   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
918     snprintf (buffer, sizeof buffer, "%d 1 rsa%u %u %d",
919               keyno+1,
920               app->app_local->keyattr[keyno].rsa.n_bits,
921               app->app_local->keyattr[keyno].rsa.e_bits,
922               app->app_local->keyattr[keyno].rsa.format);
923   else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
924     {
925       snprintf (buffer, sizeof buffer, "%d %d %s",
926                 keyno+1,
927                 keyno==1? PUBKEY_ALGO_ECDH :
928                 (app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK)?
929                 PUBKEY_ALGO_EDDSA : PUBKEY_ALGO_ECDSA,
930                 app->app_local->keyattr[keyno].ecc.curve);
931     }
932   else
933     snprintf (buffer, sizeof buffer, "%d 0 0 UNKNOWN", keyno+1);
934
935   send_status_direct (ctrl, keyword, buffer);
936 }
937
938
939 #define RSA_SMALL_SIZE_KEY 1952
940 #define RSA_SMALL_SIZE_OP  2048
941
942 static int
943 determine_rsa_response (app_t app, int keyno)
944 {
945   int size;
946
947   size = 2 + 3 /* header */
948     + 4 /* tag+len */ + (app->app_local->keyattr[keyno].rsa.n_bits+7)/8
949     + 2 /* tag+len */ + (app->app_local->keyattr[keyno].rsa.e_bits+7)/8;
950
951   return size;
952 }
953
954
955 /* Implement the GETATTR command.  This is similar to the LEARN
956    command but returns just one value via the status interface. */
957 static gpg_error_t
958 do_getattr (app_t app, ctrl_t ctrl, const char *name)
959 {
960   static struct {
961     const char *name;
962     int tag;
963     int special;
964   } table[] = {
965     { "DISP-NAME",    0x005B },
966     { "LOGIN-DATA",   0x005E },
967     { "DISP-LANG",    0x5F2D },
968     { "DISP-SEX",     0x5F35 },
969     { "PUBKEY-URL",   0x5F50 },
970     { "KEY-FPR",      0x00C5, 3 },
971     { "KEY-TIME",     0x00CD, 4 },
972     { "KEY-ATTR",     0x0000, -5 },
973     { "CA-FPR",       0x00C6, 3 },
974     { "CHV-STATUS",   0x00C4, 1 },
975     { "SIG-COUNTER",  0x0093, 2 },
976     { "SERIALNO",     0x004F, -1 },
977     { "AID",          0x004F },
978     { "EXTCAP",       0x0000, -2 },
979     { "PRIVATE-DO-1", 0x0101 },
980     { "PRIVATE-DO-2", 0x0102 },
981     { "PRIVATE-DO-3", 0x0103 },
982     { "PRIVATE-DO-4", 0x0104 },
983     { "$AUTHKEYID",   0x0000, -3 },
984     { "$ENCRKEYID",   0x0000, -6 },
985     { "$SIGNKEYID",   0x0000, -7 },
986     { "$DISPSERIALNO",0x0000, -4 },
987     { "UIF-1",        0x00D6, 0 },
988     { "UIF-2",        0x00D7, 0 },
989     { "UIF-3",        0x00D8, 0 },
990     { "KDF",          0x00F9 },
991     { NULL, 0 }
992   };
993   int idx, i, rc;
994   void *relptr;
995   unsigned char *value;
996   size_t valuelen;
997
998   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
999     ;
1000   if (!table[idx].name)
1001     return gpg_error (GPG_ERR_INV_NAME);
1002
1003   if (table[idx].special == -1)
1004     {
1005       /* The serial number is very special.  We could have used the
1006          AID DO to retrieve it.  The AID DO is available anyway but
1007          not hex formatted. */
1008       char *serial = app_get_serialno (app);
1009
1010       if (serial)
1011         {
1012           send_status_direct (ctrl, "SERIALNO", serial);
1013           xfree (serial);
1014         }
1015       return 0;
1016     }
1017   if (table[idx].special == -2)
1018     {
1019       char tmp[110];
1020
1021       snprintf (tmp, sizeof tmp,
1022                 "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d "
1023                 "sm=%d si=%u dec=%d bt=%d kdf=%d",
1024                 app->app_local->extcap.get_challenge,
1025                 app->app_local->extcap.key_import,
1026                 app->app_local->extcap.change_force_chv,
1027                 app->app_local->extcap.private_dos,
1028                 app->app_local->extcap.max_certlen_3,
1029                 app->app_local->extcap.algo_attr_change,
1030                 (app->app_local->extcap.sm_supported
1031                  ? (app->app_local->extcap.sm_algo == 0? CIPHER_ALGO_3DES :
1032                     (app->app_local->extcap.sm_algo == 1?
1033                      CIPHER_ALGO_AES : CIPHER_ALGO_AES256))
1034                  : 0),
1035                 app->app_local->status_indicator,
1036                 app->app_local->extcap.has_decrypt,
1037                 app->app_local->extcap.has_button,
1038                 app->app_local->extcap.kdf_do);
1039       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1040       return 0;
1041     }
1042   if (table[idx].special == -3)
1043     {
1044       char const tmp[] = "OPENPGP.3";
1045       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1046       return 0;
1047     }
1048   if (table[idx].special == -4)
1049     {
1050       char *serial = app_get_serialno (app);
1051
1052       if (serial)
1053         {
1054           if (strlen (serial) > 16+12)
1055             {
1056               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
1057               xfree (serial);
1058               return 0;
1059             }
1060           xfree (serial);
1061         }
1062       return gpg_error (GPG_ERR_INV_NAME);
1063     }
1064   if (table[idx].special == -5)
1065     {
1066       for (i=0; i < 3; i++)
1067         send_key_attr (ctrl, app, table[idx].name, i);
1068       return 0;
1069     }
1070   if (table[idx].special == -6)
1071     {
1072       char const tmp[] = "OPENPGP.2";
1073       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1074       return 0;
1075     }
1076   if (table[idx].special == -7)
1077     {
1078       char const tmp[] = "OPENPGP.1";
1079       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
1080       return 0;
1081     }
1082
1083   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
1084   if (relptr)
1085     {
1086       if (table[idx].special == 1)
1087         {
1088           char numbuf[7*23];
1089
1090           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
1091             sprintf (numbuf+strlen (numbuf), " %d", value[i]);
1092           send_status_info (ctrl, table[idx].name,
1093                             numbuf, strlen (numbuf), NULL, 0);
1094         }
1095       else if (table[idx].special == 2)
1096         {
1097           char numbuf[50];
1098
1099           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
1100           send_status_info (ctrl, table[idx].name,
1101                             numbuf, strlen (numbuf), NULL, 0);
1102         }
1103       else if (table[idx].special == 3)
1104         {
1105           if (valuelen >= 60)
1106             for (i=0; i < 3; i++)
1107               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
1108         }
1109       else if (table[idx].special == 4)
1110         {
1111           if (valuelen >= 12)
1112             for (i=0; i < 3; i++)
1113               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
1114         }
1115       else
1116         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
1117
1118       xfree (relptr);
1119     }
1120   return rc;
1121 }
1122
1123
1124 /* Return the DISP-NAME without any padding characters.  Caller must
1125  * free the result.  If not found or empty NULL is returned.  */
1126 static char *
1127 get_disp_name (app_t app)
1128 {
1129   int rc;
1130   void *relptr;
1131   unsigned char *value;
1132   size_t valuelen;
1133   char *string;
1134   char *p, *given;
1135   char *result;
1136
1137   relptr = get_one_do (app, 0x005B, &value, &valuelen, &rc);
1138   if (!relptr)
1139     return NULL;
1140
1141   string = xtrymalloc (valuelen + 1);
1142   if (!string)
1143     {
1144       xfree (relptr);
1145       return NULL;
1146     }
1147   memcpy (string, value, valuelen);
1148   string[valuelen] = 0;
1149   xfree (relptr);
1150
1151   /* Swap surname and given name.  */
1152   given = strstr (string, "<<");
1153   for (p = string; *p; p++)
1154     if (*p == '<')
1155       *p = ' ';
1156
1157   if (given && given[2])
1158     {
1159       *given = 0;
1160       given += 2;
1161       result = strconcat (given, " ", string, NULL);
1162     }
1163   else
1164     {
1165       result = string;
1166       string = NULL;
1167     }
1168
1169   xfree (string);
1170   return result;
1171 }
1172
1173
1174 /* Return the pretty formatted serialnumber.  On error NULL is
1175  * returned.  */
1176 static char *
1177 get_disp_serialno (app_t app)
1178 {
1179   char *serial = app_get_serialno (app);
1180
1181   /* For our OpenPGP cards we do not want to show the entire serial
1182    * number but a nicely reformatted actual serial number.  */
1183   if (serial && strlen (serial) > 16+12)
1184     {
1185       memmove (serial, serial+16, 4);
1186       serial[4] = ' ';
1187       /* memmove (serial+5, serial+20, 4); */
1188       /* serial[9] = ' '; */
1189       /* memmove (serial+10, serial+24, 4); */
1190       /* serial[14] = 0; */
1191       memmove (serial+5, serial+20, 8);
1192       serial[13] = 0;
1193     }
1194   return serial;
1195 }
1196
1197
1198 /* Return the number of remaining tries for the standard or the admin
1199  * pw.  Returns -1 on card error.  */
1200 static int
1201 get_remaining_tries (app_t app, int adminpw)
1202 {
1203   void *relptr;
1204   unsigned char *value;
1205   size_t valuelen;
1206   int remaining;
1207
1208   relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1209   if (!relptr || valuelen < 7)
1210     {
1211       log_error (_("error retrieving CHV status from card\n"));
1212       xfree (relptr);
1213       return -1;
1214     }
1215   remaining = value[adminpw? 6 : 4];
1216   xfree (relptr);
1217   return remaining;
1218 }
1219
1220
1221 /* Retrieve the fingerprint from the card inserted in SLOT and write
1222    the according hex representation to FPR.  Caller must have provide
1223    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
1224    error code. */
1225 static gpg_error_t
1226 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
1227 {
1228   gpg_error_t err = 0;
1229   void *relptr;
1230   unsigned char *value;
1231   size_t valuelen;
1232
1233   assert (keyno >=0 && keyno <= 2);
1234
1235   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
1236   if (relptr && valuelen >= 60)
1237     bin2hex (value+keyno*20, 20, fpr);
1238   else
1239     err = gpg_error (GPG_ERR_NOT_FOUND);
1240   xfree (relptr);
1241   return err;
1242 }
1243
1244
1245 /* Retrieve the public key material for the RSA key, whose fingerprint
1246    is FPR, from gpg output, which can be read through the stream FP.
1247    The RSA modulus will be stored at the address of M and MLEN, the
1248    public exponent at E and ELEN.  Returns zero on success, an error
1249    code on failure.  Caller must release the allocated buffers at M
1250    and E if the function returns success.  */
1251 static gpg_error_t
1252 retrieve_key_material (FILE *fp, const char *hexkeyid,
1253                        const unsigned char **m, size_t *mlen,
1254                        const unsigned char **e, size_t *elen)
1255 {
1256   gcry_error_t err = 0;
1257   char *line = NULL;    /* read_line() buffer. */
1258   size_t line_size = 0; /* Helper for for read_line. */
1259   int found_key = 0;    /* Helper to find a matching key. */
1260   unsigned char *m_new = NULL;
1261   unsigned char *e_new = NULL;
1262   size_t m_new_n = 0;
1263   size_t e_new_n = 0;
1264
1265   /* Loop over all records until we have found the subkey
1266      corresponding to the fingerprint. Inm general the first record
1267      should be the pub record, but we don't rely on that.  Given that
1268      we only need to look at one key, it is sufficient to compare the
1269      keyid so that we don't need to look at "fpr" records. */
1270   for (;;)
1271     {
1272       char *p;
1273       char *fields[6] = { NULL, NULL, NULL, NULL, NULL, NULL };
1274       int nfields;
1275       size_t max_length;
1276       gcry_mpi_t mpi;
1277       int i;
1278
1279       max_length = 4096;
1280       i = read_line (fp, &line, &line_size, &max_length);
1281       if (!i)
1282         break; /* EOF. */
1283       if (i < 0)
1284         {
1285           err = gpg_error_from_syserror ();
1286           goto leave; /* Error. */
1287         }
1288       if (!max_length)
1289         {
1290           err = gpg_error (GPG_ERR_TRUNCATED);
1291           goto leave;  /* Line truncated - we better stop processing.  */
1292         }
1293
1294       /* Parse the line into fields. */
1295       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
1296         {
1297           fields[nfields] = p;
1298           p = strchr (p, ':');
1299           if (p)
1300             *(p++) = 0;
1301         }
1302       if (!nfields)
1303         continue; /* No fields at all - skip line.  */
1304
1305       if (!found_key)
1306         {
1307           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1308                && nfields > 4 && !strcmp (fields[4], hexkeyid))
1309             found_key = 1;
1310           continue;
1311         }
1312
1313       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1314         break; /* Next key - stop.  */
1315
1316       if ( strcmp (fields[0], "pkd") )
1317         continue; /* Not a key data record.  */
1318       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1319            || (!i && m_new) || (i && e_new))
1320         {
1321           err = gpg_error (GPG_ERR_GENERAL);
1322           goto leave; /* Error: Invalid key data record or not an RSA key.  */
1323         }
1324
1325       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1326       if (err)
1327         mpi = NULL;
1328       else if (!i)
1329         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1330       else
1331         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1332       gcry_mpi_release (mpi);
1333       if (err)
1334         goto leave;
1335     }
1336
1337   if (m_new && e_new)
1338     {
1339       *m = m_new;
1340       *mlen = m_new_n;
1341       m_new = NULL;
1342       *e = e_new;
1343       *elen = e_new_n;
1344       e_new = NULL;
1345     }
1346   else
1347     err = gpg_error (GPG_ERR_GENERAL);
1348
1349  leave:
1350   xfree (m_new);
1351   xfree (e_new);
1352   xfree (line);
1353   return err;
1354 }
1355
1356
1357 static gpg_error_t
1358 rsa_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at,  int keyno,
1359                  const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
1360 {
1361   gpg_error_t err;
1362   const unsigned char *m, *e;
1363   size_t mlen, elen;
1364   unsigned char *mbuf = NULL, *ebuf = NULL;
1365
1366   m = find_tlv (data, datalen, 0x0081, &mlen);
1367   if (!m)
1368     {
1369       log_error (_("response does not contain the RSA modulus\n"));
1370       return gpg_error (GPG_ERR_CARD);
1371     }
1372
1373   e = find_tlv (data, datalen, 0x0082, &elen);
1374   if (!e)
1375     {
1376       log_error (_("response does not contain the RSA public exponent\n"));
1377       return gpg_error (GPG_ERR_CARD);
1378     }
1379
1380   if (ctrl)
1381     {
1382       send_key_data (ctrl, "n", m, mlen);
1383       send_key_data (ctrl, "e", e, elen);
1384     }
1385
1386   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
1387     ;
1388   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
1389     ;
1390
1391   if (ctrl)
1392     {
1393       unsigned char fprbuf[20];
1394
1395       err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
1396                        m, mlen, e, elen);
1397       if (err)
1398         return err;
1399
1400       send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1401     }
1402
1403   mbuf = xtrymalloc (mlen + 1);
1404   if (!mbuf)
1405     {
1406       err = gpg_error_from_syserror ();
1407       goto leave;
1408     }
1409   /* Prepend numbers with a 0 if needed.  */
1410   if (mlen && (*m & 0x80))
1411     {
1412       *mbuf = 0;
1413       memcpy (mbuf+1, m, mlen);
1414       mlen++;
1415     }
1416   else
1417     memcpy (mbuf, m, mlen);
1418
1419   ebuf = xtrymalloc (elen + 1);
1420   if (!ebuf)
1421     {
1422       err = gpg_error_from_syserror ();
1423       goto leave;
1424     }
1425   /* Prepend numbers with a 0 if needed.  */
1426   if (elen && (*e & 0x80))
1427     {
1428       *ebuf = 0;
1429       memcpy (ebuf+1, e, elen);
1430       elen++;
1431     }
1432   else
1433     memcpy (ebuf, e, elen);
1434
1435   err = gcry_sexp_build (r_sexp, NULL, "(public-key(rsa(n%b)(e%b)))",
1436                          (int)mlen, mbuf, (int)elen, ebuf);
1437  leave:
1438   xfree (mbuf);
1439   xfree (ebuf);
1440   return err;
1441 }
1442
1443
1444 /* Determine KDF hash algorithm and KEK encryption algorithm by CURVE.  */
1445 static const unsigned char*
1446 ecdh_params (const char *curve)
1447 {
1448   unsigned int nbits;
1449
1450   openpgp_curve_to_oid (curve, &nbits);
1451
1452   /* See RFC-6637 for those constants.
1453          0x03: Number of bytes
1454          0x01: Version for this parameter format
1455          KEK digest algorithm
1456          KEK cipher algorithm
1457   */
1458   if (nbits <= 256)
1459     return (const unsigned char*)"\x03\x01\x08\x07";
1460   else if (nbits <= 384)
1461     return (const unsigned char*)"\x03\x01\x09\x09";
1462   else
1463     return (const unsigned char*)"\x03\x01\x0a\x09";
1464 }
1465
1466 static gpg_error_t
1467 ecc_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
1468                  const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
1469 {
1470   gpg_error_t err;
1471   unsigned char *qbuf = NULL;
1472   const unsigned char *ecc_q;
1473   size_t ecc_q_len;
1474   gcry_mpi_t oid = NULL;
1475   int n;
1476   const char *curve;
1477   const char *oidstr;
1478   const unsigned char *oidbuf;
1479   size_t oid_len;
1480   int algo;
1481   const char *format;
1482
1483   ecc_q = find_tlv (data, datalen, 0x0086, &ecc_q_len);
1484   if (!ecc_q)
1485     {
1486       log_error (_("response does not contain the EC public key\n"));
1487       return gpg_error (GPG_ERR_CARD);
1488     }
1489
1490   curve = app->app_local->keyattr[keyno].ecc.curve;
1491   oidstr = openpgp_curve_to_oid (curve, NULL);
1492   err = openpgp_oid_from_str (oidstr, &oid);
1493   if (err)
1494     return err;
1495   oidbuf = gcry_mpi_get_opaque (oid, &n);
1496   if (!oidbuf)
1497     {
1498       err = gpg_error_from_syserror ();
1499       goto leave;
1500     }
1501   oid_len = (n+7)/8;
1502
1503   qbuf = xtrymalloc (ecc_q_len + 1);
1504   if (!qbuf)
1505     {
1506       err = gpg_error_from_syserror ();
1507       goto leave;
1508     }
1509
1510   if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1511     {               /* Prepend 0x40 prefix.  */
1512       *qbuf = 0x40;
1513       memcpy (qbuf+1, ecc_q, ecc_q_len);
1514       ecc_q_len++;
1515     }
1516   else
1517     memcpy (qbuf, ecc_q, ecc_q_len);
1518
1519   if (ctrl)
1520     {
1521       send_key_data (ctrl, "q", qbuf, ecc_q_len);
1522       send_key_data (ctrl, "curve", oidbuf, oid_len);
1523     }
1524
1525   if (keyno == 1)
1526     {
1527       if (ctrl)
1528         send_key_data (ctrl, "kdf/kek", ecdh_params (curve), (size_t)4);
1529       algo = PUBKEY_ALGO_ECDH;
1530     }
1531   else
1532     {
1533       if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1534         algo = PUBKEY_ALGO_EDDSA;
1535       else
1536         algo = PUBKEY_ALGO_ECDSA;
1537     }
1538
1539   if (ctrl)
1540     {
1541       unsigned char fprbuf[20];
1542
1543       err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
1544                        qbuf, ecc_q_len, ecdh_params (curve), (size_t)4);
1545       if (err)
1546         goto leave;
1547
1548       send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1549     }
1550
1551   if (!(app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1552     format = "(public-key(ecc(curve%s)(q%b)))";
1553   else if (keyno == 1)
1554     format = "(public-key(ecc(curve%s)(flags djb-tweak)(q%b)))";
1555   else
1556     format = "(public-key(ecc(curve%s)(flags eddsa)(q%b)))";
1557
1558   err = gcry_sexp_build (r_sexp, NULL, format,
1559                          app->app_local->keyattr[keyno].ecc.curve,
1560                          (int)ecc_q_len, qbuf);
1561  leave:
1562   gcry_mpi_release (oid);
1563   xfree (qbuf);
1564   return err;
1565 }
1566
1567
1568 static gpg_error_t
1569 store_keygrip (app_t app, int keyno)
1570 {
1571   gpg_error_t err;
1572   unsigned char grip[20];
1573
1574   err = keygrip_from_canon_sexp (app->app_local->pk[keyno].key,
1575                                  app->app_local->pk[keyno].keylen,
1576                                  grip);
1577   if (err)
1578     return err;
1579
1580   bin2hex (grip, 20, app->app_local->pk[keyno].keygrip_str);
1581   return 0;
1582 }
1583
1584
1585 /* Parse tag-length-value data for public key in BUFFER of BUFLEN
1586    length.  Key of KEYNO in APP is updated with an S-expression of
1587    public key.  When CTRL is not NULL, fingerprint is computed with
1588    CREATED_AT, and fingerprint is written to the card, and key data
1589    and fingerprint are send back to the client side.
1590  */
1591 static gpg_error_t
1592 read_public_key (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
1593                  const unsigned char *buffer, size_t buflen)
1594 {
1595   gpg_error_t err;
1596   const unsigned char *data;
1597   size_t datalen;
1598   gcry_sexp_t s_pkey = NULL;
1599
1600   data = find_tlv (buffer, buflen, 0x7F49, &datalen);
1601   if (!data)
1602     {
1603       log_error (_("response does not contain the public key data\n"));
1604       return gpg_error (GPG_ERR_CARD);
1605     }
1606
1607   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
1608     err = rsa_read_pubkey (app, ctrl, created_at, keyno,
1609                            data, datalen, &s_pkey);
1610   else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
1611     err = ecc_read_pubkey (app, ctrl, created_at, keyno,
1612                            data, datalen, &s_pkey);
1613   else
1614     err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1615
1616   if (!err)
1617     {
1618       unsigned char *keybuf;
1619       size_t len;
1620
1621       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1622       keybuf = xtrymalloc (len);
1623       if (!data)
1624         {
1625           err = gpg_error_from_syserror ();
1626           gcry_sexp_release (s_pkey);
1627           return err;
1628         }
1629
1630       gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1631       gcry_sexp_release (s_pkey);
1632
1633       app->app_local->pk[keyno].key = keybuf;
1634       /* Decrement for trailing '\0' */
1635       app->app_local->pk[keyno].keylen = len - 1;
1636
1637       err = store_keygrip (app, keyno);
1638     }
1639
1640   return err;
1641 }
1642
1643
1644 /* Get the public key for KEYNO and store it as an S-expression with
1645    the APP handle.  On error that field gets cleared.  If we already
1646    know about the public key we will just return.  Note that this does
1647    not mean a key is available; this is solely indicated by the
1648    presence of the app->app_local->pk[KEYNO].key field.
1649
1650    Note that GnuPG 1.x does not need this and it would be too time
1651    consuming to send it just for the fun of it. However, given that we
1652    use the same code in gpg 1.4, we can't use the gcry S-expression
1653    here but need to open encode it. */
1654 static gpg_error_t
1655 get_public_key (app_t app, int keyno)
1656 {
1657   gpg_error_t err = 0;
1658   unsigned char *buffer;
1659   const unsigned char *m, *e;
1660   size_t buflen;
1661   size_t mlen = 0;
1662   size_t elen = 0;
1663   char *keybuf = NULL;
1664   gcry_sexp_t s_pkey;
1665   size_t len;
1666
1667   if (keyno < 0 || keyno > 2)
1668     return gpg_error (GPG_ERR_INV_ID);
1669
1670   /* Already cached? */
1671   if (app->app_local->pk[keyno].read_done)
1672     return 0;
1673
1674   xfree (app->app_local->pk[keyno].key);
1675   app->app_local->pk[keyno].key = NULL;
1676   app->app_local->pk[keyno].keylen = 0;
1677
1678   m = e = NULL; /* (avoid cc warning) */
1679
1680   if (app->appversion > 0x0100)
1681     {
1682       int exmode, le_value;
1683
1684       /* We may simply read the public key out of these cards.  */
1685       if (app->app_local->cardcap.ext_lc_le
1686           && app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA
1687           && app->app_local->keyattr[keyno].rsa.n_bits > RSA_SMALL_SIZE_KEY)
1688         {
1689           exmode = 1;    /* Use extended length.  */
1690           le_value = determine_rsa_response (app, keyno);
1691         }
1692       else
1693         {
1694           exmode = 0;
1695           le_value = 256; /* Use legacy value. */
1696         }
1697
1698       err = iso7816_read_public_key (app_get_slot (app), exmode,
1699                                      (keyno == 0? "\xB6" :
1700                                       keyno == 1? "\xB8" : "\xA4"),
1701                                      2, le_value, &buffer, &buflen);
1702       if (err)
1703         {
1704           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1705           goto leave;
1706         }
1707
1708       err = read_public_key (app, NULL, 0U, keyno, buffer, buflen);
1709     }
1710   else
1711     {
1712       /* Due to a design problem in v1.0 cards we can't get the public
1713          key out of these cards without doing a verify on CHV3.
1714          Clearly that is not an option and thus we try to locate the
1715          key using an external helper.
1716
1717          The helper we use here is gpg itself, which should know about
1718          the key in any case.  */
1719
1720       char fpr[41];
1721       char *hexkeyid;
1722       char *command = NULL;
1723       FILE *fp;
1724       int ret;
1725
1726       buffer = NULL; /* We don't need buffer.  */
1727
1728       err = retrieve_fpr_from_card (app, keyno, fpr);
1729       if (err)
1730         {
1731           log_error ("error while retrieving fpr from card: %s\n",
1732                      gpg_strerror (err));
1733           goto leave;
1734         }
1735       hexkeyid = fpr + 24;
1736
1737       ret = gpgrt_asprintf
1738         (&command, "%s --list-keys --with-colons --with-key-data '%s'",
1739          gnupg_module_name (GNUPG_MODULE_NAME_GPG), fpr);
1740       if (ret < 0)
1741         {
1742           err = gpg_error_from_syserror ();
1743           goto leave;
1744         }
1745
1746       fp = popen (command, "r");
1747       xfree (command);
1748       if (!fp)
1749         {
1750           err = gpg_error_from_syserror ();
1751           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1752           goto leave;
1753         }
1754
1755       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1756       pclose (fp);
1757       if (err)
1758         {
1759           log_error ("error while retrieving key material through pipe: %s\n",
1760                      gpg_strerror (err));
1761           goto leave;
1762         }
1763
1764       err = gcry_sexp_build (&s_pkey, NULL, "(public-key(rsa(n%b)(e%b)))",
1765                              (int)mlen, m, (int)elen, e);
1766       if (err)
1767         goto leave;
1768
1769       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1770
1771       keybuf = xtrymalloc (len);
1772       if (!keybuf)
1773         {
1774           err = gpg_error_from_syserror ();
1775           gcry_sexp_release (s_pkey);
1776           goto leave;
1777         }
1778
1779       gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1780       gcry_sexp_release (s_pkey);
1781
1782       app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1783       /* Decrement for trailing '\0' */
1784       app->app_local->pk[keyno].keylen = len - 1;
1785       err = store_keygrip (app, keyno);
1786     }
1787
1788  leave:
1789   /* Set a flag to indicate that we tried to read the key.  */
1790   if (!err)
1791     app->app_local->pk[keyno].read_done = 1;
1792
1793   xfree (buffer);
1794   return err;
1795 }
1796
1797
1798 /* Send the KEYPAIRINFO back. KEY needs to be in the range [1,3].
1799    This is used by the LEARN command. */
1800 static gpg_error_t
1801 send_keypair_info (app_t app, ctrl_t ctrl, int key)
1802 {
1803   int keyno = key - 1;
1804   gpg_error_t err = 0;
1805   char idbuf[50];
1806   const char *usage;
1807
1808   err = get_public_key (app, keyno);
1809   if (err)
1810     goto leave;
1811
1812   assert (keyno >= 0 && keyno <= 2);
1813   if (!app->app_local->pk[keyno].key)
1814     goto leave; /* No such key - ignore. */
1815
1816   switch (keyno)
1817     {
1818     case 0: usage = "sc"; break;
1819     case 1: usage = "e";  break;
1820     case 2: usage = "sa"; break;
1821     default: usage = "";  break;
1822     }
1823
1824   sprintf (idbuf, "OPENPGP.%d", keyno+1);
1825   send_status_info (ctrl, "KEYPAIRINFO",
1826                     app->app_local->pk[keyno].keygrip_str, 40,
1827                     idbuf, strlen (idbuf),
1828                     usage, strlen (usage),
1829                     NULL, (size_t)0);
1830
1831  leave:
1832   return err;
1833 }
1834
1835
1836 /* Handle the LEARN command for OpenPGP.  */
1837 static gpg_error_t
1838 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1839 {
1840   (void)flags;
1841
1842   do_getattr (app, ctrl, "EXTCAP");
1843   do_getattr (app, ctrl, "DISP-NAME");
1844   do_getattr (app, ctrl, "DISP-LANG");
1845   do_getattr (app, ctrl, "DISP-SEX");
1846   do_getattr (app, ctrl, "PUBKEY-URL");
1847   do_getattr (app, ctrl, "LOGIN-DATA");
1848   do_getattr (app, ctrl, "KEY-FPR");
1849   if (app->appversion > 0x0100)
1850     do_getattr (app, ctrl, "KEY-TIME");
1851   do_getattr (app, ctrl, "CA-FPR");
1852   do_getattr (app, ctrl, "CHV-STATUS");
1853   do_getattr (app, ctrl, "SIG-COUNTER");
1854   if (app->app_local->extcap.kdf_do)
1855     do_getattr (app, ctrl, "KDF");
1856   if (app->app_local->extcap.has_button)
1857     {
1858       do_getattr (app, ctrl, "UIF-1");
1859       do_getattr (app, ctrl, "UIF-2");
1860       do_getattr (app, ctrl, "UIF-3");
1861     }
1862   if (app->app_local->extcap.private_dos)
1863     {
1864       do_getattr (app, ctrl, "PRIVATE-DO-1");
1865       do_getattr (app, ctrl, "PRIVATE-DO-2");
1866       if (app->did_chv2)
1867         do_getattr (app, ctrl, "PRIVATE-DO-3");
1868       if (app->did_chv3)
1869         do_getattr (app, ctrl, "PRIVATE-DO-4");
1870     }
1871   send_keypair_info (app, ctrl, 1);
1872   send_keypair_info (app, ctrl, 2);
1873   send_keypair_info (app, ctrl, 3);
1874   /* Note: We do not send the Cardholder Certificate, because that is
1875      relatively long and for OpenPGP applications not really needed.  */
1876   return 0;
1877 }
1878
1879
1880 /* Handle the READKEY command for OpenPGP.  On success a canonical
1881    encoded S-expression with the public key will get stored at PK and
1882    its length (for assertions) at PKLEN; the caller must release that
1883    buffer. On error PK and PKLEN are not changed and an error code is
1884    returned.  */
1885 static gpg_error_t
1886 do_readkey (app_t app, ctrl_t ctrl, const char *keyid, unsigned int flags,
1887             unsigned char **pk, size_t *pklen)
1888 {
1889   gpg_error_t err;
1890   int keyno;
1891   unsigned char *buf;
1892
1893   if (!strcmp (keyid, "OPENPGP.1"))
1894     keyno = 0;
1895   else if (!strcmp (keyid, "OPENPGP.2"))
1896     keyno = 1;
1897   else if (!strcmp (keyid, "OPENPGP.3"))
1898     keyno = 2;
1899   else
1900     return gpg_error (GPG_ERR_INV_ID);
1901
1902   err = get_public_key (app, keyno);
1903   if (err)
1904     return err;
1905
1906   buf = app->app_local->pk[keyno].key;
1907   if (!buf)
1908     return gpg_error (GPG_ERR_NO_PUBKEY);
1909
1910   if ((flags & APP_READKEY_FLAG_INFO))
1911     {
1912       err = send_keypair_info (app, ctrl, keyno+1);
1913       if (err)
1914         return err;
1915     }
1916
1917   if (pk && pklen)
1918     {
1919       *pklen = app->app_local->pk[keyno].keylen;
1920       *pk = xtrymalloc (*pklen);
1921       if (!*pk)
1922         {
1923           err = gpg_error_from_syserror ();
1924           *pklen = 0;
1925           return err;
1926         }
1927       memcpy (*pk, buf, *pklen);
1928     }
1929
1930   return 0;
1931 }
1932
1933 /* Read the standard certificate of an OpenPGP v2 card.  It is
1934    returned in a freshly allocated buffer with that address stored at
1935    CERT and the length of the certificate stored at CERTLEN.  CERTID
1936    needs to be set to "OPENPGP.3".  */
1937 static gpg_error_t
1938 do_readcert (app_t app, const char *certid,
1939              unsigned char **cert, size_t *certlen)
1940 {
1941   gpg_error_t err;
1942   unsigned char *buffer;
1943   size_t buflen;
1944   void *relptr;
1945
1946   *cert = NULL;
1947   *certlen = 0;
1948   if (strcmp (certid, "OPENPGP.3"))
1949     return gpg_error (GPG_ERR_INV_ID);
1950   if (!app->app_local->extcap.is_v2)
1951     return gpg_error (GPG_ERR_NOT_FOUND);
1952
1953   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1954   if (!relptr)
1955     return gpg_error (GPG_ERR_NOT_FOUND);
1956
1957   if (!buflen)
1958     err = gpg_error (GPG_ERR_NOT_FOUND);
1959   else if (!(*cert = xtrymalloc (buflen)))
1960     err = gpg_error_from_syserror ();
1961   else
1962     {
1963       memcpy (*cert, buffer, buflen);
1964       *certlen = buflen;
1965       err  = 0;
1966     }
1967   xfree (relptr);
1968   return err;
1969 }
1970
1971
1972 /* Decide if we use the pinpad of the reader for PIN input according
1973    to the user preference on the card, and the capability of the
1974    reader.  This routine is only called when the reader has pinpad.
1975    Returns 0 if we use pinpad, 1 otherwise.  */
1976 static int
1977 check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1978 {
1979   if (app->app_local->pinpad.specified == 0) /* No preference on card.  */
1980     {
1981       if (pininfo->fixedlen == 0) /* Reader has varlen capability.  */
1982         return 0;                 /* Then, use pinpad.  */
1983       else
1984         /*
1985          * Reader has limited capability, and it may not match PIN of
1986          * the card.
1987          */
1988         return 1;
1989     }
1990
1991   if (admin_pin)
1992     pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
1993   else
1994     pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
1995
1996   if (pininfo->fixedlen == 0    /* User requests disable pinpad.  */
1997       || pininfo->fixedlen < pininfo->minlen
1998       || pininfo->fixedlen > pininfo->maxlen
1999       /* Reader doesn't have the capability to input a PIN which
2000        * length is FIXEDLEN.  */)
2001     return 1;
2002
2003   return 0;
2004 }
2005
2006
2007 /* Return a string with information about the card for use in a
2008  * prompt.  Returns NULL on memory failure.  */
2009 static char *
2010 get_prompt_info (app_t app, int chvno, unsigned long sigcount, int remaining)
2011 {
2012   char *serial, *disp_name, *rembuf, *tmpbuf, *result;
2013
2014   serial = get_disp_serialno (app);
2015   if (!serial)
2016     return NULL;
2017
2018   disp_name = get_disp_name (app);
2019   if (chvno == 1)
2020     {
2021       /* TRANSLATORS: Put a \x1f right before a colon.  This can be
2022        * used by pinentry to nicely align the names and values.  Keep
2023        * the %s at the start and end of the string.  */
2024       result = xtryasprintf (_("%s"
2025                                "Number\x1f: %s%%0A"
2026                                "Holder\x1f: %s%%0A"
2027                                "Counter\x1f: %lu"
2028                                "%s"),
2029                              "\x1e",
2030                              serial,
2031                              disp_name? disp_name:"",
2032                              sigcount,
2033                              "");
2034     }
2035   else
2036     {
2037       result = xtryasprintf (_("%s"
2038                                "Number\x1f: %s%%0A"
2039                                "Holder\x1f: %s"
2040                                "%s"),
2041                              "\x1e",
2042                              serial,
2043                              disp_name? disp_name:"",
2044                              "");
2045     }
2046   xfree (disp_name);
2047   xfree (serial);
2048
2049   if (remaining != -1)
2050     {
2051       /* TRANSLATORS: This is the number of remaining attempts to
2052        * enter a PIN.  Use %%0A (double-percent,0A) for a linefeed. */
2053       rembuf = xtryasprintf (_("Remaining attempts: %d"), remaining);
2054       if (!rembuf)
2055         {
2056           xfree (result);
2057           return NULL;
2058         }
2059       tmpbuf = strconcat (result, "%0A%0A", rembuf, NULL);
2060       xfree (rembuf);
2061       if (!tmpbuf)
2062         {
2063           xfree (result);
2064           return NULL;
2065         }
2066       xfree (result);
2067       result = tmpbuf;
2068     }
2069
2070   return result;
2071 }
2072
2073 #define KDF_DATA_LENGTH_MIN  90
2074 #define KDF_DATA_LENGTH_MAX 110
2075
2076 /* Compute hash if KDF-DO is available.  CHVNO must be 0 for reset
2077    code, 1 or 2 for user pin and 3 for admin pin.
2078  */
2079 static gpg_error_t
2080 pin2hash_if_kdf (app_t app, int chvno, char *pinvalue, int *r_pinlen)
2081 {
2082   gpg_error_t err = 0;
2083   void *relptr = NULL;
2084   unsigned char *buffer;
2085   size_t buflen;
2086
2087   if (app->app_local->extcap.kdf_do
2088       && (relptr = get_one_do (app, 0x00F9, &buffer, &buflen, NULL))
2089       && buflen >= KDF_DATA_LENGTH_MIN && (buffer[2] == 0x03))
2090     {
2091       const char *salt;
2092       unsigned long s2k_count;
2093       char dek[32];
2094       int salt_index;
2095
2096       s2k_count = (((unsigned int)buffer[8] << 24)
2097                    | (buffer[9] << 16) | (buffer[10] << 8) | buffer[11]);
2098
2099       if (buflen == KDF_DATA_LENGTH_MIN)
2100         salt_index =14;
2101       else if (buflen == KDF_DATA_LENGTH_MAX)
2102         salt_index = (chvno==3 ? 34 : (chvno==0 ? 24 : 14));
2103       else
2104         {
2105           err = gpg_error (GPG_ERR_INV_DATA);
2106           goto leave;
2107         }
2108
2109       salt = &buffer[salt_index];
2110       err = gcry_kdf_derive (pinvalue, strlen (pinvalue),
2111                              GCRY_KDF_ITERSALTED_S2K,
2112                              DIGEST_ALGO_SHA256, salt, 8,
2113                              s2k_count, sizeof (dek), dek);
2114       if (!err)
2115         {
2116           /* pinvalue has a buffer of MAXLEN_PIN+1, 32 is OK.  */
2117           *r_pinlen = 32;
2118           memcpy (pinvalue, dek, *r_pinlen);
2119           wipememory (dek, *r_pinlen);
2120         }
2121    }
2122   else
2123     *r_pinlen = strlen (pinvalue);
2124
2125  leave:
2126   xfree (relptr);
2127   return err;
2128 }
2129
2130
2131 /* Verify a CHV either using the pinentry or if possible by
2132    using a pinpad.  PINCB and PINCB_ARG describe the usual callback
2133    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
2134    used with CHV1.  PINVALUE is the address of a pointer which will
2135    receive a newly allocated block with the actual PIN (this is useful
2136    in case that PIN shall be used for another verify operation).  The
2137    caller needs to free this value.  If the function returns with
2138    success and NULL is stored at PINVALUE, the caller should take this
2139    as an indication that the pinpad has been used.
2140    */
2141 static gpg_error_t
2142 verify_a_chv (app_t app,
2143               gpg_error_t (*pincb)(void*, const char *, char **),
2144               void *pincb_arg, int chvno, unsigned long sigcount,
2145               char **pinvalue, int *pinlen)
2146 {
2147   int rc = 0;
2148   char *prompt_buffer = NULL;
2149   const char *prompt;
2150   pininfo_t pininfo;
2151   int minlen = 6;
2152   int remaining;
2153
2154   log_assert (chvno == 1 || chvno == 2);
2155
2156   *pinvalue = NULL;
2157   *pinlen = 0;
2158
2159   remaining = get_remaining_tries (app, 0);
2160   if (remaining == -1)
2161     return gpg_error (GPG_ERR_CARD);
2162
2163   if (chvno == 2 && app->app_local->flags.def_chv2)
2164     {
2165       /* Special case for def_chv2 mechanism. */
2166       if (opt.verbose)
2167         log_info (_("using default PIN as %s\n"), "CHV2");
2168       rc = iso7816_verify (app_get_slot (app), 0x82, "123456", 6);
2169       if (rc)
2170         {
2171           /* Verification of CHV2 with the default PIN failed,
2172              although the card pretends to have the default PIN set as
2173              CHV2.  We better disable the def_chv2 flag now. */
2174           log_info (_("failed to use default PIN as %s: %s"
2175                       " - disabling further default use\n"),
2176                     "CHV2", gpg_strerror (rc));
2177           app->app_local->flags.def_chv2 = 0;
2178         }
2179       return rc;
2180     }
2181
2182   memset (&pininfo, 0, sizeof pininfo);
2183   pininfo.fixedlen = -1;
2184   pininfo.minlen = minlen;
2185
2186   {
2187     const char *firstline = _("||Please unlock the card");
2188     char *infoblock = get_prompt_info (app, chvno, sigcount,
2189                                        remaining < 3? remaining : -1);
2190
2191     prompt_buffer = strconcat (firstline, "%0A%0A", infoblock, NULL);
2192     if (prompt_buffer)
2193       prompt = prompt_buffer;
2194     else
2195       prompt = firstline;  /* ENOMEM fallback.  */
2196
2197     xfree (infoblock);
2198   }
2199
2200   if (!opt.disable_pinpad
2201       && !iso7816_check_pinpad (app_get_slot (app), ISO7816_VERIFY, &pininfo)
2202       && !check_pinpad_request (app, &pininfo, 0))
2203     {
2204       /* The reader supports the verify command through the pinpad.
2205          Note that the pincb appends a text to the prompt telling the
2206          user to use the pinpad. */
2207       rc = pincb (pincb_arg, prompt, NULL);
2208       prompt = NULL;
2209       xfree (prompt_buffer);
2210       prompt_buffer = NULL;
2211       if (rc)
2212         {
2213           log_info (_("PIN callback returned error: %s\n"),
2214                     gpg_strerror (rc));
2215           return rc;
2216         }
2217       rc = iso7816_verify_kp (app_get_slot (app), 0x80+chvno, &pininfo);
2218       /* Dismiss the prompt. */
2219       pincb (pincb_arg, NULL, NULL);
2220
2221       log_assert (!*pinvalue);
2222     }
2223   else
2224     {
2225       /* The reader has no pinpad or we don't want to use it. */
2226       rc = pincb (pincb_arg, prompt, pinvalue);
2227       prompt = NULL;
2228       xfree (prompt_buffer);
2229       prompt_buffer = NULL;
2230       if (rc)
2231         {
2232           log_info (_("PIN callback returned error: %s\n"),
2233                     gpg_strerror (rc));
2234           return rc;
2235         }
2236
2237       if (strlen (*pinvalue) < minlen)
2238         {
2239           log_error (_("PIN for CHV%d is too short;"
2240                        " minimum length is %d\n"), chvno, minlen);
2241           xfree (*pinvalue);
2242           *pinvalue = NULL;
2243           return gpg_error (GPG_ERR_BAD_PIN);
2244         }
2245
2246       rc = pin2hash_if_kdf (app, chvno, *pinvalue, pinlen);
2247       if (!rc)
2248         rc = iso7816_verify (app_get_slot (app),
2249                              0x80 + chvno, *pinvalue, *pinlen);
2250     }
2251
2252   if (rc)
2253     {
2254       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
2255       xfree (*pinvalue);
2256       *pinvalue = NULL;
2257       flush_cache_after_error (app);
2258     }
2259
2260   return rc;
2261 }
2262
2263
2264 /* Verify CHV2 if required.  Depending on the configuration of the
2265    card CHV1 will also be verified. */
2266 static gpg_error_t
2267 verify_chv2 (app_t app,
2268              gpg_error_t (*pincb)(void*, const char *, char **),
2269              void *pincb_arg)
2270 {
2271   int rc;
2272   char *pinvalue;
2273   int pinlen;
2274
2275   if (app->did_chv2)
2276     return 0;  /* We already verified CHV2.  */
2277
2278   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue, &pinlen);
2279   if (rc)
2280     return rc;
2281   app->did_chv2 = 1;
2282
2283   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
2284     {
2285       /* For convenience we verify CHV1 here too.  We do this only if
2286          the card is not configured to require a verification before
2287          each CHV1 controlled operation (force_chv1) and if we are not
2288          using the pinpad (PINVALUE == NULL). */
2289       rc = iso7816_verify (app_get_slot (app), 0x81, pinvalue, pinlen);
2290       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2291         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2292       if (rc)
2293         {
2294           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2295           flush_cache_after_error (app);
2296         }
2297       else
2298         app->did_chv1 = 1;
2299     }
2300
2301   xfree (pinvalue);
2302
2303   return rc;
2304 }
2305
2306
2307 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
2308    current sdtate of the card.  */
2309 static gpg_error_t
2310 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
2311 {
2312   int remaining;
2313   char *prompt;
2314   char *infoblock;
2315
2316   *r_prompt = NULL;
2317
2318   remaining = get_remaining_tries (app, 1);
2319   if (remaining == -1)
2320     return gpg_error (GPG_ERR_CARD);
2321   if (!remaining)
2322     {
2323       log_info (_("card is permanently locked!\n"));
2324       return gpg_error (GPG_ERR_BAD_PIN);
2325     }
2326
2327   log_info (ngettext("%d Admin PIN attempt remaining before card"
2328                      " is permanently locked\n",
2329                      "%d Admin PIN attempts remaining before card"
2330                      " is permanently locked\n",
2331                      remaining), remaining);
2332
2333   infoblock = get_prompt_info (app, 3, 0, remaining < 3? remaining : -1);
2334
2335   /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
2336      the start of the string.  Use %0A (single percent) for a linefeed.  */
2337   prompt = strconcat (_("|A|Please enter the Admin PIN"),
2338                       "%0A%0A", infoblock, NULL);
2339   xfree (infoblock);
2340   if (!prompt)
2341     return gpg_error_from_syserror ();
2342
2343   *r_prompt = prompt;
2344   return 0;
2345 }
2346
2347
2348 /* Verify CHV3 if required. */
2349 static gpg_error_t
2350 verify_chv3 (app_t app,
2351              gpg_error_t (*pincb)(void*, const char *, char **),
2352              void *pincb_arg)
2353 {
2354   int rc = 0;
2355
2356   if (!opt.allow_admin)
2357     {
2358       log_info (_("access to admin commands is not configured\n"));
2359       return gpg_error (GPG_ERR_EACCES);
2360     }
2361
2362   if (!app->did_chv3)
2363     {
2364       pininfo_t pininfo;
2365       int minlen = 8;
2366       char *prompt;
2367
2368       memset (&pininfo, 0, sizeof pininfo);
2369       pininfo.fixedlen = -1;
2370       pininfo.minlen = minlen;
2371
2372       rc = build_enter_admin_pin_prompt (app, &prompt);
2373       if (rc)
2374         return rc;
2375
2376       if (!opt.disable_pinpad
2377           && !iso7816_check_pinpad (app_get_slot (app),
2378                                     ISO7816_VERIFY, &pininfo)
2379           && !check_pinpad_request (app, &pininfo, 1))
2380         {
2381           /* The reader supports the verify command through the pinpad. */
2382           rc = pincb (pincb_arg, prompt, NULL);
2383           xfree (prompt);
2384           prompt = NULL;
2385           if (rc)
2386             {
2387               log_info (_("PIN callback returned error: %s\n"),
2388                         gpg_strerror (rc));
2389               return rc;
2390             }
2391           rc = iso7816_verify_kp (app_get_slot (app), 0x83, &pininfo);
2392           /* Dismiss the prompt. */
2393           pincb (pincb_arg, NULL, NULL);
2394         }
2395       else
2396         {
2397           char *pinvalue;
2398           int pinlen;
2399
2400           rc = pincb (pincb_arg, prompt, &pinvalue);
2401           xfree (prompt);
2402           prompt = NULL;
2403           if (rc)
2404             {
2405               log_info (_("PIN callback returned error: %s\n"),
2406                         gpg_strerror (rc));
2407               return rc;
2408             }
2409
2410           if (strlen (pinvalue) < minlen)
2411             {
2412               log_error (_("PIN for CHV%d is too short;"
2413                            " minimum length is %d\n"), 3, minlen);
2414               xfree (pinvalue);
2415               return gpg_error (GPG_ERR_BAD_PIN);
2416             }
2417
2418           rc = pin2hash_if_kdf (app, 3, pinvalue, &pinlen);
2419           if (!rc)
2420             rc = iso7816_verify (app_get_slot (app), 0x83, pinvalue, pinlen);
2421           xfree (pinvalue);
2422         }
2423
2424       if (rc)
2425         {
2426           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
2427           flush_cache_after_error (app);
2428           return rc;
2429         }
2430       app->did_chv3 = 1;
2431     }
2432   return rc;
2433 }
2434
2435
2436 /* Handle the SETATTR operation. All arguments are already basically
2437    checked. */
2438 static gpg_error_t
2439 do_setattr (app_t app, const char *name,
2440             gpg_error_t (*pincb)(void*, const char *, char **),
2441             void *pincb_arg,
2442             const unsigned char *value, size_t valuelen)
2443 {
2444   gpg_error_t rc;
2445   int idx;
2446   static struct {
2447     const char *name;
2448     int tag;
2449     int flush_tag;  /* The tag which needs to be flushed or 0. */
2450     int need_chv;
2451     int special;
2452     unsigned int need_v2:1;
2453   } table[] = {
2454     { "DISP-NAME",    0x005B, 0,      3 },
2455     { "LOGIN-DATA",   0x005E, 0,      3, 2 },
2456     { "DISP-LANG",    0x5F2D, 0,      3 },
2457     { "DISP-SEX",     0x5F35, 0,      3 },
2458     { "PUBKEY-URL",   0x5F50, 0,      3 },
2459     { "CHV-STATUS-1", 0x00C4, 0,      3, 1 },
2460     { "CA-FPR-1",     0x00CA, 0x00C6, 3 },
2461     { "CA-FPR-2",     0x00CB, 0x00C6, 3 },
2462     { "CA-FPR-3",     0x00CC, 0x00C6, 3 },
2463     { "PRIVATE-DO-1", 0x0101, 0,      2 },
2464     { "PRIVATE-DO-2", 0x0102, 0,      3 },
2465     { "PRIVATE-DO-3", 0x0103, 0,      2 },
2466     { "PRIVATE-DO-4", 0x0104, 0,      3 },
2467     { "CERT-3",       0x7F21, 0,      3, 0, 1 },
2468     { "SM-KEY-ENC",   0x00D1, 0,      3, 0, 1 },
2469     { "SM-KEY-MAC",   0x00D2, 0,      3, 0, 1 },
2470     { "KEY-ATTR",     0,      0,      0, 3, 1 },
2471     { "AESKEY",       0x00D5, 0,      3, 0, 1 },
2472     { "UIF-1",        0x00D6, 0,      3, 5, 1 },
2473     { "UIF-2",        0x00D7, 0,      3, 5, 1 },
2474     { "UIF-3",        0x00D8, 0,      3, 5, 1 },
2475     { "KDF",          0x00F9, 0,      3, 4, 1 },
2476     { NULL, 0 }
2477   };
2478   int exmode;
2479
2480   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
2481     ;
2482   if (!table[idx].name)
2483     return gpg_error (GPG_ERR_INV_NAME);
2484   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
2485     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
2486
2487   if (table[idx].special == 5 && app->app_local->extcap.has_button == 0)
2488     return gpg_error (GPG_ERR_INV_OBJ);
2489
2490   if (table[idx].special == 3)
2491     return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
2492
2493   switch (table[idx].need_chv)
2494     {
2495     case 2:
2496       rc = verify_chv2 (app, pincb, pincb_arg);
2497       break;
2498     case 3:
2499       rc = verify_chv3 (app, pincb, pincb_arg);
2500       break;
2501     default:
2502       rc = 0;
2503     }
2504   if (rc)
2505     return rc;
2506
2507   /* Flush the cache before writing it, so that the next get operation
2508      will reread the data from the card and thus get synced in case of
2509      errors (e.g. data truncated by the card). */
2510   flush_cache_item (app, table[idx].flush_tag? table[idx].flush_tag
2511                     /* */                    : table[idx].tag);
2512
2513   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
2514     exmode = 1;    /* Use extended length w/o a limit.  */
2515   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
2516     exmode = -254; /* Command chaining with max. 254 bytes.  */
2517   else
2518     exmode = 0;
2519   rc = iso7816_put_data (app_get_slot (app),
2520                          exmode, table[idx].tag, value, valuelen);
2521   if (rc)
2522     log_error ("failed to set '%s': %s\n", table[idx].name, gpg_strerror (rc));
2523
2524   if (table[idx].special == 1)
2525     app->force_chv1 = (valuelen && *value == 0);
2526   else if (table[idx].special == 2)
2527     parse_login_data (app);
2528   else if (table[idx].special == 4)
2529     {
2530       app->did_chv1 = 0;
2531       app->did_chv2 = 0;
2532       app->did_chv3 = 0;
2533     }
2534
2535   return rc;
2536 }
2537
2538
2539 /* Handle the WRITECERT command for OpenPGP.  This writes the standard
2540  * certificate to the card; CERTID needs to be set to "OPENPGP.3".
2541  * PINCB and PINCB_ARG are the usual arguments for the pinentry
2542  * callback.  */
2543 static gpg_error_t
2544 do_writecert (app_t app, ctrl_t ctrl,
2545               const char *certidstr,
2546               gpg_error_t (*pincb)(void*, const char *, char **),
2547               void *pincb_arg,
2548               const unsigned char *certdata, size_t certdatalen)
2549 {
2550   (void)ctrl;
2551   if (strcmp (certidstr, "OPENPGP.3"))
2552     return gpg_error (GPG_ERR_INV_ID);
2553   if (!certdata || !certdatalen)
2554     return gpg_error (GPG_ERR_INV_ARG);
2555   if (!app->app_local->extcap.is_v2)
2556     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2557   if (certdatalen > app->app_local->extcap.max_certlen_3)
2558     return gpg_error (GPG_ERR_TOO_LARGE);
2559   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
2560 }
2561
2562
2563 static gpg_error_t
2564 clear_chv_status (app_t app, int chvno)
2565 {
2566   unsigned char apdu[4];
2567   gpg_error_t err;
2568
2569   if (!app->app_local->extcap.is_v2)
2570     return GPG_ERR_UNSUPPORTED_OPERATION;
2571
2572   apdu[0] = 0x00;
2573   apdu[1] = ISO7816_VERIFY;
2574   apdu[2] = 0xff;
2575   apdu[3] = 0x80+chvno;
2576
2577   err = iso7816_apdu_direct (app_get_slot (app), apdu, 4, 0, NULL, NULL, NULL);
2578   if (err)
2579     {
2580       if (gpg_err_code (err) == GPG_ERR_INV_VALUE)
2581         err = gpg_error (GPG_ERR_UNSUPPORTED_OPERATION);
2582       return err;
2583     }
2584
2585   if (chvno == 1)
2586     {
2587       apdu[3]++;
2588       err = iso7816_apdu_direct (app_get_slot (app),
2589                                  apdu, 4, 0, NULL, NULL, NULL);
2590       app->did_chv1 = app->did_chv2 = 0;
2591     }
2592   else if (chvno == 2)
2593     app->did_chv2 = 0;
2594   else if (chvno == 3)
2595     app->did_chv3 = 0;
2596
2597   return err;
2598 }
2599
2600
2601 /* Handle the PASSWD command.  The following combinations are
2602    possible:
2603
2604     Flags  CHVNO Vers.  Description
2605     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
2606     RESET    1   2      Verify PW3 and set a new PW1.
2607     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
2608     RESET    2   2      Verify PW3 and set a new Reset Code.
2609     RESET    3   any    Returns GPG_ERR_INV_ID.
2610      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
2611      -       1   2      Verify PW1 and set a new PW1.
2612      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
2613      -       2   2      Verify Reset Code and set a new PW1.
2614      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
2615
2616    The CHVNO can be prefixed with "OPENPGP.".
2617  */
2618 static gpg_error_t
2619 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
2620                unsigned int flags,
2621                gpg_error_t (*pincb)(void*, const char *, char **),
2622                void *pincb_arg)
2623 {
2624   int rc = 0;
2625   int chvno;
2626   char *resetcode = NULL;
2627   char *oldpinvalue = NULL;
2628   char *pinvalue = NULL;
2629   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2630   int set_resetcode = 0;
2631   pininfo_t pininfo;
2632   int use_pinpad = 0;
2633   int minlen = 6;
2634   int pinlen0 = 0;
2635   int pinlen = 0;
2636
2637   (void)ctrl;
2638
2639   if (digitp (chvnostr))
2640     chvno = atoi (chvnostr);
2641   else if (!ascii_strcasecmp (chvnostr, "OPENPGP.1"))
2642     chvno = 1;
2643   else if (!ascii_strcasecmp (chvnostr, "OPENPGP.2"))
2644     chvno = 2;
2645   else if (!ascii_strcasecmp (chvnostr, "OPENPGP.3"))
2646     chvno = 3;
2647   else
2648     return gpg_error (GPG_ERR_INV_ID);
2649
2650   memset (&pininfo, 0, sizeof pininfo);
2651   pininfo.fixedlen = -1;
2652   pininfo.minlen = minlen;
2653
2654   if ((flags & APP_CHANGE_FLAG_CLEAR))
2655     return clear_chv_status (app, chvno);
2656
2657   if (reset_mode && chvno == 3)
2658     {
2659       rc = gpg_error (GPG_ERR_INV_ID);
2660       goto leave;
2661     }
2662
2663   if (!app->app_local->extcap.is_v2)
2664     {
2665       /* Version 1 cards.  */
2666
2667       if (reset_mode || chvno == 3)
2668         {
2669           /* We always require that the PIN is entered. */
2670           app->did_chv3 = 0;
2671           rc = verify_chv3 (app, pincb, pincb_arg);
2672           if (rc)
2673             goto leave;
2674         }
2675       else if (chvno == 1 || chvno == 2)
2676         {
2677           /* On a v1.x card CHV1 and CVH2 should always have the same
2678              value, thus we enforce it here.  */
2679           int save_force = app->force_chv1;
2680
2681           app->force_chv1 = 0;
2682           app->did_chv1 = 0;
2683           app->did_chv2 = 0;
2684           rc = verify_chv2 (app, pincb, pincb_arg);
2685           app->force_chv1 = save_force;
2686           if (rc)
2687             goto leave;
2688         }
2689       else
2690         {
2691           rc = gpg_error (GPG_ERR_INV_ID);
2692           goto leave;
2693         }
2694     }
2695   else
2696     {
2697       /* Version 2 cards.  */
2698
2699       if (!opt.disable_pinpad
2700           && !iso7816_check_pinpad (app_get_slot (app),
2701                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2702           && !check_pinpad_request (app, &pininfo, chvno == 3))
2703         use_pinpad = 1;
2704
2705       if (reset_mode)
2706         {
2707           /* To reset a PIN the Admin PIN is required. */
2708           use_pinpad = 0;
2709           app->did_chv3 = 0;
2710           rc = verify_chv3 (app, pincb, pincb_arg);
2711           if (rc)
2712             goto leave;
2713
2714           if (chvno == 2)
2715             set_resetcode = 1;
2716         }
2717       else if (chvno == 1 || chvno == 3)
2718         {
2719           if (!use_pinpad)
2720             {
2721               char *promptbuf = NULL;
2722               const char *prompt;
2723
2724               if (chvno == 3)
2725                 {
2726                   minlen = 8;
2727                   rc = build_enter_admin_pin_prompt (app, &promptbuf);
2728                   if (rc)
2729                     goto leave;
2730                   prompt = promptbuf;
2731                 }
2732               else
2733                 prompt = _("||Please enter the PIN");
2734               rc = pincb (pincb_arg, prompt, &oldpinvalue);
2735               xfree (promptbuf);
2736               promptbuf = NULL;
2737               if (rc)
2738                 {
2739                   log_info (_("PIN callback returned error: %s\n"),
2740                             gpg_strerror (rc));
2741                   goto leave;
2742                 }
2743
2744               if (strlen (oldpinvalue) < minlen)
2745                 {
2746                   log_info (_("PIN for CHV%d is too short;"
2747                               " minimum length is %d\n"), chvno, minlen);
2748                   rc = gpg_error (GPG_ERR_BAD_PIN);
2749                   goto leave;
2750                 }
2751             }
2752         }
2753       else if (chvno == 2)
2754         {
2755           /* There is no PW2 for v2 cards.  We use this condition to
2756              allow a PW reset using the Reset Code.  */
2757           void *relptr;
2758           unsigned char *value;
2759           size_t valuelen;
2760           int remaining;
2761
2762           use_pinpad = 0;
2763           minlen = 8;
2764           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2765           if (!relptr || valuelen < 7)
2766             {
2767               log_error (_("error retrieving CHV status from card\n"));
2768               xfree (relptr);
2769               rc = gpg_error (GPG_ERR_CARD);
2770               goto leave;
2771             }
2772           remaining = value[5];
2773           xfree (relptr);
2774           if (!remaining)
2775             {
2776               log_error (_("Reset Code not or not anymore available\n"));
2777               rc = gpg_error (GPG_ERR_BAD_PIN);
2778               goto leave;
2779             }
2780
2781           rc = pincb (pincb_arg,
2782                       _("||Please enter the Reset Code for the card"),
2783                       &resetcode);
2784           if (rc)
2785             {
2786               log_info (_("PIN callback returned error: %s\n"),
2787                         gpg_strerror (rc));
2788               goto leave;
2789             }
2790           if (strlen (resetcode) < minlen)
2791             {
2792               log_info (_("Reset Code is too short; minimum length is %d\n"),
2793                         minlen);
2794               rc = gpg_error (GPG_ERR_BAD_PIN);
2795               goto leave;
2796             }
2797         }
2798       else
2799         {
2800           rc = gpg_error (GPG_ERR_INV_ID);
2801           goto leave;
2802         }
2803     }
2804
2805   if (chvno == 3)
2806     app->did_chv3 = 0;
2807   else
2808     app->did_chv1 = app->did_chv2 = 0;
2809
2810   if (!use_pinpad)
2811     {
2812       /* TRANSLATORS: Do not translate the "|*|" prefixes but
2813          keep it at the start of the string.  We need this elsewhere
2814          to get some infos on the string. */
2815       rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2816                   chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2817                   &pinvalue);
2818       if (rc || pinvalue == NULL)
2819         {
2820           log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2821           goto leave;
2822         }
2823     }
2824
2825
2826   if (resetcode)
2827     {
2828       char *buffer;
2829
2830       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2831       if (!buffer)
2832         rc = gpg_error_from_syserror ();
2833       else
2834         {
2835           strcpy (buffer, resetcode);
2836           rc = pin2hash_if_kdf (app, 0, buffer, &pinlen0);
2837           if (!rc)
2838             {
2839               strcpy (buffer+pinlen0, pinvalue);
2840               rc = pin2hash_if_kdf (app, 0, buffer+pinlen0, &pinlen);
2841             }
2842           if (!rc)
2843             rc = iso7816_reset_retry_counter_with_rc (app_get_slot (app), 0x81,
2844                                                       buffer, pinlen0+pinlen);
2845           wipememory (buffer, pinlen0 + pinlen);
2846           xfree (buffer);
2847         }
2848     }
2849   else if (set_resetcode)
2850     {
2851       if (strlen (pinvalue) < 8)
2852         {
2853           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2854           rc = gpg_error (GPG_ERR_BAD_PIN);
2855         }
2856       else
2857         {
2858           rc = pin2hash_if_kdf (app, 0, pinvalue, &pinlen);
2859           if (!rc)
2860             rc = iso7816_put_data (app_get_slot (app),
2861                                    0, 0xD3, pinvalue, pinlen);
2862         }
2863     }
2864   else if (reset_mode)
2865     {
2866       rc = pin2hash_if_kdf (app, 1, pinvalue, &pinlen);
2867       if (!rc)
2868         rc = iso7816_reset_retry_counter (app_get_slot (app),
2869                                           0x81, pinvalue, pinlen);
2870       if (!rc && !app->app_local->extcap.is_v2)
2871         rc = iso7816_reset_retry_counter (app_get_slot (app),
2872                                           0x82, pinvalue, pinlen);
2873     }
2874   else if (!app->app_local->extcap.is_v2)
2875     {
2876       /* Version 1 cards.  */
2877       if (chvno == 1 || chvno == 2)
2878         {
2879           rc = iso7816_change_reference_data (app_get_slot (app),
2880                                               0x81, NULL, 0,
2881                                               pinvalue, strlen (pinvalue));
2882           if (!rc)
2883             rc = iso7816_change_reference_data (app_get_slot (app),
2884                                                 0x82, NULL, 0,
2885                                                 pinvalue, strlen (pinvalue));
2886         }
2887       else /* CHVNO == 3 */
2888         {
2889           rc = iso7816_change_reference_data (app_get_slot (app),
2890                                               0x80 + chvno, NULL, 0,
2891                                               pinvalue, strlen (pinvalue));
2892         }
2893     }
2894   else
2895     {
2896       /* Version 2 cards.  */
2897       assert (chvno == 1 || chvno == 3);
2898
2899       if (use_pinpad)
2900         {
2901           rc = pincb (pincb_arg,
2902                       chvno == 3 ?
2903                       _("||Please enter the Admin PIN and New Admin PIN") :
2904                       _("||Please enter the PIN and New PIN"), NULL);
2905           if (rc)
2906             {
2907               log_info (_("PIN callback returned error: %s\n"),
2908                         gpg_strerror (rc));
2909               goto leave;
2910             }
2911           rc = iso7816_change_reference_data_kp (app_get_slot (app),
2912                                                  0x80 + chvno, 0,
2913                                                  &pininfo);
2914           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2915         }
2916       else
2917         {
2918           rc = pin2hash_if_kdf (app, chvno, oldpinvalue, &pinlen0);
2919           if (!rc)
2920             rc = pin2hash_if_kdf (app, chvno, pinvalue, &pinlen);
2921           if (!rc)
2922             rc = iso7816_change_reference_data (app_get_slot (app),
2923                                                 0x80 + chvno,
2924                                                 oldpinvalue, pinlen0,
2925                                                 pinvalue, pinlen);
2926         }
2927     }
2928
2929   if (pinvalue)
2930     {
2931       wipememory (pinvalue, pinlen);
2932       xfree (pinvalue);
2933     }
2934   if (rc)
2935     flush_cache_after_error (app);
2936
2937  leave:
2938   if (resetcode)
2939     {
2940       wipememory (resetcode, strlen (resetcode));
2941       xfree (resetcode);
2942     }
2943   if (oldpinvalue)
2944     {
2945       wipememory (oldpinvalue, pinlen0);
2946       xfree (oldpinvalue);
2947     }
2948   return rc;
2949 }
2950
2951
2952 /* Check whether a key already exists.  KEYIDX is the index of the key
2953    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2954    error returned if the key already exists.  The flag GENERATING is
2955    only used to print correct messages. */
2956 static gpg_error_t
2957 does_key_exist (app_t app, int keyidx, int generating, int force)
2958 {
2959   const unsigned char *fpr;
2960   unsigned char *buffer;
2961   size_t buflen, n;
2962   int i;
2963
2964   assert (keyidx >=0 && keyidx <= 2);
2965
2966   if (iso7816_get_data (app_get_slot (app), 0, 0x006E, &buffer, &buflen))
2967     {
2968       log_error (_("error reading application data\n"));
2969       return gpg_error (GPG_ERR_GENERAL);
2970     }
2971   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2972   if (!fpr || n < 60)
2973     {
2974       log_error (_("error reading fingerprint DO\n"));
2975       xfree (buffer);
2976       return gpg_error (GPG_ERR_GENERAL);
2977     }
2978   fpr += 20*keyidx;
2979   for (i=0; i < 20 && !fpr[i]; i++)
2980     ;
2981   xfree (buffer);
2982   if (i!=20 && !force)
2983     {
2984       log_error (_("key already exists\n"));
2985       return gpg_error (GPG_ERR_EEXIST);
2986     }
2987   else if (i!=20)
2988     log_info (_("existing key will be replaced\n"));
2989   else if (generating)
2990     log_info (_("generating new key\n"));
2991   else
2992     log_info (_("writing new key\n"));
2993   return 0;
2994 }
2995
2996
2997 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2998    of tag and length.  A LENGTH greater than 65535 is truncated. */
2999 static size_t
3000 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
3001 {
3002   unsigned char *p = buffer;
3003
3004   assert (tag <= 0xffff);
3005   if ( tag > 0xff )
3006     *p++ = tag >> 8;
3007   *p++ = tag;
3008   if (length < 128)
3009     *p++ = length;
3010   else if (length < 256)
3011     {
3012       *p++ = 0x81;
3013       *p++ = length;
3014     }
3015   else
3016     {
3017       if (length > 0xffff)
3018         length = 0xffff;
3019       *p++ = 0x82;
3020       *p++ = length >> 8;
3021       *p++ = length;
3022     }
3023
3024   return p - buffer;
3025 }
3026
3027
3028 static gpg_error_t
3029 build_privkey_template (app_t app, int keyno,
3030                         const unsigned char *rsa_n, size_t rsa_n_len,
3031                         const unsigned char *rsa_e, size_t rsa_e_len,
3032                         const unsigned char *rsa_p, size_t rsa_p_len,
3033                         const unsigned char *rsa_q, size_t rsa_q_len,
3034                         const unsigned char *rsa_u, size_t rsa_u_len,
3035                         const unsigned char *rsa_dp, size_t rsa_dp_len,
3036                         const unsigned char *rsa_dq, size_t rsa_dq_len,
3037                         unsigned char **result, size_t *resultlen)
3038 {
3039   size_t rsa_e_reqlen;
3040   unsigned char privkey[7*(1+3+3)];
3041   size_t privkey_len;
3042   unsigned char exthdr[2+2+3];
3043   size_t exthdr_len;
3044   unsigned char suffix[2+3];
3045   size_t suffix_len;
3046   unsigned char *tp;
3047   size_t datalen;
3048   unsigned char *template;
3049   size_t template_size;
3050
3051   *result = NULL;
3052   *resultlen = 0;
3053
3054   switch (app->app_local->keyattr[keyno].rsa.format)
3055     {
3056     case RSA_STD:
3057     case RSA_STD_N:
3058     case RSA_CRT:
3059     case RSA_CRT_N:
3060       break;
3061
3062     default:
3063       return gpg_error (GPG_ERR_INV_VALUE);
3064     }
3065
3066   /* Get the required length for E. Rounded up to the nearest byte  */
3067   rsa_e_reqlen = (app->app_local->keyattr[keyno].rsa.e_bits + 7) / 8;
3068   assert (rsa_e_len <= rsa_e_reqlen);
3069
3070   /* Build the 7f48 cardholder private key template.  */
3071   datalen = 0;
3072   tp = privkey;
3073
3074   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
3075   datalen += rsa_e_reqlen;
3076
3077   tp += add_tlv (tp, 0x92, rsa_p_len);
3078   datalen += rsa_p_len;
3079
3080   tp += add_tlv (tp, 0x93, rsa_q_len);
3081   datalen += rsa_q_len;
3082
3083   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
3084       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3085     {
3086       tp += add_tlv (tp, 0x94, rsa_u_len);
3087       datalen += rsa_u_len;
3088       tp += add_tlv (tp, 0x95, rsa_dp_len);
3089       datalen += rsa_dp_len;
3090       tp += add_tlv (tp, 0x96, rsa_dq_len);
3091       datalen += rsa_dq_len;
3092     }
3093
3094   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
3095       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3096     {
3097       tp += add_tlv (tp, 0x97, rsa_n_len);
3098       datalen += rsa_n_len;
3099     }
3100   privkey_len = tp - privkey;
3101
3102   /* Build the extended header list without the private key template.  */
3103   tp = exthdr;
3104   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
3105   *tp++ = 0;
3106   tp += add_tlv (tp, 0x7f48, privkey_len);
3107   exthdr_len = tp - exthdr;
3108
3109   /* Build the 5f48 suffix of the data.  */
3110   tp = suffix;
3111   tp += add_tlv (tp, 0x5f48, datalen);
3112   suffix_len = tp - suffix;
3113
3114   /* Now concatenate everything.  */
3115   template_size = (1 + 3   /* 0x4d and len. */
3116                    + exthdr_len
3117                    + privkey_len
3118                    + suffix_len
3119                    + datalen);
3120   tp = template = xtrymalloc_secure (template_size);
3121   if (!template)
3122     return gpg_error_from_syserror ();
3123
3124   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
3125   memcpy (tp, exthdr, exthdr_len);
3126   tp += exthdr_len;
3127   memcpy (tp, privkey, privkey_len);
3128   tp += privkey_len;
3129   memcpy (tp, suffix, suffix_len);
3130   tp += suffix_len;
3131
3132   memcpy (tp, rsa_e, rsa_e_len);
3133   if (rsa_e_len < rsa_e_reqlen)
3134     {
3135       /* Right justify E. */
3136       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
3137       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
3138     }
3139   tp += rsa_e_reqlen;
3140
3141   memcpy (tp, rsa_p, rsa_p_len);
3142   tp += rsa_p_len;
3143
3144   memcpy (tp, rsa_q, rsa_q_len);
3145   tp += rsa_q_len;
3146
3147   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
3148       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3149     {
3150       memcpy (tp, rsa_u, rsa_u_len);
3151       tp += rsa_u_len;
3152       memcpy (tp, rsa_dp, rsa_dp_len);
3153       tp += rsa_dp_len;
3154       memcpy (tp, rsa_dq, rsa_dq_len);
3155       tp += rsa_dq_len;
3156     }
3157
3158   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
3159       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
3160     {
3161       memcpy (tp, rsa_n, rsa_n_len);
3162       tp += rsa_n_len;
3163     }
3164
3165   /* Sanity check.  We don't know the exact length because we
3166      allocated 3 bytes for the first length header.  */
3167   assert (tp - template <= template_size);
3168
3169   *result = template;
3170   *resultlen = tp - template;
3171   return 0;
3172 }
3173
3174 static gpg_error_t
3175 build_ecc_privkey_template (app_t app, int keyno,
3176                             const unsigned char *ecc_d, size_t ecc_d_len,
3177                             const unsigned char *ecc_q, size_t ecc_q_len,
3178                             unsigned char **result, size_t *resultlen)
3179 {
3180   unsigned char privkey[2+2];
3181   size_t privkey_len;
3182   unsigned char exthdr[2+2+1];
3183   size_t exthdr_len;
3184   unsigned char suffix[2+1];
3185   size_t suffix_len;
3186   unsigned char *tp;
3187   size_t datalen;
3188   unsigned char *template;
3189   size_t template_size;
3190   int pubkey_required;
3191
3192   pubkey_required = !!(app->app_local->keyattr[keyno].ecc.flags
3193                        & ECC_FLAG_PUBKEY);
3194
3195   *result = NULL;
3196   *resultlen = 0;
3197
3198   /* Build the 7f48 cardholder private key template.  */
3199   datalen = 0;
3200   tp = privkey;
3201
3202   tp += add_tlv (tp, 0x92, ecc_d_len);
3203   datalen += ecc_d_len;
3204
3205   if (pubkey_required)
3206     {
3207       tp += add_tlv (tp, 0x99, ecc_q_len);
3208       datalen += ecc_q_len;
3209     }
3210
3211   privkey_len = tp - privkey;
3212
3213
3214   /* Build the extended header list without the private key template.  */
3215   tp = exthdr;
3216   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
3217   *tp++ = 0;
3218   tp += add_tlv (tp, 0x7f48, privkey_len);
3219   exthdr_len = tp - exthdr;
3220
3221   /* Build the 5f48 suffix of the data.  */
3222   tp = suffix;
3223   tp += add_tlv (tp, 0x5f48, datalen);
3224   suffix_len = tp - suffix;
3225
3226   /* Now concatenate everything.  */
3227   template_size = (1 + 1   /* 0x4d and len. */
3228                    + exthdr_len
3229                    + privkey_len
3230                    + suffix_len
3231                    + datalen);
3232   if (exthdr_len + privkey_len + suffix_len + datalen >= 128)
3233     template_size++;
3234   tp = template = xtrymalloc_secure (template_size);
3235   if (!template)
3236     return gpg_error_from_syserror ();
3237
3238   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
3239   memcpy (tp, exthdr, exthdr_len);
3240   tp += exthdr_len;
3241   memcpy (tp, privkey, privkey_len);
3242   tp += privkey_len;
3243   memcpy (tp, suffix, suffix_len);
3244   tp += suffix_len;
3245
3246   memcpy (tp, ecc_d, ecc_d_len);
3247   tp += ecc_d_len;
3248
3249   if (pubkey_required)
3250     {
3251       memcpy (tp, ecc_q, ecc_q_len);
3252       tp += ecc_q_len;
3253     }
3254
3255   assert (tp - template == template_size);
3256
3257   *result = template;
3258   *resultlen = tp - template;
3259   return 0;
3260 }
3261
3262
3263 /* Helper for do_writekley to change the size of a key.  Not ethat
3264    this deletes the entire key without asking.  */
3265 static gpg_error_t
3266 change_keyattr (app_t app, int keyno, const unsigned char *buf, size_t buflen,
3267                 gpg_error_t (*pincb)(void*, const char *, char **),
3268                 void *pincb_arg)
3269 {
3270   gpg_error_t err;
3271
3272   assert (keyno >=0 && keyno <= 2);
3273
3274   /* Prepare for storing the key.  */
3275   err = verify_chv3 (app, pincb, pincb_arg);
3276   if (err)
3277     return err;
3278
3279   /* Change the attribute.  */
3280   err = iso7816_put_data (app_get_slot (app), 0, 0xC1+keyno, buf, buflen);
3281   if (err)
3282     log_error ("error changing key attribute (key=%d)\n", keyno+1);
3283   else
3284     log_info ("key attribute changed (key=%d)\n", keyno+1);
3285   flush_cache (app);
3286   parse_algorithm_attribute (app, keyno);
3287   app->did_chv1 = 0;
3288   app->did_chv2 = 0;
3289   app->did_chv3 = 0;
3290   return err;
3291 }
3292
3293
3294 static gpg_error_t
3295 change_rsa_keyattr (app_t app, int keyno, unsigned int nbits,
3296                     gpg_error_t (*pincb)(void*, const char *, char **),
3297                     void *pincb_arg)
3298 {
3299   gpg_error_t err = 0;
3300   unsigned char *buf;
3301   size_t buflen;
3302   void *relptr;
3303
3304   /* Read the current attributes into a buffer.  */
3305   relptr = get_one_do (app, 0xC1+keyno, &buf, &buflen, NULL);
3306   if (!relptr)
3307     err = gpg_error (GPG_ERR_CARD);
3308   else if (buflen < 6)
3309     {
3310       /* Attributes too short.  */
3311       xfree (relptr);
3312       err = gpg_error (GPG_ERR_CARD);
3313     }
3314   else
3315     {
3316       /* If key attribute was RSA, we only change n_bits and don't
3317          touch anything else.  Before we do so, we round up NBITS to a
3318          sensible way in the same way as gpg's key generation does it.
3319          This may help to sort out problems with a few bits too short
3320          keys.  */
3321       nbits = ((nbits + 31) / 32) * 32;
3322       buf[1] = (nbits >> 8);
3323       buf[2] = nbits;
3324
3325       /* If it was not RSA, we need to fill other parts.  */
3326       if (buf[0] != PUBKEY_ALGO_RSA)
3327         {
3328           buf[0] = PUBKEY_ALGO_RSA;
3329           buf[3] = 0;
3330           buf[4] = 32;
3331           buf[5] = 0;
3332           buflen = 6;
3333         }
3334
3335       err = change_keyattr (app, keyno, buf, buflen, pincb, pincb_arg);
3336       xfree (relptr);
3337     }
3338
3339   return err;
3340 }
3341
3342
3343 /* Helper to process an setattr command for name KEY-ATTR.
3344    In (VALUE,VALUELEN), it expects following string:
3345         RSA: "--force <key> <algo> rsa<nbits>"
3346         ECC: "--force <key> <algo> <curvename>"
3347   */
3348 static gpg_error_t
3349 change_keyattr_from_string (app_t app,
3350                             gpg_error_t (*pincb)(void*, const char *, char **),
3351                             void *pincb_arg,
3352                             const void *value, size_t valuelen)
3353 {
3354   gpg_error_t err = 0;
3355   char *string;
3356   int key, keyno, algo;
3357   int n = 0;
3358
3359   /* VALUE is expected to be a string but not guaranteed to be
3360      terminated.  Thus copy it to an allocated buffer first. */
3361   string = xtrymalloc (valuelen+1);
3362   if (!string)
3363     return gpg_error_from_syserror ();
3364   memcpy (string, value, valuelen);
3365   string[valuelen] = 0;
3366
3367   /* Because this function deletes the key we require the string
3368      "--force" in the data to make clear that something serious might
3369      happen.  */
3370   sscanf (string, "--force %d %d %n", &key, &algo, &n);
3371   if (n < 12)
3372     {
3373       err = gpg_error (GPG_ERR_INV_DATA);
3374       goto leave;
3375     }
3376
3377   keyno = key - 1;
3378   if (keyno < 0 || keyno > 2)
3379     err = gpg_error (GPG_ERR_INV_ID);
3380   else if (algo == PUBKEY_ALGO_RSA)
3381     {
3382       unsigned int nbits;
3383
3384       errno = 0;
3385       nbits = strtoul (string+n+3, NULL, 10);
3386       if (errno)
3387         err = gpg_error (GPG_ERR_INV_DATA);
3388       else if (nbits < 1024)
3389         err = gpg_error (GPG_ERR_TOO_SHORT);
3390       else if (nbits > 4096)
3391         err = gpg_error (GPG_ERR_TOO_LARGE);
3392       else
3393         err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3394     }
3395   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
3396            || algo == PUBKEY_ALGO_EDDSA)
3397     {
3398       const char *oidstr;
3399       gcry_mpi_t oid;
3400       const unsigned char *oidbuf;
3401       size_t oid_len;
3402
3403       oidstr = openpgp_curve_to_oid (string+n, NULL);
3404       if (!oidstr)
3405         {
3406           err = gpg_error (GPG_ERR_INV_DATA);
3407           goto leave;
3408         }
3409
3410       err = openpgp_oid_from_str (oidstr, &oid);
3411       if (err)
3412         goto leave;
3413
3414       oidbuf = gcry_mpi_get_opaque (oid, &n);
3415       oid_len = (n+7)/8;
3416
3417       /* We have enough room at STRING.  */
3418       string[0] = algo;
3419       memcpy (string+1, oidbuf+1, oid_len-1);
3420       err = change_keyattr (app, keyno, string, oid_len, pincb, pincb_arg);
3421       gcry_mpi_release (oid);
3422     }
3423   else
3424     err = gpg_error (GPG_ERR_PUBKEY_ALGO);
3425
3426  leave:
3427   xfree (string);
3428   return err;
3429 }
3430
3431
3432 static gpg_error_t
3433 rsa_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3434               void *pincb_arg, int keyno,
3435               const unsigned char *buf, size_t buflen, int depth)
3436 {
3437   gpg_error_t err;
3438   const unsigned char *tok;
3439   size_t toklen;
3440   int last_depth1, last_depth2;
3441   const unsigned char *rsa_n = NULL;
3442   const unsigned char *rsa_e = NULL;
3443   const unsigned char *rsa_p = NULL;
3444   const unsigned char *rsa_q = NULL;
3445   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3446   unsigned int nbits;
3447   unsigned int maxbits;
3448   unsigned char *template = NULL;
3449   unsigned char *tp;
3450   size_t template_len;
3451   unsigned char fprbuf[20];
3452   u32 created_at = 0;
3453
3454   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
3455     {
3456       log_error (_("unsupported algorithm: %s"), "RSA");
3457       err = gpg_error (GPG_ERR_INV_VALUE);
3458       goto leave;
3459     }
3460
3461   last_depth1 = depth;
3462   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3463          && depth && depth >= last_depth1)
3464     {
3465       if (tok)
3466         {
3467           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3468           goto leave;
3469         }
3470       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3471         goto leave;
3472       if (tok && toklen == 1)
3473         {
3474           const unsigned char **mpi;
3475           size_t *mpi_len;
3476
3477           switch (*tok)
3478             {
3479             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
3480             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
3481             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
3482             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
3483             default: mpi = NULL;  mpi_len = NULL; break;
3484             }
3485           if (mpi && *mpi)
3486             {
3487               err = gpg_error (GPG_ERR_DUP_VALUE);
3488               goto leave;
3489             }
3490           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3491             goto leave;
3492           if (tok && mpi)
3493             {
3494               /* Strip off leading zero bytes and save. */
3495               for (;toklen && !*tok; toklen--, tok++)
3496                 ;
3497               *mpi = tok;
3498               *mpi_len = toklen;
3499             }
3500         }
3501       /* Skip until end of list. */
3502       last_depth2 = depth;
3503       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3504              && depth && depth >= last_depth2)
3505         ;
3506       if (err)
3507         goto leave;
3508     }
3509   /* Parse other attributes. */
3510   last_depth1 = depth;
3511   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3512          && depth && depth >= last_depth1)
3513     {
3514       if (tok)
3515         {
3516           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3517           goto leave;
3518         }
3519       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3520         goto leave;
3521       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3522         {
3523           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3524             goto leave;
3525           if (tok)
3526             {
3527               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3528                    tok++, toklen--)
3529                 created_at = created_at*10 + (*tok - '0');
3530             }
3531         }
3532       /* Skip until end of list. */
3533       last_depth2 = depth;
3534       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3535              && depth && depth >= last_depth2)
3536         ;
3537       if (err)
3538         goto leave;
3539     }
3540
3541
3542   /* Check that we have all parameters and that they match the card
3543      description. */
3544   if (!created_at)
3545     {
3546       log_error (_("creation timestamp missing\n"));
3547       err = gpg_error (GPG_ERR_INV_VALUE);
3548       goto leave;
3549     }
3550
3551   maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3552   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
3553   if (opt.verbose)
3554     log_info ("RSA modulus size is %u bits\n", nbits);
3555   if (nbits && nbits != maxbits
3556       && app->app_local->extcap.algo_attr_change)
3557     {
3558       /* Try to switch the key to a new length.  */
3559       err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3560       if (!err)
3561         maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3562     }
3563   if (nbits != maxbits)
3564     {
3565       log_error (_("RSA modulus missing or not of size %d bits\n"),
3566                  (int)maxbits);
3567       err = gpg_error (GPG_ERR_BAD_SECKEY);
3568       goto leave;
3569     }
3570
3571   maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
3572   if (maxbits > 32 && !app->app_local->extcap.is_v2)
3573     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
3574   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
3575   if (nbits < 2 || nbits > maxbits)
3576     {
3577       log_error (_("RSA public exponent missing or larger than %d bits\n"),
3578                  (int)maxbits);
3579       err = gpg_error (GPG_ERR_BAD_SECKEY);
3580       goto leave;
3581     }
3582
3583   maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
3584   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
3585   if (nbits != maxbits)
3586     {
3587       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3588                  "P", (int)maxbits);
3589       err = gpg_error (GPG_ERR_BAD_SECKEY);
3590       goto leave;
3591     }
3592   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
3593   if (nbits != maxbits)
3594     {
3595       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3596                  "Q", (int)maxbits);
3597       err = gpg_error (GPG_ERR_BAD_SECKEY);
3598       goto leave;
3599     }
3600
3601   /* We need to remove the cached public key.  */
3602   xfree (app->app_local->pk[keyno].key);
3603   app->app_local->pk[keyno].key = NULL;
3604   app->app_local->pk[keyno].keylen = 0;
3605   app->app_local->pk[keyno].read_done = 0;
3606
3607
3608   if (app->app_local->extcap.is_v2)
3609     {
3610       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
3611       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
3612       gcry_mpi_t mpi_e, mpi_p, mpi_q;
3613       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
3614       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
3615       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
3616       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
3617       int exmode;
3618
3619       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
3620       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
3621       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
3622       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
3623
3624       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
3625       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
3626       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
3627       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
3628       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
3629
3630       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
3631       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
3632       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
3633
3634       gcry_mpi_release (mpi_e);
3635       gcry_mpi_release (mpi_p);
3636       gcry_mpi_release (mpi_q);
3637       gcry_mpi_release (mpi_u);
3638       gcry_mpi_release (mpi_dp);
3639       gcry_mpi_release (mpi_dq);
3640       gcry_mpi_release (mpi_tmp);
3641
3642       /* Build the private key template as described in section 4.3.3.7 of
3643          the OpenPGP card specs version 2.0.  */
3644       err = build_privkey_template (app, keyno,
3645                                     rsa_n, rsa_n_len,
3646                                     rsa_e, rsa_e_len,
3647                                     rsa_p, rsa_p_len,
3648                                     rsa_q, rsa_q_len,
3649                                     rsa_u, rsa_u_len,
3650                                     rsa_dp, rsa_dp_len,
3651                                     rsa_dq, rsa_dq_len,
3652                                     &template, &template_len);
3653       xfree(rsa_u);
3654       xfree(rsa_dp);
3655       xfree(rsa_dq);
3656
3657       if (err)
3658         goto leave;
3659
3660       /* Prepare for storing the key.  */
3661       err = verify_chv3 (app, pincb, pincb_arg);
3662       if (err)
3663         goto leave;
3664
3665       /* Store the key. */
3666       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3667         exmode = 1;    /* Use extended length w/o a limit.  */
3668       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3669         exmode = -254;
3670       else
3671         exmode = 0;
3672       err = iso7816_put_data_odd (app_get_slot (app), exmode, 0x3fff,
3673                                   template, template_len);
3674     }
3675   else
3676     {
3677       /* Build the private key template as described in section 4.3.3.6 of
3678          the OpenPGP card specs version 1.1:
3679          0xC0   <length> public exponent
3680          0xC1   <length> prime p
3681          0xC2   <length> prime q
3682       */
3683       assert (rsa_e_len <= 4);
3684       template_len = (1 + 1 + 4
3685                       + 1 + 1 + rsa_p_len
3686                       + 1 + 1 + rsa_q_len);
3687       template = tp = xtrymalloc_secure (template_len);
3688       if (!template)
3689         {
3690           err = gpg_error_from_syserror ();
3691           goto leave;
3692         }
3693       *tp++ = 0xC0;
3694       *tp++ = 4;
3695       memcpy (tp, rsa_e, rsa_e_len);
3696       if (rsa_e_len < 4)
3697         {
3698           /* Right justify E. */
3699           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
3700           memset (tp, 0, 4-rsa_e_len);
3701         }
3702       tp += 4;
3703
3704       *tp++ = 0xC1;
3705       *tp++ = rsa_p_len;
3706       memcpy (tp, rsa_p, rsa_p_len);
3707       tp += rsa_p_len;
3708
3709       *tp++ = 0xC2;
3710       *tp++ = rsa_q_len;
3711       memcpy (tp, rsa_q, rsa_q_len);
3712       tp += rsa_q_len;
3713
3714       assert (tp - template == template_len);
3715
3716       /* Prepare for storing the key.  */
3717       err = verify_chv3 (app, pincb, pincb_arg);
3718       if (err)
3719         goto leave;
3720
3721       /* Store the key. */
3722       err = iso7816_put_data (app_get_slot (app), 0,
3723                               (app->appversion > 0x0007? 0xE0:0xE9)+keyno,
3724                               template, template_len);
3725     }
3726   if (err)
3727     {
3728       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3729       goto leave;
3730     }
3731
3732   err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
3733                    rsa_n, rsa_n_len, rsa_e, rsa_e_len);
3734   if (err)
3735     goto leave;
3736
3737
3738  leave:
3739   xfree (template);
3740   return err;
3741 }
3742
3743
3744 static gpg_error_t
3745 ecc_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3746               void *pincb_arg, int keyno,
3747               const unsigned char *buf, size_t buflen, int depth)
3748 {
3749   gpg_error_t err;
3750   const unsigned char *tok;
3751   size_t toklen;
3752   int last_depth1, last_depth2;
3753   const unsigned char *ecc_q = NULL;
3754   const unsigned char *ecc_d = NULL;
3755   size_t ecc_q_len, ecc_d_len;
3756   const char *curve = NULL;
3757   u32 created_at = 0;
3758   const char *oidstr;
3759   int flag_djb_tweak = 0;
3760   int algo;
3761   gcry_mpi_t oid = NULL;
3762   const unsigned char *oidbuf;
3763   unsigned int n;
3764   size_t oid_len;
3765   unsigned char fprbuf[20];
3766
3767   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3768      curve = "NIST P-256" */
3769   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3770      curve = "secp256k1" */
3771   /* (private-key(ecc(curve%s)(flags eddsa)(q%m)(d%m))(created-at%d)):
3772       curve = "Ed25519" */
3773   last_depth1 = depth;
3774   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3775          && depth && depth >= last_depth1)
3776     {
3777       if (tok)
3778         {
3779           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3780           goto leave;
3781         }
3782       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3783         goto leave;
3784
3785       if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
3786         {
3787           char *curve_name;
3788
3789           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3790             goto leave;
3791
3792           curve_name = xtrymalloc (toklen+1);
3793           if (!curve_name)
3794             {
3795               err = gpg_error_from_syserror ();
3796               goto leave;
3797             }
3798
3799           memcpy (curve_name, tok, toklen);
3800           curve_name[toklen] = 0;
3801           curve = openpgp_is_curve_supported (curve_name, NULL, NULL);
3802           xfree (curve_name);
3803         }
3804       else if (tok && toklen == 5 && !memcmp (tok, "flags", 5))
3805         {
3806           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3807             goto leave;
3808
3809           if (tok)
3810             {
3811               if ((toklen == 5 && !memcmp (tok, "eddsa", 5))
3812                   || (toklen == 9 && !memcmp (tok, "djb-tweak", 9)))
3813                 flag_djb_tweak = 1;
3814             }
3815         }
3816       else if (tok && toklen == 1)
3817         {
3818           const unsigned char **buf2;
3819           size_t *buf2len;
3820           int native = flag_djb_tweak;
3821
3822           switch (*tok)
3823             {
3824             case 'q': buf2 = &ecc_q; buf2len = &ecc_q_len; break;
3825             case 'd': buf2 = &ecc_d; buf2len = &ecc_d_len; native = 0; break;
3826             default: buf2 = NULL;  buf2len = NULL; break;
3827             }
3828           if (buf2 && *buf2)
3829             {
3830               err = gpg_error (GPG_ERR_DUP_VALUE);
3831               goto leave;
3832             }
3833           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3834             goto leave;
3835           if (tok && buf2)
3836             {
3837               if (!native)
3838                 /* Strip off leading zero bytes and save. */
3839                 for (;toklen && !*tok; toklen--, tok++)
3840                   ;
3841
3842               *buf2 = tok;
3843               *buf2len = toklen;
3844             }
3845         }
3846       /* Skip until end of list. */
3847       last_depth2 = depth;
3848       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3849              && depth && depth >= last_depth2)
3850         ;
3851       if (err)
3852         goto leave;
3853     }
3854   /* Parse other attributes. */
3855   last_depth1 = depth;
3856   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3857          && depth && depth >= last_depth1)
3858     {
3859       if (tok)
3860         {
3861           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3862           goto leave;
3863         }
3864       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3865         goto leave;
3866       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3867         {
3868           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3869             goto leave;
3870           if (tok)
3871             {
3872               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3873                    tok++, toklen--)
3874                 created_at = created_at*10 + (*tok - '0');
3875             }
3876         }
3877       /* Skip until end of list. */
3878       last_depth2 = depth;
3879       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3880              && depth && depth >= last_depth2)
3881         ;
3882       if (err)
3883         goto leave;
3884     }
3885
3886
3887   /* Check that we have all parameters and that they match the card
3888      description. */
3889   if (!curve)
3890     {
3891       log_error (_("unsupported curve\n"));
3892       err = gpg_error (GPG_ERR_INV_VALUE);
3893       goto leave;
3894     }
3895   if (!created_at)
3896     {
3897       log_error (_("creation timestamp missing\n"));
3898       err = gpg_error (GPG_ERR_INV_VALUE);
3899       goto leave;
3900     }
3901   if (flag_djb_tweak && keyno != 1)
3902     algo = PUBKEY_ALGO_EDDSA;
3903   else if (keyno == 1)
3904     algo = PUBKEY_ALGO_ECDH;
3905   else
3906     algo = PUBKEY_ALGO_ECDSA;
3907
3908   oidstr = openpgp_curve_to_oid (curve, NULL);
3909   err = openpgp_oid_from_str (oidstr, &oid);
3910   if (err)
3911     goto leave;
3912   oidbuf = gcry_mpi_get_opaque (oid, &n);
3913   if (!oidbuf)
3914     {
3915       err = gpg_error_from_syserror ();
3916       goto leave;
3917     }
3918   oid_len = (n+7)/8;
3919
3920   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_ECC
3921       || app->app_local->keyattr[keyno].ecc.curve != curve
3922       || (flag_djb_tweak !=
3923           (app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK)))
3924     {
3925       if (app->app_local->extcap.algo_attr_change)
3926         {
3927           unsigned char *keyattr;
3928
3929           if (!oid_len)
3930             {
3931               err = gpg_error (GPG_ERR_INTERNAL);
3932               goto leave;
3933             }
3934           keyattr = xtrymalloc (oid_len);
3935           if (!keyattr)
3936             {
3937               err = gpg_error_from_syserror ();
3938               goto leave;
3939             }
3940           keyattr[0] = algo;
3941           memcpy (keyattr+1, oidbuf+1, oid_len-1);
3942           err = change_keyattr (app, keyno, keyattr, oid_len, pincb, pincb_arg);
3943           xfree (keyattr);
3944           if (err)
3945             goto leave;
3946         }
3947       else
3948         {
3949           log_error ("key attribute on card doesn't match\n");
3950           err = gpg_error (GPG_ERR_INV_VALUE);
3951           goto leave;
3952         }
3953     }
3954
3955   if (opt.verbose)
3956     log_info ("ECC private key size is %u bytes\n", (unsigned int)ecc_d_len);
3957
3958   /* We need to remove the cached public key.  */
3959   xfree (app->app_local->pk[keyno].key);
3960   app->app_local->pk[keyno].key = NULL;
3961   app->app_local->pk[keyno].keylen = 0;
3962   app->app_local->pk[keyno].read_done = 0;
3963
3964   if (app->app_local->extcap.is_v2)
3965     {
3966       /* Build the private key template as described in section 4.3.3.7 of
3967          the OpenPGP card specs version 2.0.  */
3968       unsigned char *template;
3969       size_t template_len;
3970       int exmode;
3971
3972       err = build_ecc_privkey_template (app, keyno,
3973                                         ecc_d, ecc_d_len,
3974                                         ecc_q, ecc_q_len,
3975                                         &template, &template_len);
3976       if (err)
3977         goto leave;
3978
3979       /* Prepare for storing the key.  */
3980       err = verify_chv3 (app, pincb, pincb_arg);
3981       if (err)
3982         {
3983           xfree (template);
3984           goto leave;
3985         }
3986
3987       /* Store the key. */
3988       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3989         exmode = 1;    /* Use extended length w/o a limit.  */
3990       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3991         exmode = -254;
3992       else
3993         exmode = 0;
3994       err = iso7816_put_data_odd (app_get_slot (app), exmode, 0x3fff,
3995                                   template, template_len);
3996       xfree (template);
3997     }
3998   else
3999     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
4000
4001   if (err)
4002     {
4003       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
4004       goto leave;
4005     }
4006
4007   err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
4008                    ecc_q, ecc_q_len, ecdh_params (curve), (size_t)4);
4009
4010  leave:
4011   gcry_mpi_release (oid);
4012   return err;
4013 }
4014
4015 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
4016    canonical encoded S-expression with the secret key in KEYDATA and
4017    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
4018    usual keyid which for OpenPGP is the string "OPENPGP.n" with
4019    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
4020    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
4021    the pinentry callback.  */
4022 static gpg_error_t
4023 do_writekey (app_t app, ctrl_t ctrl,
4024              const char *keyid, unsigned int flags,
4025              gpg_error_t (*pincb)(void*, const char *, char **),
4026              void *pincb_arg,
4027              const unsigned char *keydata, size_t keydatalen)
4028 {
4029   gpg_error_t err;
4030   int force = (flags & 1);
4031   int keyno;
4032   const unsigned char *buf, *tok;
4033   size_t buflen, toklen;
4034   int depth;
4035
4036   (void)ctrl;
4037
4038   if (!strcmp (keyid, "OPENPGP.1"))
4039     keyno = 0;
4040   else if (!strcmp (keyid, "OPENPGP.2"))
4041     keyno = 1;
4042   else if (!strcmp (keyid, "OPENPGP.3"))
4043     keyno = 2;
4044   else
4045     return gpg_error (GPG_ERR_INV_ID);
4046
4047   err = does_key_exist (app, keyno, 0, force);
4048   if (err)
4049     return err;
4050
4051
4052   /*
4053      Parse the S-expression
4054    */
4055   buf = keydata;
4056   buflen = keydatalen;
4057   depth = 0;
4058   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4059     goto leave;
4060   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4061     goto leave;
4062   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
4063     {
4064       if (!tok)
4065         ;
4066       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
4067         log_info ("protected-private-key passed to writekey\n");
4068       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
4069         log_info ("shadowed-private-key passed to writekey\n");
4070       err = gpg_error (GPG_ERR_BAD_SECKEY);
4071       goto leave;
4072     }
4073   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4074     goto leave;
4075   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
4076     goto leave;
4077   if (tok && toklen == 3 && memcmp ("rsa", tok, toklen) == 0)
4078     err = rsa_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
4079   else if (tok && toklen == 3 && memcmp ("ecc", tok, toklen) == 0)
4080     err = ecc_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
4081   else
4082     {
4083       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
4084       goto leave;
4085     }
4086
4087  leave:
4088   return err;
4089 }
4090
4091
4092
4093 /* Handle the GENKEY command. */
4094 static gpg_error_t
4095 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, const char *keytype,
4096            unsigned int flags, time_t createtime,
4097            gpg_error_t (*pincb)(void*, const char *, char **),
4098            void *pincb_arg)
4099 {
4100   gpg_error_t err;
4101   char numbuf[30];
4102   unsigned char *buffer = NULL;
4103   const unsigned char *keydata;
4104   size_t buflen, keydatalen;
4105   u32 created_at;
4106   int keyno = atoi (keynostr) - 1;
4107   int force = (flags & 1);
4108   time_t start_at;
4109   int exmode = 0;
4110   int le_value = 256; /* Use legacy value. */
4111
4112   (void)keytype;  /* Ignored for OpenPGP cards.  */
4113
4114   if (keyno < 0 || keyno > 2)
4115     return gpg_error (GPG_ERR_INV_ID);
4116
4117   /* We flush the cache to increase the traffic before a key
4118      generation.  This _might_ help a card to gather more entropy. */
4119   flush_cache (app);
4120
4121   /* Obviously we need to remove the cached public key.  */
4122   xfree (app->app_local->pk[keyno].key);
4123   app->app_local->pk[keyno].key = NULL;
4124   app->app_local->pk[keyno].keylen = 0;
4125   app->app_local->pk[keyno].read_done = 0;
4126
4127   /* Check whether a key already exists.  */
4128   err = does_key_exist (app, keyno, 1, force);
4129   if (err)
4130     return err;
4131
4132   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
4133     {
4134       unsigned int keybits = app->app_local->keyattr[keyno].rsa.n_bits;
4135
4136       /* Because we send the key parameter back via status lines we need
4137          to put a limit on the max. allowed keysize.  2048 bit will
4138          already lead to a 527 byte long status line and thus a 4096 bit
4139          key would exceed the Assuan line length limit.  */
4140       if (keybits > 4096)
4141         return gpg_error (GPG_ERR_TOO_LARGE);
4142
4143       if (app->app_local->cardcap.ext_lc_le && keybits > RSA_SMALL_SIZE_KEY
4144           && app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
4145         {
4146           exmode = 1;    /* Use extended length w/o a limit.  */
4147           le_value = determine_rsa_response (app, keyno);
4148           /* No need to check le_value because it comes from a 16 bit
4149              value and thus can't create an overflow on a 32 bit
4150              system.  */
4151         }
4152     }
4153
4154   /* Prepare for key generation by verifying the Admin PIN.  */
4155   err = verify_chv3 (app, pincb, pincb_arg);
4156   if (err)
4157     return err;
4158
4159
4160   log_info (_("please wait while key is being generated ...\n"));
4161   start_at = time (NULL);
4162   err = iso7816_generate_keypair (app_get_slot (app), exmode, 0x80, 0,
4163                                   (keyno == 0? "\xB6" :
4164                                    keyno == 1? "\xB8" : "\xA4"),
4165                                   2, le_value, &buffer, &buflen);
4166   if (err)
4167     {
4168       log_error (_("generating key failed\n"));
4169       return gpg_error (GPG_ERR_CARD);
4170     }
4171
4172   {
4173     int nsecs = (int)(time (NULL) - start_at);
4174     log_info (ngettext("key generation completed (%d second)\n",
4175                        "key generation completed (%d seconds)\n",
4176                        nsecs), nsecs);
4177   }
4178
4179   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
4180   if (!keydata)
4181     {
4182       err = gpg_error (GPG_ERR_CARD);
4183       log_error (_("response does not contain the public key data\n"));
4184       goto leave;
4185     }
4186
4187   created_at = (u32)(createtime? createtime : gnupg_get_time ());
4188   sprintf (numbuf, "%u", created_at);
4189   send_status_info (ctrl, "KEY-CREATED-AT",
4190                     numbuf, (size_t)strlen(numbuf), NULL, 0);
4191
4192   err = read_public_key (app, ctrl, created_at, keyno, buffer, buflen);
4193  leave:
4194   xfree (buffer);
4195   return err;
4196 }
4197
4198
4199 static unsigned long
4200 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
4201 {
4202   unsigned long ul;
4203
4204   if (valuelen == 3 )
4205     ul = (value[0] << 16) | (value[1] << 8) | value[2];
4206   else
4207     {
4208       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
4209       ul = 0;
4210     }
4211   return ul;
4212 }
4213
4214 static unsigned long
4215 get_sig_counter (app_t app)
4216 {
4217   void *relptr;
4218   unsigned char *value;
4219   size_t valuelen;
4220   unsigned long ul;
4221
4222   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
4223   if (!relptr)
4224     return 0;
4225   ul = convert_sig_counter_value (value, valuelen);
4226   xfree (relptr);
4227   return ul;
4228 }
4229
4230 static gpg_error_t
4231 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
4232 {
4233   const unsigned char *fpr;
4234   unsigned char *buffer;
4235   size_t buflen, n;
4236   int rc, i;
4237
4238   assert (keyno >= 0 && keyno <= 2);
4239
4240   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
4241   if (rc)
4242     {
4243       log_error (_("error reading application data\n"));
4244       return gpg_error (GPG_ERR_GENERAL);
4245     }
4246   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
4247   if (!fpr || n != 60)
4248     {
4249       xfree (buffer);
4250       log_error (_("error reading fingerprint DO\n"));
4251       return gpg_error (GPG_ERR_GENERAL);
4252     }
4253   fpr += keyno*20;
4254   for (i=0; i < 20; i++)
4255     if (sha1fpr[i] != fpr[i])
4256       {
4257         xfree (buffer);
4258         log_info (_("fingerprint on card does not match requested one\n"));
4259         return gpg_error (GPG_ERR_WRONG_SECKEY);
4260       }
4261   xfree (buffer);
4262   return 0;
4263 }
4264
4265
4266 /* If a fingerprint has been specified check it against the one on the
4267    card.  This allows for a meaningful error message in case the key
4268    on the card has been replaced but the shadow information known to
4269    gpg has not been updated.  If there is no fingerprint we assume
4270    that this is okay. */
4271 static gpg_error_t
4272 check_against_given_fingerprint (app_t app, const char *fpr, int key)
4273 {
4274   unsigned char tmp[20];
4275   const char *s;
4276   int n;
4277
4278   for (s=fpr, n=0; hexdigitp (s); s++, n++)
4279     ;
4280   if (n != 40)
4281     return gpg_error (GPG_ERR_INV_ID);
4282   else if (!*s)
4283     ; /* okay */
4284   else
4285     return gpg_error (GPG_ERR_INV_ID);
4286
4287   for (s=fpr, n=0; n < 20; s += 2, n++)
4288         tmp[n] = xtoi_2 (s);
4289   return compare_fingerprint (app, key-1, tmp);
4290 }
4291
4292
4293 /* Check KEYIDSTR, if it's valid.
4294    When KEYNO is 0, it means it's for PIN check.
4295    Otherwise, KEYNO corresponds to the slot (signing, decipher and auth).
4296    KEYIDSTR is either:
4297     (1) Serial number
4298     (2) Serial number "/" fingerprint
4299     (3) Serial number "[CHV3]"
4300     (4) keygrip
4301
4302    When KEYNO is 0 and KEYIDSTR is for a keygrip, the keygrip should
4303    be to be compared is the first one (keygrip for signing).
4304  */
4305 static int
4306 check_keyidstr (app_t app, const char *keyidstr, int keyno)
4307 {
4308   int rc;
4309   const char *s;
4310   int n;
4311   const char *fpr = NULL;
4312   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
4313
4314   if (strlen (keyidstr) < 32)
4315     return gpg_error (GPG_ERR_INV_ID);
4316   else
4317     {
4318       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
4319         ;
4320
4321       /* Check if it's a keygrip */
4322       if (n == 40)
4323         {
4324           const unsigned char *keygrip_str;
4325
4326           keygrip_str = app->app_local->pk[keyno?keyno-1:0].keygrip_str;
4327           if (!strncmp (keygrip_str, keyidstr, 40))
4328             return 0;
4329           else
4330             return gpg_error (GPG_ERR_INV_ID);
4331         }
4332
4333       if (n != 32 || strncmp (keyidstr, "D27600012401", 12))
4334         return gpg_error (GPG_ERR_INV_ID);
4335       else if (!*s)
4336         ; /* no fingerprint given: we allow this for now. */
4337       else if (*s == '/')
4338         fpr = s + 1;
4339
4340       for (s=keyidstr, n=0; n < 16; s += 2, n++)
4341         tmp_sn[n] = xtoi_2 (s);
4342
4343       if (app->card->serialnolen != 16)
4344         return gpg_error (GPG_ERR_INV_CARD);
4345       if (memcmp (app->card->serialno, tmp_sn, 16))
4346         return gpg_error (GPG_ERR_WRONG_CARD);
4347     }
4348
4349   /* If a fingerprint has been specified check it against the one on
4350      the card.  This is allows for a meaningful error message in case
4351      the key on the card has been replaced but the shadow information
4352      known to gpg was not updated.  If there is no fingerprint, gpg
4353      will detect a bogus signature anyway due to the
4354      verify-after-signing feature. */
4355   rc = (fpr&&keyno)? check_against_given_fingerprint (app, fpr, keyno) : 0;
4356
4357   return rc;
4358 }
4359
4360
4361 /* Compute a digital signature on INDATA which is expected to be the
4362    raw message digest. For this application the KEYIDSTR consists of
4363    the serialnumber and the fingerprint delimited by a slash.
4364
4365    Note that this function may return the error code
4366    GPG_ERR_WRONG_CARD to indicate that the card currently present does
4367    not match the one required for the requested action (e.g. the
4368    serial number does not match).
4369
4370    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
4371    operation to the auth command.
4372 */
4373 static gpg_error_t
4374 do_sign (app_t app, const char *keyidstr, int hashalgo,
4375          gpg_error_t (*pincb)(void*, const char *, char **),
4376          void *pincb_arg,
4377          const void *indata, size_t indatalen,
4378          unsigned char **outdata, size_t *outdatalen )
4379 {
4380   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
4381     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
4382       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
4383   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
4384     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
4385       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
4386   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
4387     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
4388       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
4389       0x1C  };
4390   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
4391     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
4392       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
4393       0x00, 0x04, 0x20  };
4394   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
4395     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
4396       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
4397       0x00, 0x04, 0x30  };
4398   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
4399     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
4400       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
4401       0x00, 0x04, 0x40  };
4402   int rc;
4403   unsigned char data[19+64];
4404   size_t datalen;
4405   unsigned long sigcount;
4406   int use_auth = 0;
4407   int exmode, le_value;
4408
4409   if (!keyidstr || !*keyidstr)
4410     return gpg_error (GPG_ERR_INV_VALUE);
4411
4412   /* Strip off known prefixes.  */
4413 #define X(a,b,c,d) \
4414   if (hashalgo == GCRY_MD_ ## a                               \
4415       && (d)                                                  \
4416       && indatalen == sizeof b ## _prefix + (c)               \
4417       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
4418     {                                                         \
4419       indata = (const char*)indata + sizeof b ## _prefix;     \
4420       indatalen -= sizeof b ## _prefix;                       \
4421     }
4422
4423   if (indatalen == 20)
4424     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
4425   else X(SHA1,   sha1,   20, 1)
4426   else X(RMD160, rmd160, 20, 1)
4427   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
4428   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
4429   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
4430   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
4431   else if ((indatalen == 28 || indatalen == 32
4432             || indatalen == 48 || indatalen ==64)
4433            && app->app_local->extcap.is_v2)
4434     ;  /* Assume a plain SHA-3 digest has been given.  */
4435   else
4436     {
4437       log_error (_("card does not support digest algorithm %s\n"),
4438                  gcry_md_algo_name (hashalgo));
4439       /* Or the supplied digest length does not match an algorithm.  */
4440       return gpg_error (GPG_ERR_INV_VALUE);
4441     }
4442 #undef X
4443
4444   /* Check whether an OpenPGP card of any version has been requested. */
4445   if (!strcmp (keyidstr, "OPENPGP.1"))
4446     ;
4447   else if (!strcmp (keyidstr, "OPENPGP.3"))
4448     use_auth = 1;
4449   else
4450     {
4451       rc = check_keyidstr (app, keyidstr, 1);
4452       if (rc)
4453         return rc;
4454     }
4455
4456   /* Concatenate prefix and digest.  */
4457 #define X(a,b,d) \
4458   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
4459     {                                                         \
4460       datalen = sizeof b ## _prefix + indatalen;              \
4461       assert (datalen <= sizeof data);                        \
4462       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
4463       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
4464     }
4465
4466   if (use_auth
4467       || app->app_local->keyattr[use_auth? 2: 0].key_type == KEY_TYPE_RSA)
4468     {
4469       X(SHA1,   sha1,   1)
4470       else X(RMD160, rmd160, 1)
4471       else X(SHA224, sha224, app->app_local->extcap.is_v2)
4472       else X(SHA256, sha256, app->app_local->extcap.is_v2)
4473       else X(SHA384, sha384, app->app_local->extcap.is_v2)
4474       else X(SHA512, sha512, app->app_local->extcap.is_v2)
4475       else
4476         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
4477     }
4478   else
4479     {
4480       datalen = indatalen;
4481       memcpy (data, indata, indatalen);
4482     }
4483 #undef X
4484
4485   /* Redirect to the AUTH command if asked to. */
4486   if (use_auth)
4487     {
4488       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
4489                       data, datalen,
4490                       outdata, outdatalen);
4491     }
4492
4493   /* Show the number of signature done using this key.  */
4494   sigcount = get_sig_counter (app);
4495   log_info (_("signatures created so far: %lu\n"), sigcount);
4496
4497   /* Check CHV if needed.  */
4498   if (!app->did_chv1 || app->force_chv1)
4499     {
4500       char *pinvalue;
4501       int pinlen;
4502
4503       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount,
4504                          &pinvalue, &pinlen);
4505       if (rc)
4506         return rc;
4507
4508       app->did_chv1 = 1;
4509
4510       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
4511          sync, thus we verify CHV2 here using the given PIN.  Cards
4512          with version2 to not have the need for a separate CHV2 and
4513          internally use just one.  Obviously we can't do that if the
4514          pinpad has been used. */
4515       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
4516         {
4517           rc = iso7816_verify (app_get_slot (app), 0x82, pinvalue, pinlen);
4518           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
4519             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
4520           if (rc)
4521             {
4522               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
4523               xfree (pinvalue);
4524               flush_cache_after_error (app);
4525               return rc;
4526             }
4527           app->did_chv2 = 1;
4528         }
4529       xfree (pinvalue);
4530     }
4531
4532
4533   if (app->app_local->cardcap.ext_lc_le
4534       && app->app_local->keyattr[0].key_type == KEY_TYPE_RSA
4535       && app->app_local->keyattr[0].rsa.n_bits > RSA_SMALL_SIZE_OP)
4536     {
4537       exmode = 1;    /* Use extended length.  */
4538       le_value = app->app_local->keyattr[0].rsa.n_bits / 8;
4539     }
4540   else
4541     {
4542       exmode = 0;
4543       le_value = 0;
4544     }
4545   rc = iso7816_compute_ds (app_get_slot (app), exmode, data, datalen, le_value,
4546                            outdata, outdatalen);
4547   if (gpg_err_code (rc) == GPG_ERR_TIMEOUT)
4548     clear_chv_status (app, 1);
4549   else if (!rc && app->force_chv1)
4550     app->did_chv1 = 0;
4551
4552   return rc;
4553 }
4554
4555 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
4556    on INDATA which is expected to be the raw message digest. For this
4557    application the KEYIDSTR consists of the serialnumber and the
4558    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
4559    be given.
4560
4561    Note that this function may return the error code
4562    GPG_ERR_WRONG_CARD to indicate that the card currently present does
4563    not match the one required for the requested action (e.g. the
4564    serial number does not match). */
4565 static gpg_error_t
4566 do_auth (app_t app, const char *keyidstr,
4567          gpg_error_t (*pincb)(void*, const char *, char **),
4568          void *pincb_arg,
4569          const void *indata, size_t indatalen,
4570          unsigned char **outdata, size_t *outdatalen )
4571 {
4572   int rc;
4573
4574   if (!keyidstr || !*keyidstr)
4575     return gpg_error (GPG_ERR_INV_VALUE);
4576   if (app->app_local->keyattr[2].key_type == KEY_TYPE_RSA
4577       && indatalen > 101) /* For a 2048 bit key. */
4578     return gpg_error (GPG_ERR_INV_VALUE);
4579
4580   if (app->app_local->keyattr[2].key_type == KEY_TYPE_ECC)
4581     {
4582       if (!(app->app_local->keyattr[2].ecc.flags & ECC_FLAG_DJB_TWEAK)
4583           && (indatalen == 51 || indatalen == 67 || indatalen == 83))
4584         {
4585           const char *p = (const char *)indata + 19;
4586           indata = p;
4587           indatalen -= 19;
4588         }
4589       else
4590         {
4591           const char *p = (const char *)indata + 15;
4592           indata = p;
4593           indatalen -= 15;
4594         }
4595     }
4596
4597   /* Check whether an OpenPGP card of any version has been requested. */
4598   if (!strcmp (keyidstr, "OPENPGP.3"))
4599     ;
4600   else
4601     {
4602       rc = check_keyidstr (app, keyidstr, 3);
4603       if (rc)
4604         return rc;
4605     }
4606
4607   rc = verify_chv2 (app, pincb, pincb_arg);
4608   if (!rc)
4609     {
4610       int exmode, le_value;
4611
4612       if (app->app_local->cardcap.ext_lc_le
4613           && app->app_local->keyattr[2].key_type == KEY_TYPE_RSA
4614           && app->app_local->keyattr[2].rsa.n_bits > RSA_SMALL_SIZE_OP)
4615         {
4616           exmode = 1;    /* Use extended length.  */
4617           le_value = app->app_local->keyattr[2].rsa.n_bits / 8;
4618         }
4619       else
4620         {
4621           exmode = 0;
4622           le_value = 0;
4623         }
4624       rc = iso7816_internal_authenticate (app_get_slot (app), exmode,
4625                                           indata, indatalen, le_value,
4626                                           outdata, outdatalen);
4627       if (gpg_err_code (rc) == GPG_ERR_TIMEOUT)
4628         clear_chv_status (app, 1);
4629     }
4630   return rc;
4631 }
4632
4633
4634 static gpg_error_t
4635 do_decipher (app_t app, const char *keyidstr,
4636              gpg_error_t (*pincb)(void*, const char *, char **),
4637              void *pincb_arg,
4638              const void *indata, size_t indatalen,
4639              unsigned char **outdata, size_t *outdatalen,
4640              unsigned int *r_info)
4641 {
4642   int n;
4643   int rc;
4644   int exmode, le_value;
4645   unsigned char *fixbuf = NULL;
4646   int padind = 0;
4647   int fixuplen = 0;
4648
4649   if (!keyidstr || !*keyidstr || !indatalen)
4650     return gpg_error (GPG_ERR_INV_VALUE);
4651
4652   /* Check whether an OpenPGP card of any version has been requested. */
4653   if (!strcmp (keyidstr, "OPENPGP.2"))
4654     ;
4655   else
4656     {
4657       rc = check_keyidstr (app, keyidstr, 2);
4658       if (rc)
4659         return rc;
4660     }
4661
4662   rc = verify_chv2 (app, pincb, pincb_arg);
4663   if (rc)
4664     return rc;
4665
4666   if ((indatalen == 16 + 1 || indatalen == 32 + 1)
4667       && ((char *)indata)[0] == 0x02)
4668     {
4669       /* PSO:DECIPHER with symmetric key.  */
4670       padind = -1;
4671     }
4672   else if (app->app_local->keyattr[1].key_type == KEY_TYPE_RSA)
4673     {
4674       /* We might encounter a couple of leading zeroes in the
4675          cryptogram.  Due to internal use of MPIs these leading zeroes
4676          are stripped.  However the OpenPGP card expects exactly 128
4677          bytes for the cryptogram (for a 1k key).  Thus we need to fix
4678          it up.  We do this for up to 16 leading zero bytes; a
4679          cryptogram with more than this is with a very high
4680          probability anyway broken.  If a signed conversion was used
4681          we may also encounter one leading zero followed by the correct
4682          length.  We fix that as well.  */
4683       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
4684         fixuplen = 128 - indatalen;
4685       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
4686         fixuplen = 192 - indatalen;
4687       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
4688         fixuplen = 256 - indatalen;
4689       else if (indatalen >= (384-16) && indatalen < 384) /* 3072 bit key.  */
4690         fixuplen = 384 - indatalen;
4691       else if (indatalen >= (512-16) && indatalen < 512) /* 4096 bit key.  */
4692         fixuplen = 512 - indatalen;
4693       else if (!*(const char *)indata && (indatalen == 129
4694                                           || indatalen == 193
4695                                           || indatalen == 257
4696                                           || indatalen == 385
4697                                           || indatalen == 513))
4698         fixuplen = -1;
4699       else
4700         fixuplen = 0;
4701
4702       if (fixuplen > 0)
4703         {
4704           /* While we have to prepend stuff anyway, we can also
4705              include the padding byte here so that iso1816_decipher
4706              does not need to do another data mangling.  */
4707           fixuplen++;
4708
4709           fixbuf = xtrymalloc (fixuplen + indatalen);
4710           if (!fixbuf)
4711             return gpg_error_from_syserror ();
4712
4713           memset (fixbuf, 0, fixuplen);
4714           memcpy (fixbuf+fixuplen, indata, indatalen);
4715           indata = fixbuf;
4716           indatalen = fixuplen + indatalen;
4717           padind = -1; /* Already padded.  */
4718         }
4719       else if (fixuplen < 0)
4720         {
4721           /* We use the extra leading zero as the padding byte.  */
4722           padind = -1;
4723         }
4724     }
4725   else if (app->app_local->keyattr[1].key_type == KEY_TYPE_ECC)
4726     {
4727       int old_format_len = 0;
4728
4729       if ((app->app_local->keyattr[1].ecc.flags & ECC_FLAG_DJB_TWEAK))
4730         {
4731           if (indatalen > 32 && (indatalen % 2))
4732             { /*
4733                * Skip the prefix.  It may be 0x40 (in new format), or MPI
4734                * head of 0x00 (in old format).
4735                */
4736               indata = (const char *)indata + 1;
4737               indatalen--;
4738             }
4739           else if (indatalen < 32)
4740             { /*
4741                * Old format trancated by MPI handling.
4742                */
4743               old_format_len = indatalen;
4744               indatalen = 32;
4745             }
4746         }
4747
4748       n = 0;
4749       if (indatalen < 128)
4750         fixuplen = 7;
4751       else
4752         fixuplen = 10;
4753
4754       fixbuf = xtrymalloc (fixuplen + indatalen);
4755       if (!fixbuf)
4756         return gpg_error_from_syserror ();
4757
4758       /* Build 'Cipher DO' */
4759       fixbuf[n++] = '\xa6';
4760       if (indatalen < 128)
4761         fixbuf[n++] = (char)(indatalen+5);
4762       else
4763         {
4764           fixbuf[n++] = 0x81;
4765           fixbuf[n++] = (char)(indatalen+7);
4766         }
4767       fixbuf[n++] = '\x7f';
4768       fixbuf[n++] = '\x49';
4769       if (indatalen < 128)
4770         fixbuf[n++] = (char)(indatalen+2);
4771       else
4772         {
4773           fixbuf[n++] = 0x81;
4774           fixbuf[n++] = (char)(indatalen+3);
4775         }
4776       fixbuf[n++] = '\x86';
4777       if (indatalen < 128)
4778         fixbuf[n++] = (char)indatalen;
4779       else
4780         {
4781           fixbuf[n++] = 0x81;
4782           fixbuf[n++] = (char)indatalen;
4783         }
4784
4785       if (old_format_len)
4786         {
4787           memset (fixbuf+fixuplen, 0, 32 - old_format_len);
4788           memcpy (fixbuf+fixuplen + 32 - old_format_len,
4789                   indata, old_format_len);
4790         }
4791       else
4792         {
4793           memcpy (fixbuf+fixuplen, indata, indatalen);
4794         }
4795       indata = fixbuf;
4796       indatalen = fixuplen + indatalen;
4797
4798       padind = -1;
4799     }
4800   else
4801     return gpg_error (GPG_ERR_INV_VALUE);
4802
4803   if (app->app_local->cardcap.ext_lc_le
4804       && (indatalen > 254
4805           || (app->app_local->keyattr[1].key_type == KEY_TYPE_RSA
4806               && app->app_local->keyattr[1].rsa.n_bits > RSA_SMALL_SIZE_OP)))
4807     {
4808       exmode = 1;    /* Extended length w/o a limit.  */
4809       le_value = app->app_local->keyattr[1].rsa.n_bits / 8;
4810     }
4811   else if (app->app_local->cardcap.cmd_chaining && indatalen > 254)
4812     {
4813       exmode = -254; /* Command chaining with max. 254 bytes.  */
4814       le_value = 0;
4815     }
4816   else
4817     exmode = le_value = 0;
4818
4819   rc = iso7816_decipher (app_get_slot (app), exmode,
4820                          indata, indatalen, le_value, padind,
4821                          outdata, outdatalen);
4822   xfree (fixbuf);
4823   if (!rc && app->app_local->keyattr[1].key_type == KEY_TYPE_ECC)
4824     {
4825       unsigned char prefix = 0;
4826
4827       if (app->app_local->keyattr[1].ecc.flags & ECC_FLAG_DJB_TWEAK)
4828         prefix = 0x40;
4829       else if ((*outdatalen % 2) == 0) /* No 0x04 -> x-coordinate only */
4830         prefix = 0x41;
4831
4832       if (prefix)
4833         { /* Add the prefix */
4834           fixbuf = xtrymalloc (*outdatalen + 1);
4835           if (!fixbuf)
4836             {
4837               xfree (*outdata);
4838               return gpg_error_from_syserror ();
4839             }
4840           fixbuf[0] = prefix;
4841           memcpy (fixbuf+1, *outdata, *outdatalen);
4842           xfree (*outdata);
4843           *outdata = fixbuf;
4844           *outdatalen = *outdatalen + 1;
4845         }
4846     }
4847   if (gpg_err_code (rc) == GPG_ERR_TIMEOUT)
4848     clear_chv_status (app, 1);
4849
4850   if (gpg_err_code (rc) == GPG_ERR_CARD /* actual SW is 0x640a */
4851       && app->app_local->manufacturer == 5
4852       && app->appversion == 0x0200)
4853     log_info ("NOTE: Cards with manufacturer id 5 and s/n <= 346 (0x15a)"
4854               " do not work with encryption keys > 2048 bits\n");
4855
4856   *r_info |= APP_DECIPHER_INFO_NOPAD;
4857
4858   return rc;
4859 }
4860
4861
4862 /* Perform a simple verify operation for CHV1 and CHV2, so that
4863    further operations won't ask for CHV2 and it is possible to do a
4864    cheap check on the PIN: If there is something wrong with the PIN
4865    entry system, only the regular CHV will get blocked and not the
4866    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
4867    optional fingerprint part will be ignored.
4868
<