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