scd: Add --advanced option for READKEY.
[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 *curve;
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                 app->app_local->keyattr[keyno].ecc.curve);
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
1311 /* Determine KDF hash algorithm and KEK encryption algorithm by CURVE.  */
1312 static const unsigned char*
1313 ecdh_params (const char *curve)
1314 {
1315   unsigned int nbits;
1316
1317   openpgp_curve_to_oid (curve, &nbits);
1318
1319   /* See RFC-6637 for those constants.
1320          0x03: Number of bytes
1321          0x01: Version for this parameter format
1322          KDF algo
1323         KEK algo
1324   */
1325   if (nbits <= 256)
1326     return (const unsigned char*)"\x03\x01\x08\x07";
1327   else if (nbits <= 384)
1328     return (const unsigned char*)"\x03\x01\x09\x08";
1329   else
1330     return (const unsigned char*)"\x03\x01\x0a\x09";
1331 }
1332
1333 static gpg_error_t
1334 ecc_read_pubkey (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
1335                  const unsigned char *data, size_t datalen, gcry_sexp_t *r_sexp)
1336 {
1337   gpg_error_t err;
1338   unsigned char *qbuf = NULL;
1339   const unsigned char *ecc_q;
1340   size_t ecc_q_len;
1341   gcry_mpi_t oid = NULL;
1342   int n;
1343   const char *curve;
1344   const char *oidstr;
1345   const unsigned char *oidbuf;
1346   size_t oid_len;
1347   int algo;
1348   const char *format;
1349
1350   ecc_q = find_tlv (data, datalen, 0x0086, &ecc_q_len);
1351   if (!ecc_q)
1352     {
1353       log_error (_("response does not contain the EC public key\n"));
1354       return gpg_error (GPG_ERR_CARD);
1355     }
1356
1357   curve = app->app_local->keyattr[keyno].ecc.curve;
1358   oidstr = openpgp_curve_to_oid (curve, NULL);
1359   err = openpgp_oid_from_str (oidstr, &oid);
1360   if (err)
1361     return err;
1362   oidbuf = gcry_mpi_get_opaque (oid, &n);
1363   if (!oidbuf)
1364     {
1365       err = gpg_error_from_syserror ();
1366       goto leave;
1367     }
1368   oid_len = (n+7)/8;
1369
1370   qbuf = xtrymalloc (ecc_q_len + 1);
1371   if (!qbuf)
1372     {
1373       err = gpg_error_from_syserror ();
1374       goto leave;
1375     }
1376
1377   if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1378     {               /* Prepend 0x40 prefix.  */
1379       *qbuf = 0x40;
1380       memcpy (qbuf+1, ecc_q, ecc_q_len);
1381       ecc_q_len++;
1382     }
1383   else
1384     memcpy (qbuf, ecc_q, ecc_q_len);
1385
1386   if (ctrl)
1387     {
1388       send_key_data (ctrl, "q", qbuf, ecc_q_len);
1389       send_key_data (ctrl, "curve", oidbuf, oid_len);
1390     }
1391
1392   if (keyno == 1)
1393     {
1394       if (ctrl)
1395         send_key_data (ctrl, "kdf/kek", ecdh_params (curve), (size_t)4);
1396       algo = PUBKEY_ALGO_ECDH;
1397     }
1398   else
1399     {
1400       if ((app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1401         algo = PUBKEY_ALGO_EDDSA;
1402       else
1403         algo = PUBKEY_ALGO_ECDSA;
1404     }
1405
1406   if (ctrl)
1407     {
1408       unsigned char fprbuf[20];
1409
1410       err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
1411                        qbuf, ecc_q_len, ecdh_params (curve), (size_t)4);
1412       if (err)
1413         goto leave;
1414
1415       send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1416     }
1417
1418   if (!(app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK))
1419     format = "(public-key(ecc(curve%s)(q%b)))";
1420   else if (keyno == 1)
1421     format = "(public-key(ecc(curve%s)(flags djb-tweak)(q%b)))";
1422   else
1423     format = "(public-key(ecc(curve%s)(flags eddsa)(q%b)))";
1424
1425   err = gcry_sexp_build (r_sexp, NULL, format,
1426                          app->app_local->keyattr[keyno].ecc.curve,
1427                          (int)ecc_q_len, qbuf);
1428  leave:
1429   gcry_mpi_release (oid);
1430   xfree (qbuf);
1431   return err;
1432 }
1433
1434
1435 /* Parse tag-length-value data for public key in BUFFER of BUFLEN
1436    length.  Key of KEYNO in APP is updated with an S-expression of
1437    public key.  When CTRL is not NULL, fingerprint is computed with
1438    CREATED_AT, and fingerprint is written to the card, and key data
1439    and fingerprint are send back to the client side.
1440  */
1441 static gpg_error_t
1442 read_public_key (app_t app, ctrl_t ctrl, u32 created_at, int keyno,
1443                  const unsigned char *buffer, size_t buflen)
1444 {
1445   gpg_error_t err;
1446   const unsigned char *data;
1447   size_t datalen;
1448   gcry_sexp_t s_pkey = NULL;
1449
1450   data = find_tlv (buffer, buflen, 0x7F49, &datalen);
1451   if (!data)
1452     {
1453       log_error (_("response does not contain the public key data\n"));
1454       return gpg_error (GPG_ERR_CARD);
1455     }
1456
1457   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
1458     err = rsa_read_pubkey (app, ctrl, created_at, keyno,
1459                            data, datalen, &s_pkey);
1460   else if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_ECC)
1461     err = ecc_read_pubkey (app, ctrl, created_at, keyno,
1462                            data, datalen, &s_pkey);
1463   else
1464     err = gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1465
1466   if (!err)
1467     {
1468       unsigned char *keybuf;
1469       size_t len;
1470
1471       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1472       keybuf = xtrymalloc (len);
1473       if (!data)
1474         {
1475           err = gpg_error_from_syserror ();
1476           gcry_sexp_release (s_pkey);
1477           return err;
1478         }
1479
1480       gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1481       gcry_sexp_release (s_pkey);
1482
1483       app->app_local->pk[keyno].key = keybuf;
1484       /* Decrement for trailing '\0' */
1485       app->app_local->pk[keyno].keylen = len - 1;
1486     }
1487
1488   return err;
1489 }
1490
1491
1492 /* Get the public key for KEYNO and store it as an S-expresion with
1493    the APP handle.  On error that field gets cleared.  If we already
1494    know about the public key we will just return.  Note that this does
1495    not mean a key is available; this is solely indicated by the
1496    presence of the app->app_local->pk[KEYNO].key field.
1497
1498    Note that GnuPG 1.x does not need this and it would be too time
1499    consuming to send it just for the fun of it. However, given that we
1500    use the same code in gpg 1.4, we can't use the gcry S-expresion
1501    here but need to open encode it. */
1502 #if GNUPG_MAJOR_VERSION > 1
1503 static gpg_error_t
1504 get_public_key (app_t app, int keyno)
1505 {
1506   gpg_error_t err = 0;
1507   unsigned char *buffer;
1508   const unsigned char *m, *e;
1509   size_t buflen;
1510   size_t mlen = 0;
1511   size_t elen = 0;
1512   char *keybuf = NULL;
1513   gcry_sexp_t s_pkey;
1514   size_t len;
1515
1516   if (keyno < 0 || keyno > 2)
1517     return gpg_error (GPG_ERR_INV_ID);
1518
1519   /* Already cached? */
1520   if (app->app_local->pk[keyno].read_done)
1521     return 0;
1522
1523   xfree (app->app_local->pk[keyno].key);
1524   app->app_local->pk[keyno].key = NULL;
1525   app->app_local->pk[keyno].keylen = 0;
1526
1527   m = e = NULL; /* (avoid cc warning) */
1528
1529   if (app->card_version > 0x0100)
1530     {
1531       int exmode, le_value;
1532
1533       /* We may simply read the public key out of these cards.  */
1534       if (app->app_local->cardcap.ext_lc_le)
1535         {
1536           exmode = 1;    /* Use extended length.  */
1537           le_value = app->app_local->extcap.max_rsp_data;
1538         }
1539       else
1540         {
1541           exmode = 0;
1542           le_value = 256; /* Use legacy value. */
1543         }
1544
1545       err = iso7816_read_public_key (app->slot, exmode,
1546                                      (keyno == 0? "\xB6" :
1547                                       keyno == 1? "\xB8" : "\xA4"),
1548                                      2, le_value, &buffer, &buflen);
1549       if (err)
1550         {
1551           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1552           goto leave;
1553         }
1554
1555       err = read_public_key (app, NULL, 0U, keyno, buffer, buflen);
1556     }
1557   else
1558     {
1559       /* Due to a design problem in v1.0 cards we can't get the public
1560          key out of these cards without doing a verify on CHV3.
1561          Clearly that is not an option and thus we try to locate the
1562          key using an external helper.
1563
1564          The helper we use here is gpg itself, which should know about
1565          the key in any case.  */
1566
1567       char fpr[41];
1568       char *hexkeyid;
1569       char *command = NULL;
1570       FILE *fp;
1571       int ret;
1572
1573       buffer = NULL; /* We don't need buffer.  */
1574
1575       err = retrieve_fpr_from_card (app, keyno, fpr);
1576       if (err)
1577         {
1578           log_error ("error while retrieving fpr from card: %s\n",
1579                      gpg_strerror (err));
1580           goto leave;
1581         }
1582       hexkeyid = fpr + 24;
1583
1584       ret = gpgrt_asprintf
1585         (&command, "gpg --list-keys --with-colons --with-key-data '%s'", fpr);
1586       if (ret < 0)
1587         {
1588           err = gpg_error_from_syserror ();
1589           goto leave;
1590         }
1591
1592       fp = popen (command, "r");
1593       xfree (command);
1594       if (!fp)
1595         {
1596           err = gpg_error_from_syserror ();
1597           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1598           goto leave;
1599         }
1600
1601       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1602       pclose (fp);
1603       if (err)
1604         {
1605           log_error ("error while retrieving key material through pipe: %s\n",
1606                      gpg_strerror (err));
1607           goto leave;
1608         }
1609
1610       err = gcry_sexp_build (&s_pkey, NULL, "(public-key(rsa(n%b)(e%b)))",
1611                              (int)mlen, m, (int)elen, e);
1612       if (err)
1613         goto leave;
1614
1615       len = gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, NULL, 0);
1616
1617       keybuf = xtrymalloc (len);
1618       if (!keybuf)
1619         {
1620           err = gpg_error_from_syserror ();
1621           gcry_sexp_release (s_pkey);
1622           goto leave;
1623         }
1624
1625       gcry_sexp_sprint (s_pkey, GCRYSEXP_FMT_CANON, keybuf, len);
1626       gcry_sexp_release (s_pkey);
1627
1628       app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1629       /* Decrement for trailing '\0' */
1630       app->app_local->pk[keyno].keylen = len - 1;
1631     }
1632
1633  leave:
1634   /* Set a flag to indicate that we tried to read the key.  */
1635   app->app_local->pk[keyno].read_done = 1;
1636
1637   xfree (buffer);
1638   return err;
1639 }
1640 #endif /* GNUPG_MAJOR_VERSION > 1 */
1641
1642
1643
1644 /* Send the KEYPAIRINFO back. KEY needs to be in the range [1,3].
1645    This is used by the LEARN command. */
1646 static gpg_error_t
1647 send_keypair_info (app_t app, ctrl_t ctrl, int key)
1648 {
1649   int keyno = key - 1;
1650   gpg_error_t err = 0;
1651   /* Note that GnuPG 1.x does not need this and it would be too time
1652      consuming to send it just for the fun of it. */
1653 #if GNUPG_MAJOR_VERSION > 1
1654   unsigned char grip[20];
1655   char gripstr[41];
1656   char idbuf[50];
1657
1658   err = get_public_key (app, keyno);
1659   if (err)
1660     goto leave;
1661
1662   assert (keyno >= 0 && keyno <= 2);
1663   if (!app->app_local->pk[keyno].key)
1664     goto leave; /* No such key - ignore. */
1665
1666   err = keygrip_from_canon_sexp (app->app_local->pk[keyno].key,
1667                                  app->app_local->pk[keyno].keylen,
1668                                  grip);
1669   if (err)
1670     goto leave;
1671
1672   bin2hex (grip, 20, gripstr);
1673
1674   sprintf (idbuf, "OPENPGP.%d", keyno+1);
1675   send_status_info (ctrl, "KEYPAIRINFO",
1676                     gripstr, 40,
1677                     idbuf, strlen (idbuf),
1678                     NULL, (size_t)0);
1679
1680  leave:
1681 #endif /* GNUPG_MAJOR_VERSION > 1 */
1682
1683   return err;
1684 }
1685
1686
1687 /* Handle the LEARN command for OpenPGP.  */
1688 static gpg_error_t
1689 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1690 {
1691   (void)flags;
1692
1693   do_getattr (app, ctrl, "EXTCAP");
1694   do_getattr (app, ctrl, "DISP-NAME");
1695   do_getattr (app, ctrl, "DISP-LANG");
1696   do_getattr (app, ctrl, "DISP-SEX");
1697   do_getattr (app, ctrl, "PUBKEY-URL");
1698   do_getattr (app, ctrl, "LOGIN-DATA");
1699   do_getattr (app, ctrl, "KEY-FPR");
1700   if (app->card_version > 0x0100)
1701     do_getattr (app, ctrl, "KEY-TIME");
1702   do_getattr (app, ctrl, "CA-FPR");
1703   do_getattr (app, ctrl, "CHV-STATUS");
1704   do_getattr (app, ctrl, "SIG-COUNTER");
1705   if (app->app_local->extcap.private_dos)
1706     {
1707       do_getattr (app, ctrl, "PRIVATE-DO-1");
1708       do_getattr (app, ctrl, "PRIVATE-DO-2");
1709       if (app->did_chv2)
1710         do_getattr (app, ctrl, "PRIVATE-DO-3");
1711       if (app->did_chv3)
1712         do_getattr (app, ctrl, "PRIVATE-DO-4");
1713     }
1714   send_keypair_info (app, ctrl, 1);
1715   send_keypair_info (app, ctrl, 2);
1716   send_keypair_info (app, ctrl, 3);
1717   /* Note: We do not send the Cardholder Certificate, because that is
1718      relatively long and for OpenPGP applications not really needed.  */
1719   return 0;
1720 }
1721
1722
1723 /* Handle the READKEY command for OpenPGP.  On success a canonical
1724    encoded S-expression with the public key will get stored at PK and
1725    its length (for assertions) at PKLEN; the caller must release that
1726    buffer. On error PK and PKLEN are not changed and an error code is
1727    returned.  */
1728 static gpg_error_t
1729 do_readkey (app_t app, int advanced, const char *keyid,
1730             unsigned char **pk, size_t *pklen)
1731 {
1732 #if GNUPG_MAJOR_VERSION > 1
1733   gpg_error_t err;
1734   int keyno;
1735   unsigned char *buf;
1736
1737   if (!strcmp (keyid, "OPENPGP.1"))
1738     keyno = 0;
1739   else if (!strcmp (keyid, "OPENPGP.2"))
1740     keyno = 1;
1741   else if (!strcmp (keyid, "OPENPGP.3"))
1742     keyno = 2;
1743   else
1744     return gpg_error (GPG_ERR_INV_ID);
1745
1746   err = get_public_key (app, keyno);
1747   if (err)
1748     return err;
1749
1750   buf = app->app_local->pk[keyno].key;
1751   if (!buf)
1752     return gpg_error (GPG_ERR_NO_PUBKEY);
1753
1754   if (advanced)
1755     {
1756       gcry_sexp_t s_key;
1757
1758       err = gcry_sexp_new (&s_key, buf, app->app_local->pk[keyno].keylen, 0);
1759       if (err)
1760         return err;
1761
1762       *pklen = gcry_sexp_sprint (s_key, GCRYSEXP_FMT_ADVANCED, NULL, 0);
1763       *pk = xtrymalloc (*pklen);
1764       if (!*pk)
1765         {
1766           err = gpg_error_from_syserror ();
1767           *pklen = 0;
1768           return err;
1769         }
1770
1771       gcry_sexp_sprint (s_key, GCRYSEXP_FMT_ADVANCED, *pk, *pklen);
1772       gcry_sexp_release (s_key);
1773     }
1774   else
1775     {
1776       *pklen = app->app_local->pk[keyno].keylen;
1777       *pk = xtrymalloc (*pklen);
1778       if (!*pk)
1779         {
1780           err = gpg_error_from_syserror ();
1781           *pklen = 0;
1782           return err;
1783         }
1784       memcpy (*pk, buf, *pklen);
1785     }
1786
1787   return 0;
1788 #else
1789   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1790 #endif
1791 }
1792
1793 /* Read the standard certificate of an OpenPGP v2 card.  It is
1794    returned in a freshly allocated buffer with that address stored at
1795    CERT and the length of the certificate stored at CERTLEN.  CERTID
1796    needs to be set to "OPENPGP.3".  */
1797 static gpg_error_t
1798 do_readcert (app_t app, const char *certid,
1799              unsigned char **cert, size_t *certlen)
1800 {
1801 #if GNUPG_MAJOR_VERSION > 1
1802   gpg_error_t err;
1803   unsigned char *buffer;
1804   size_t buflen;
1805   void *relptr;
1806
1807   *cert = NULL;
1808   *certlen = 0;
1809   if (strcmp (certid, "OPENPGP.3"))
1810     return gpg_error (GPG_ERR_INV_ID);
1811   if (!app->app_local->extcap.is_v2)
1812     return gpg_error (GPG_ERR_NOT_FOUND);
1813
1814   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1815   if (!relptr)
1816     return gpg_error (GPG_ERR_NOT_FOUND);
1817
1818   if (!buflen)
1819     err = gpg_error (GPG_ERR_NOT_FOUND);
1820   else if (!(*cert = xtrymalloc (buflen)))
1821     err = gpg_error_from_syserror ();
1822   else
1823     {
1824       memcpy (*cert, buffer, buflen);
1825       *certlen = buflen;
1826       err  = 0;
1827     }
1828   xfree (relptr);
1829   return err;
1830 #else
1831   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1832 #endif
1833 }
1834
1835
1836 /* Decide if we use the pinpad of the reader for PIN input according
1837    to the user preference on the card, and the capability of the
1838    reader.  This routine is only called when the reader has pinpad.
1839    Returns 0 if we use pinpad, 1 otherwise.  */
1840 static int
1841 check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1842 {
1843   if (app->app_local->pinpad.specified == 0) /* No preference on card.  */
1844     {
1845       if (pininfo->fixedlen == 0) /* Reader has varlen capability.  */
1846         return 0;                 /* Then, use pinpad.  */
1847       else
1848         /*
1849          * Reader has limited capability, and it may not match PIN of
1850          * the card.
1851          */
1852         return 1;
1853     }
1854
1855   if (admin_pin)
1856     pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
1857   else
1858     pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
1859
1860   if (pininfo->fixedlen == 0    /* User requests disable pinpad.  */
1861       || pininfo->fixedlen < pininfo->minlen
1862       || pininfo->fixedlen > pininfo->maxlen
1863       /* Reader doesn't have the capability to input a PIN which
1864        * length is FIXEDLEN.  */)
1865     return 1;
1866
1867   return 0;
1868 }
1869
1870
1871 /* Verify a CHV either using using the pinentry or if possible by
1872    using a pinpad.  PINCB and PINCB_ARG describe the usual callback
1873    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1874    used with CHV1.  PINVALUE is the address of a pointer which will
1875    receive a newly allocated block with the actual PIN (this is useful
1876    in case that PIN shall be used for another verify operation).  The
1877    caller needs to free this value.  If the function returns with
1878    success and NULL is stored at PINVALUE, the caller should take this
1879    as an indication that the pinpad has been used.
1880    */
1881 static gpg_error_t
1882 verify_a_chv (app_t app,
1883               gpg_error_t (*pincb)(void*, const char *, char **),
1884               void *pincb_arg,
1885               int chvno, unsigned long sigcount, char **pinvalue)
1886 {
1887   int rc = 0;
1888   char *prompt_buffer = NULL;
1889   const char *prompt;
1890   pininfo_t pininfo;
1891   int minlen = 6;
1892
1893   assert (chvno == 1 || chvno == 2);
1894
1895   *pinvalue = NULL;
1896
1897   if (chvno == 2 && app->app_local->flags.def_chv2)
1898     {
1899       /* Special case for def_chv2 mechanism. */
1900       if (opt.verbose)
1901         log_info (_("using default PIN as %s\n"), "CHV2");
1902       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1903       if (rc)
1904         {
1905           /* Verification of CHV2 with the default PIN failed,
1906              although the card pretends to have the default PIN set as
1907              CHV2.  We better disable the def_chv2 flag now. */
1908           log_info (_("failed to use default PIN as %s: %s"
1909                       " - disabling further default use\n"),
1910                     "CHV2", gpg_strerror (rc));
1911           app->app_local->flags.def_chv2 = 0;
1912         }
1913       return rc;
1914     }
1915
1916   memset (&pininfo, 0, sizeof pininfo);
1917   pininfo.fixedlen = -1;
1918   pininfo.minlen = minlen;
1919
1920
1921   if (chvno == 1)
1922     {
1923 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1924       size_t promptsize = strlen (PROMPTSTRING) + 50;
1925
1926       prompt_buffer = xtrymalloc (promptsize);
1927       if (!prompt_buffer)
1928         return gpg_error_from_syserror ();
1929       snprintf (prompt_buffer, promptsize, PROMPTSTRING, sigcount);
1930       prompt = prompt_buffer;
1931 #undef PROMPTSTRING
1932     }
1933   else
1934     prompt = _("||Please enter the PIN");
1935
1936
1937   if (!opt.disable_pinpad
1938       && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
1939       && !check_pinpad_request (app, &pininfo, 0))
1940     {
1941       /* The reader supports the verify command through the pinpad.
1942          Note that the pincb appends a text to the prompt telling the
1943          user to use the pinpad. */
1944       rc = pincb (pincb_arg, prompt, NULL);
1945       prompt = NULL;
1946       xfree (prompt_buffer);
1947       prompt_buffer = NULL;
1948       if (rc)
1949         {
1950           log_info (_("PIN callback returned error: %s\n"),
1951                     gpg_strerror (rc));
1952           return rc;
1953         }
1954       rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
1955       /* Dismiss the prompt. */
1956       pincb (pincb_arg, NULL, NULL);
1957
1958       assert (!*pinvalue);
1959     }
1960   else
1961     {
1962       /* The reader has no pinpad or we don't want to use it. */
1963       rc = pincb (pincb_arg, prompt, pinvalue);
1964       prompt = NULL;
1965       xfree (prompt_buffer);
1966       prompt_buffer = NULL;
1967       if (rc)
1968         {
1969           log_info (_("PIN callback returned error: %s\n"),
1970                     gpg_strerror (rc));
1971           return rc;
1972         }
1973
1974       if (strlen (*pinvalue) < minlen)
1975         {
1976           log_error (_("PIN for CHV%d is too short;"
1977                        " minimum length is %d\n"), chvno, minlen);
1978           xfree (*pinvalue);
1979           *pinvalue = NULL;
1980           return gpg_error (GPG_ERR_BAD_PIN);
1981         }
1982
1983       rc = iso7816_verify (app->slot, 0x80+chvno,
1984                            *pinvalue, strlen (*pinvalue));
1985     }
1986
1987   if (rc)
1988     {
1989       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1990       xfree (*pinvalue);
1991       *pinvalue = NULL;
1992       flush_cache_after_error (app);
1993     }
1994
1995   return rc;
1996 }
1997
1998
1999 /* Verify CHV2 if required.  Depending on the configuration of the
2000    card CHV1 will also be verified. */
2001 static gpg_error_t
2002 verify_chv2 (app_t app,
2003              gpg_error_t (*pincb)(void*, const char *, char **),
2004              void *pincb_arg)
2005 {
2006   int rc;
2007   char *pinvalue;
2008
2009   if (app->did_chv2)
2010     return 0;  /* We already verified CHV2.  */
2011
2012   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
2013   if (rc)
2014     return rc;
2015   app->did_chv2 = 1;
2016
2017   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
2018     {
2019       /* For convenience we verify CHV1 here too.  We do this only if
2020          the card is not configured to require a verification before
2021          each CHV1 controlled operation (force_chv1) and if we are not
2022          using the pinpad (PINVALUE == NULL). */
2023       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
2024       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2025         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2026       if (rc)
2027         {
2028           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2029           flush_cache_after_error (app);
2030         }
2031       else
2032         app->did_chv1 = 1;
2033     }
2034
2035   xfree (pinvalue);
2036
2037   return rc;
2038 }
2039
2040
2041 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
2042    current sdtate of the card.  */
2043 static gpg_error_t
2044 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
2045 {
2046   void *relptr;
2047   unsigned char *value;
2048   size_t valuelen;
2049   int remaining;
2050   char *prompt;
2051
2052   *r_prompt = NULL;
2053
2054   relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2055   if (!relptr || valuelen < 7)
2056     {
2057       log_error (_("error retrieving CHV status from card\n"));
2058       xfree (relptr);
2059       return gpg_error (GPG_ERR_CARD);
2060     }
2061   if (value[6] == 0)
2062     {
2063       log_info (_("card is permanently locked!\n"));
2064       xfree (relptr);
2065       return gpg_error (GPG_ERR_BAD_PIN);
2066     }
2067   remaining = value[6];
2068   xfree (relptr);
2069
2070   log_info (ngettext("%d Admin PIN attempt remaining before card"
2071                      " is permanently locked\n",
2072                      "%d Admin PIN attempts remaining before card"
2073                      " is permanently locked\n",
2074                      remaining), remaining);
2075
2076   if (remaining < 3)
2077     {
2078       /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
2079          the start of the string.  Use %%0A to force a linefeed.  */
2080       prompt = xtryasprintf (_("|A|Please enter the Admin PIN%%0A"
2081                                "[remaining attempts: %d]"), remaining);
2082     }
2083   else
2084     prompt = xtrystrdup (_("|A|Please enter the Admin PIN"));
2085
2086   if (!prompt)
2087     return gpg_error_from_syserror ();
2088
2089   *r_prompt = prompt;
2090   return 0;
2091 }
2092
2093
2094 /* Verify CHV3 if required. */
2095 static gpg_error_t
2096 verify_chv3 (app_t app,
2097              gpg_error_t (*pincb)(void*, const char *, char **),
2098              void *pincb_arg)
2099 {
2100   int rc = 0;
2101
2102 #if GNUPG_MAJOR_VERSION != 1
2103   if (!opt.allow_admin)
2104     {
2105       log_info (_("access to admin commands is not configured\n"));
2106       return gpg_error (GPG_ERR_EACCES);
2107     }
2108 #endif
2109
2110   if (!app->did_chv3)
2111     {
2112       pininfo_t pininfo;
2113       int minlen = 8;
2114       char *prompt;
2115
2116       memset (&pininfo, 0, sizeof pininfo);
2117       pininfo.fixedlen = -1;
2118       pininfo.minlen = minlen;
2119
2120       rc = build_enter_admin_pin_prompt (app, &prompt);
2121       if (rc)
2122         return rc;
2123
2124       if (!opt.disable_pinpad
2125           && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
2126           && !check_pinpad_request (app, &pininfo, 1))
2127         {
2128           /* The reader supports the verify command through the pinpad. */
2129           rc = pincb (pincb_arg, prompt, NULL);
2130           xfree (prompt);
2131           prompt = NULL;
2132           if (rc)
2133             {
2134               log_info (_("PIN callback returned error: %s\n"),
2135                         gpg_strerror (rc));
2136               return rc;
2137             }
2138           rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
2139           /* Dismiss the prompt. */
2140           pincb (pincb_arg, NULL, NULL);
2141         }
2142       else
2143         {
2144           char *pinvalue;
2145
2146           rc = pincb (pincb_arg, prompt, &pinvalue);
2147           xfree (prompt);
2148           prompt = NULL;
2149           if (rc)
2150             {
2151               log_info (_("PIN callback returned error: %s\n"),
2152                         gpg_strerror (rc));
2153               return rc;
2154             }
2155
2156           if (strlen (pinvalue) < minlen)
2157             {
2158               log_error (_("PIN for CHV%d is too short;"
2159                            " minimum length is %d\n"), 3, minlen);
2160               xfree (pinvalue);
2161               return gpg_error (GPG_ERR_BAD_PIN);
2162             }
2163
2164           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
2165           xfree (pinvalue);
2166         }
2167
2168       if (rc)
2169         {
2170           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
2171           flush_cache_after_error (app);
2172           return rc;
2173         }
2174       app->did_chv3 = 1;
2175     }
2176   return rc;
2177 }
2178
2179
2180 /* Handle the SETATTR operation. All arguments are already basically
2181    checked. */
2182 static gpg_error_t
2183 do_setattr (app_t app, const char *name,
2184             gpg_error_t (*pincb)(void*, const char *, char **),
2185             void *pincb_arg,
2186             const unsigned char *value, size_t valuelen)
2187 {
2188   gpg_error_t rc;
2189   int idx;
2190   static struct {
2191     const char *name;
2192     int tag;
2193     int need_chv;
2194     int special;
2195     unsigned int need_v2:1;
2196   } table[] = {
2197     { "DISP-NAME",    0x005B, 3 },
2198     { "LOGIN-DATA",   0x005E, 3, 2 },
2199     { "DISP-LANG",    0x5F2D, 3 },
2200     { "DISP-SEX",     0x5F35, 3 },
2201     { "PUBKEY-URL",   0x5F50, 3 },
2202     { "CHV-STATUS-1", 0x00C4, 3, 1 },
2203     { "CA-FPR-1",     0x00CA, 3 },
2204     { "CA-FPR-2",     0x00CB, 3 },
2205     { "CA-FPR-3",     0x00CC, 3 },
2206     { "PRIVATE-DO-1", 0x0101, 2 },
2207     { "PRIVATE-DO-2", 0x0102, 3 },
2208     { "PRIVATE-DO-3", 0x0103, 2 },
2209     { "PRIVATE-DO-4", 0x0104, 3 },
2210     { "CERT-3",       0x7F21, 3, 0, 1 },
2211     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
2212     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
2213     { "KEY-ATTR",     0,      0, 3, 1 },
2214     { "AESKEY",       0x00D5, 3, 0, 1 },
2215     { NULL, 0 }
2216   };
2217   int exmode;
2218
2219   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
2220     ;
2221   if (!table[idx].name)
2222     return gpg_error (GPG_ERR_INV_NAME);
2223   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
2224     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
2225
2226   if (table[idx].special == 3)
2227     return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
2228
2229   switch (table[idx].need_chv)
2230     {
2231     case 2:
2232       rc = verify_chv2 (app, pincb, pincb_arg);
2233       break;
2234     case 3:
2235       rc = verify_chv3 (app, pincb, pincb_arg);
2236       break;
2237     default:
2238       rc = 0;
2239     }
2240   if (rc)
2241     return rc;
2242
2243   /* Flush the cache before writing it, so that the next get operation
2244      will reread the data from the card and thus get synced in case of
2245      errors (e.g. data truncated by the card). */
2246   flush_cache_item (app, table[idx].tag);
2247
2248   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
2249     exmode = 1;    /* Use extended length w/o a limit.  */
2250   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
2251     exmode = -254; /* Command chaining with max. 254 bytes.  */
2252   else
2253     exmode = 0;
2254   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
2255   if (rc)
2256     log_error ("failed to set '%s': %s\n", table[idx].name, gpg_strerror (rc));
2257
2258   if (table[idx].special == 1)
2259     app->force_chv1 = (valuelen && *value == 0);
2260   else if (table[idx].special == 2)
2261     parse_login_data (app);
2262
2263   return rc;
2264 }
2265
2266
2267 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
2268    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
2269    PINCB and PINCB_ARG are the usual arguments for the pinentry
2270    callback.  */
2271 static gpg_error_t
2272 do_writecert (app_t app, ctrl_t ctrl,
2273               const char *certidstr,
2274               gpg_error_t (*pincb)(void*, const char *, char **),
2275               void *pincb_arg,
2276               const unsigned char *certdata, size_t certdatalen)
2277 {
2278   (void)ctrl;
2279 #if GNUPG_MAJOR_VERSION > 1
2280   if (strcmp (certidstr, "OPENPGP.3"))
2281     return gpg_error (GPG_ERR_INV_ID);
2282   if (!certdata || !certdatalen)
2283     return gpg_error (GPG_ERR_INV_ARG);
2284   if (!app->app_local->extcap.is_v2)
2285     return gpg_error (GPG_ERR_NOT_SUPPORTED);
2286   if (certdatalen > app->app_local->extcap.max_certlen_3)
2287     return gpg_error (GPG_ERR_TOO_LARGE);
2288   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
2289 #else
2290   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
2291 #endif
2292 }
2293
2294
2295
2296 /* Handle the PASSWD command.  The following combinations are
2297    possible:
2298
2299     Flags  CHVNO Vers.  Description
2300     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
2301     RESET    1   2      Verify PW3 and set a new PW1.
2302     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
2303     RESET    2   2      Verify PW3 and set a new Reset Code.
2304     RESET    3   any    Returns GPG_ERR_INV_ID.
2305      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
2306      -       1   2      Verify PW1 and set a new PW1.
2307      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
2308      -       2   2      Verify Reset Code and set a new PW1.
2309      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
2310  */
2311 static gpg_error_t
2312 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
2313                unsigned int flags,
2314                gpg_error_t (*pincb)(void*, const char *, char **),
2315                void *pincb_arg)
2316 {
2317   int rc = 0;
2318   int chvno = atoi (chvnostr);
2319   char *resetcode = NULL;
2320   char *oldpinvalue = NULL;
2321   char *pinvalue = NULL;
2322   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2323   int set_resetcode = 0;
2324   pininfo_t pininfo;
2325   int use_pinpad = 0;
2326   int minlen = 6;
2327
2328   (void)ctrl;
2329   memset (&pininfo, 0, sizeof pininfo);
2330   pininfo.fixedlen = -1;
2331   pininfo.minlen = minlen;
2332
2333   if (reset_mode && chvno == 3)
2334     {
2335       rc = gpg_error (GPG_ERR_INV_ID);
2336       goto leave;
2337     }
2338
2339   if (!app->app_local->extcap.is_v2)
2340     {
2341       /* Version 1 cards.  */
2342
2343       if (reset_mode || chvno == 3)
2344         {
2345           /* We always require that the PIN is entered. */
2346           app->did_chv3 = 0;
2347           rc = verify_chv3 (app, pincb, pincb_arg);
2348           if (rc)
2349             goto leave;
2350         }
2351       else if (chvno == 1 || chvno == 2)
2352         {
2353           /* On a v1.x card CHV1 and CVH2 should always have the same
2354              value, thus we enforce it here.  */
2355           int save_force = app->force_chv1;
2356
2357           app->force_chv1 = 0;
2358           app->did_chv1 = 0;
2359           app->did_chv2 = 0;
2360           rc = verify_chv2 (app, pincb, pincb_arg);
2361           app->force_chv1 = save_force;
2362           if (rc)
2363             goto leave;
2364         }
2365       else
2366         {
2367           rc = gpg_error (GPG_ERR_INV_ID);
2368           goto leave;
2369         }
2370     }
2371   else
2372     {
2373       /* Version 2 cards.  */
2374
2375       if (!opt.disable_pinpad
2376           && !iso7816_check_pinpad (app->slot,
2377                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2378           && !check_pinpad_request (app, &pininfo, chvno == 3))
2379         use_pinpad = 1;
2380
2381       if (reset_mode)
2382         {
2383           /* To reset a PIN the Admin PIN is required. */
2384           use_pinpad = 0;
2385           app->did_chv3 = 0;
2386           rc = verify_chv3 (app, pincb, pincb_arg);
2387           if (rc)
2388             goto leave;
2389
2390           if (chvno == 2)
2391             set_resetcode = 1;
2392         }
2393       else if (chvno == 1 || chvno == 3)
2394         {
2395           if (!use_pinpad)
2396             {
2397               char *promptbuf = NULL;
2398               const char *prompt;
2399
2400               if (chvno == 3)
2401                 {
2402                   minlen = 8;
2403                   rc = build_enter_admin_pin_prompt (app, &promptbuf);
2404                   if (rc)
2405                     goto leave;
2406                   prompt = promptbuf;
2407                 }
2408               else
2409                 prompt = _("||Please enter the PIN");
2410               rc = pincb (pincb_arg, prompt, &oldpinvalue);
2411               xfree (promptbuf);
2412               promptbuf = NULL;
2413               if (rc)
2414                 {
2415                   log_info (_("PIN callback returned error: %s\n"),
2416                             gpg_strerror (rc));
2417                   goto leave;
2418                 }
2419
2420               if (strlen (oldpinvalue) < minlen)
2421                 {
2422                   log_info (_("PIN for CHV%d is too short;"
2423                               " minimum length is %d\n"), chvno, minlen);
2424                   rc = gpg_error (GPG_ERR_BAD_PIN);
2425                   goto leave;
2426                 }
2427             }
2428         }
2429       else if (chvno == 2)
2430         {
2431           /* There is no PW2 for v2 cards.  We use this condition to
2432              allow a PW reset using the Reset Code.  */
2433           void *relptr;
2434           unsigned char *value;
2435           size_t valuelen;
2436           int remaining;
2437
2438           use_pinpad = 0;
2439           minlen = 8;
2440           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2441           if (!relptr || valuelen < 7)
2442             {
2443               log_error (_("error retrieving CHV status from card\n"));
2444               xfree (relptr);
2445               rc = gpg_error (GPG_ERR_CARD);
2446               goto leave;
2447             }
2448           remaining = value[5];
2449           xfree (relptr);
2450           if (!remaining)
2451             {
2452               log_error (_("Reset Code not or not anymore available\n"));
2453               rc = gpg_error (GPG_ERR_BAD_PIN);
2454               goto leave;
2455             }
2456
2457           rc = pincb (pincb_arg,
2458                       _("||Please enter the Reset Code for the card"),
2459                       &resetcode);
2460           if (rc)
2461             {
2462               log_info (_("PIN callback returned error: %s\n"),
2463                         gpg_strerror (rc));
2464               goto leave;
2465             }
2466           if (strlen (resetcode) < minlen)
2467             {
2468               log_info (_("Reset Code is too short; minimum length is %d\n"),
2469                         minlen);
2470               rc = gpg_error (GPG_ERR_BAD_PIN);
2471               goto leave;
2472             }
2473         }
2474       else
2475         {
2476           rc = gpg_error (GPG_ERR_INV_ID);
2477           goto leave;
2478         }
2479     }
2480
2481   if (chvno == 3)
2482     app->did_chv3 = 0;
2483   else
2484     app->did_chv1 = app->did_chv2 = 0;
2485
2486   if (!use_pinpad)
2487     {
2488       /* TRANSLATORS: Do not translate the "|*|" prefixes but
2489          keep it at the start of the string.  We need this elsewhere
2490          to get some infos on the string. */
2491       rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2492                   chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2493                   &pinvalue);
2494       if (rc)
2495         {
2496           log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2497           goto leave;
2498         }
2499     }
2500
2501
2502   if (resetcode)
2503     {
2504       char *buffer;
2505
2506       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2507       if (!buffer)
2508         rc = gpg_error_from_syserror ();
2509       else
2510         {
2511           strcpy (stpcpy (buffer, resetcode), pinvalue);
2512           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2513                                                     buffer, strlen (buffer));
2514           wipememory (buffer, strlen (buffer));
2515           xfree (buffer);
2516         }
2517     }
2518   else if (set_resetcode)
2519     {
2520       if (strlen (pinvalue) < 8)
2521         {
2522           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2523           rc = gpg_error (GPG_ERR_BAD_PIN);
2524         }
2525       else
2526         rc = iso7816_put_data (app->slot, 0, 0xD3,
2527                                pinvalue, strlen (pinvalue));
2528     }
2529   else if (reset_mode)
2530     {
2531       rc = iso7816_reset_retry_counter (app->slot, 0x81,
2532                                         pinvalue, strlen (pinvalue));
2533       if (!rc && !app->app_local->extcap.is_v2)
2534         rc = iso7816_reset_retry_counter (app->slot, 0x82,
2535                                           pinvalue, strlen (pinvalue));
2536     }
2537   else if (!app->app_local->extcap.is_v2)
2538     {
2539       /* Version 1 cards.  */
2540       if (chvno == 1 || chvno == 2)
2541         {
2542           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2543                                               pinvalue, strlen (pinvalue));
2544           if (!rc)
2545             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2546                                                 pinvalue, strlen (pinvalue));
2547         }
2548       else /* CHVNO == 3 */
2549         {
2550           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2551                                               pinvalue, strlen (pinvalue));
2552         }
2553     }
2554   else
2555     {
2556       /* Version 2 cards.  */
2557       assert (chvno == 1 || chvno == 3);
2558
2559       if (use_pinpad)
2560         {
2561           rc = pincb (pincb_arg,
2562                       chvno == 3 ?
2563                       _("||Please enter the Admin PIN and New Admin PIN") :
2564                       _("||Please enter the PIN and New PIN"), NULL);
2565           if (rc)
2566             {
2567               log_info (_("PIN callback returned error: %s\n"),
2568                         gpg_strerror (rc));
2569               goto leave;
2570             }
2571           rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
2572                                                  &pininfo);
2573           pincb (pincb_arg, NULL, NULL); /* Dismiss the prompt. */
2574         }
2575       else
2576         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2577                                             oldpinvalue, strlen (oldpinvalue),
2578                                             pinvalue, strlen (pinvalue));
2579     }
2580
2581   if (pinvalue)
2582     {
2583       wipememory (pinvalue, strlen (pinvalue));
2584       xfree (pinvalue);
2585     }
2586   if (rc)
2587     flush_cache_after_error (app);
2588
2589  leave:
2590   if (resetcode)
2591     {
2592       wipememory (resetcode, strlen (resetcode));
2593       xfree (resetcode);
2594     }
2595   if (oldpinvalue)
2596     {
2597       wipememory (oldpinvalue, strlen (oldpinvalue));
2598       xfree (oldpinvalue);
2599     }
2600   return rc;
2601 }
2602
2603
2604 /* Check whether a key already exists.  KEYIDX is the index of the key
2605    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2606    error returned if the key already exists.  The flag GENERATING is
2607    only used to print correct messages. */
2608 static gpg_error_t
2609 does_key_exist (app_t app, int keyidx, int generating, int force)
2610 {
2611   const unsigned char *fpr;
2612   unsigned char *buffer;
2613   size_t buflen, n;
2614   int i;
2615
2616   assert (keyidx >=0 && keyidx <= 2);
2617
2618   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2619     {
2620       log_error (_("error reading application data\n"));
2621       return gpg_error (GPG_ERR_GENERAL);
2622     }
2623   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2624   if (!fpr || n < 60)
2625     {
2626       log_error (_("error reading fingerprint DO\n"));
2627       xfree (buffer);
2628       return gpg_error (GPG_ERR_GENERAL);
2629     }
2630   fpr += 20*keyidx;
2631   for (i=0; i < 20 && !fpr[i]; i++)
2632     ;
2633   xfree (buffer);
2634   if (i!=20 && !force)
2635     {
2636       log_error (_("key already exists\n"));
2637       return gpg_error (GPG_ERR_EEXIST);
2638     }
2639   else if (i!=20)
2640     log_info (_("existing key will be replaced\n"));
2641   else if (generating)
2642     log_info (_("generating new key\n"));
2643   else
2644     log_info (_("writing new key\n"));
2645   return 0;
2646 }
2647
2648
2649 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2650    of tag and length.  A LENGTH greater than 65535 is truncated. */
2651 static size_t
2652 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2653 {
2654   unsigned char *p = buffer;
2655
2656   assert (tag <= 0xffff);
2657   if ( tag > 0xff )
2658     *p++ = tag >> 8;
2659   *p++ = tag;
2660   if (length < 128)
2661     *p++ = length;
2662   else if (length < 256)
2663     {
2664       *p++ = 0x81;
2665       *p++ = length;
2666     }
2667   else
2668     {
2669       if (length > 0xffff)
2670         length = 0xffff;
2671       *p++ = 0x82;
2672       *p++ = length >> 8;
2673       *p++ = length;
2674     }
2675
2676   return p - buffer;
2677 }
2678
2679
2680 static gpg_error_t
2681 build_privkey_template (app_t app, int keyno,
2682                         const unsigned char *rsa_n, size_t rsa_n_len,
2683                         const unsigned char *rsa_e, size_t rsa_e_len,
2684                         const unsigned char *rsa_p, size_t rsa_p_len,
2685                         const unsigned char *rsa_q, size_t rsa_q_len,
2686                         const unsigned char *rsa_u, size_t rsa_u_len,
2687                         const unsigned char *rsa_dp, size_t rsa_dp_len,
2688                         const unsigned char *rsa_dq, size_t rsa_dq_len,
2689                         unsigned char **result, size_t *resultlen)
2690 {
2691   size_t rsa_e_reqlen;
2692   unsigned char privkey[7*(1+3+3)];
2693   size_t privkey_len;
2694   unsigned char exthdr[2+2+3];
2695   size_t exthdr_len;
2696   unsigned char suffix[2+3];
2697   size_t suffix_len;
2698   unsigned char *tp;
2699   size_t datalen;
2700   unsigned char *template;
2701   size_t template_size;
2702
2703   *result = NULL;
2704   *resultlen = 0;
2705
2706   switch (app->app_local->keyattr[keyno].rsa.format)
2707     {
2708     case RSA_STD:
2709     case RSA_STD_N:
2710     case RSA_CRT:
2711     case RSA_CRT_N:
2712       break;
2713
2714     default:
2715       return gpg_error (GPG_ERR_INV_VALUE);
2716     }
2717
2718   /* Get the required length for E. Rounded up to the nearest byte  */
2719   rsa_e_reqlen = (app->app_local->keyattr[keyno].rsa.e_bits + 7) / 8;
2720   assert (rsa_e_len <= rsa_e_reqlen);
2721
2722   /* Build the 7f48 cardholder private key template.  */
2723   datalen = 0;
2724   tp = privkey;
2725
2726   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2727   datalen += rsa_e_reqlen;
2728
2729   tp += add_tlv (tp, 0x92, rsa_p_len);
2730   datalen += rsa_p_len;
2731
2732   tp += add_tlv (tp, 0x93, rsa_q_len);
2733   datalen += rsa_q_len;
2734
2735   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
2736       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2737     {
2738       tp += add_tlv (tp, 0x94, rsa_u_len);
2739       datalen += rsa_u_len;
2740       tp += add_tlv (tp, 0x95, rsa_dp_len);
2741       datalen += rsa_dp_len;
2742       tp += add_tlv (tp, 0x96, rsa_dq_len);
2743       datalen += rsa_dq_len;
2744     }
2745
2746   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
2747       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2748     {
2749       tp += add_tlv (tp, 0x97, rsa_n_len);
2750       datalen += rsa_n_len;
2751     }
2752   privkey_len = tp - privkey;
2753
2754   /* Build the extended header list without the private key template.  */
2755   tp = exthdr;
2756   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2757   *tp++ = 0;
2758   tp += add_tlv (tp, 0x7f48, privkey_len);
2759   exthdr_len = tp - exthdr;
2760
2761   /* Build the 5f48 suffix of the data.  */
2762   tp = suffix;
2763   tp += add_tlv (tp, 0x5f48, datalen);
2764   suffix_len = tp - suffix;
2765
2766   /* Now concatenate everything.  */
2767   template_size = (1 + 3   /* 0x4d and len. */
2768                    + exthdr_len
2769                    + privkey_len
2770                    + suffix_len
2771                    + datalen);
2772   tp = template = xtrymalloc_secure (template_size);
2773   if (!template)
2774     return gpg_error_from_syserror ();
2775
2776   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2777   memcpy (tp, exthdr, exthdr_len);
2778   tp += exthdr_len;
2779   memcpy (tp, privkey, privkey_len);
2780   tp += privkey_len;
2781   memcpy (tp, suffix, suffix_len);
2782   tp += suffix_len;
2783
2784   memcpy (tp, rsa_e, rsa_e_len);
2785   if (rsa_e_len < rsa_e_reqlen)
2786     {
2787       /* Right justify E. */
2788       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2789       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2790     }
2791   tp += rsa_e_reqlen;
2792
2793   memcpy (tp, rsa_p, rsa_p_len);
2794   tp += rsa_p_len;
2795
2796   memcpy (tp, rsa_q, rsa_q_len);
2797   tp += rsa_q_len;
2798
2799   if (app->app_local->keyattr[keyno].rsa.format == RSA_CRT
2800       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2801     {
2802       memcpy (tp, rsa_u, rsa_u_len);
2803       tp += rsa_u_len;
2804       memcpy (tp, rsa_dp, rsa_dp_len);
2805       tp += rsa_dp_len;
2806       memcpy (tp, rsa_dq, rsa_dq_len);
2807       tp += rsa_dq_len;
2808     }
2809
2810   if (app->app_local->keyattr[keyno].rsa.format == RSA_STD_N
2811       || app->app_local->keyattr[keyno].rsa.format == RSA_CRT_N)
2812     {
2813       memcpy (tp, rsa_n, rsa_n_len);
2814       tp += rsa_n_len;
2815     }
2816
2817   /* Sanity check.  We don't know the exact length because we
2818      allocated 3 bytes for the first length header.  */
2819   assert (tp - template <= template_size);
2820
2821   *result = template;
2822   *resultlen = tp - template;
2823   return 0;
2824 }
2825
2826 static gpg_error_t
2827 build_ecc_privkey_template (app_t app, int keyno,
2828                             const unsigned char *ecc_d, size_t ecc_d_len,
2829                             const unsigned char *ecc_q, size_t ecc_q_len,
2830                             unsigned char **result, size_t *resultlen)
2831 {
2832   unsigned char privkey[2+2];
2833   size_t privkey_len;
2834   unsigned char exthdr[2+2+1];
2835   size_t exthdr_len;
2836   unsigned char suffix[2+1];
2837   size_t suffix_len;
2838   unsigned char *tp;
2839   size_t datalen;
2840   unsigned char *template;
2841   size_t template_size;
2842   int pubkey_required;
2843
2844   pubkey_required = !!(app->app_local->keyattr[keyno].ecc.flags
2845                        & ECC_FLAG_PUBKEY);
2846
2847   *result = NULL;
2848   *resultlen = 0;
2849
2850   /* Build the 7f48 cardholder private key template.  */
2851   datalen = 0;
2852   tp = privkey;
2853
2854   tp += add_tlv (tp, 0x92, ecc_d_len);
2855   datalen += ecc_d_len;
2856
2857   if (pubkey_required)
2858     {
2859       tp += add_tlv (tp, 0x99, ecc_q_len);
2860       datalen += ecc_q_len;
2861     }
2862
2863   privkey_len = tp - privkey;
2864
2865
2866   /* Build the extended header list without the private key template.  */
2867   tp = exthdr;
2868   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2869   *tp++ = 0;
2870   tp += add_tlv (tp, 0x7f48, privkey_len);
2871   exthdr_len = tp - exthdr;
2872
2873   /* Build the 5f48 suffix of the data.  */
2874   tp = suffix;
2875   tp += add_tlv (tp, 0x5f48, datalen);
2876   suffix_len = tp - suffix;
2877
2878   /* Now concatenate everything.  */
2879   template_size = (1 + 1   /* 0x4d and len. */
2880                    + exthdr_len
2881                    + privkey_len
2882                    + suffix_len
2883                    + datalen);
2884   if (exthdr_len + privkey_len + suffix_len + datalen >= 128)
2885     template_size++;
2886   tp = template = xtrymalloc_secure (template_size);
2887   if (!template)
2888     return gpg_error_from_syserror ();
2889
2890   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2891   memcpy (tp, exthdr, exthdr_len);
2892   tp += exthdr_len;
2893   memcpy (tp, privkey, privkey_len);
2894   tp += privkey_len;
2895   memcpy (tp, suffix, suffix_len);
2896   tp += suffix_len;
2897
2898   memcpy (tp, ecc_d, ecc_d_len);
2899   tp += ecc_d_len;
2900
2901   if (pubkey_required)
2902     {
2903       memcpy (tp, ecc_q, ecc_q_len);
2904       tp += ecc_q_len;
2905     }
2906
2907   assert (tp - template == template_size);
2908
2909   *result = template;
2910   *resultlen = tp - template;
2911   return 0;
2912 }
2913
2914
2915 /* Helper for do_writekley to change the size of a key.  Not ethat
2916    this deletes the entire key without asking.  */
2917 static gpg_error_t
2918 change_keyattr (app_t app, int keyno, const unsigned char *buf, size_t buflen,
2919                 gpg_error_t (*pincb)(void*, const char *, char **),
2920                 void *pincb_arg)
2921 {
2922   gpg_error_t err;
2923
2924   assert (keyno >=0 && keyno <= 2);
2925
2926   /* Prepare for storing the key.  */
2927   err = verify_chv3 (app, pincb, pincb_arg);
2928   if (err)
2929     return err;
2930
2931   /* Change the attribute.  */
2932   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buf, buflen);
2933   if (err)
2934     log_error ("error changing key attribute (key=%d)\n", keyno+1);
2935   else
2936     log_info ("key attribute changed (key=%d)\n", keyno+1);
2937   flush_cache (app);
2938   parse_algorithm_attribute (app, keyno);
2939   app->did_chv1 = 0;
2940   app->did_chv2 = 0;
2941   app->did_chv3 = 0;
2942   return err;
2943 }
2944
2945
2946 static gpg_error_t
2947 change_rsa_keyattr (app_t app, int keyno, unsigned int nbits,
2948                     gpg_error_t (*pincb)(void*, const char *, char **),
2949                     void *pincb_arg)
2950 {
2951   gpg_error_t err = 0;
2952   unsigned char *buf;
2953   size_t buflen;
2954   void *relptr;
2955
2956   /* Read the current attributes into a buffer.  */
2957   relptr = get_one_do (app, 0xC1+keyno, &buf, &buflen, NULL);
2958   if (!relptr)
2959     err = gpg_error (GPG_ERR_CARD);
2960   else if (buflen < 6 || buf[0] != PUBKEY_ALGO_RSA)
2961     {
2962       /* Attriutes too short or not an RSA key.  */
2963       xfree (relptr);
2964       err = gpg_error (GPG_ERR_CARD);
2965     }
2966   else
2967     {
2968       /* We only change n_bits and don't touch anything else.  Before we
2969          do so, we round up NBITS to a sensible way in the same way as
2970          gpg's key generation does it.  This may help to sort out problems
2971          with a few bits too short keys.  */
2972       nbits = ((nbits + 31) / 32) * 32;
2973       buf[1] = (nbits >> 8);
2974       buf[2] = nbits;
2975       err = change_keyattr (app, keyno, buf, buflen, pincb, pincb_arg);
2976       xfree (relptr);
2977     }
2978
2979   return err;
2980 }
2981
2982
2983 /* Helper to process an setattr command for name KEY-ATTR.
2984    In (VALUE,VALUELEN), it expects following string:
2985         RSA: "--force <key> <algo> rsa<nbits>"
2986         ECC: "--force <key> <algo> <curvename>"
2987   */
2988 static gpg_error_t
2989 change_keyattr_from_string (app_t app,
2990                             gpg_error_t (*pincb)(void*, const char *, char **),
2991                             void *pincb_arg,
2992                             const void *value, size_t valuelen)
2993 {
2994   gpg_error_t err = 0;
2995   char *string;
2996   int key, keyno, algo;
2997   int n = 0;
2998
2999   /* VALUE is expected to be a string but not guaranteed to be
3000      terminated.  Thus copy it to an allocated buffer first. */
3001   string = xtrymalloc (valuelen+1);
3002   if (!string)
3003     return gpg_error_from_syserror ();
3004   memcpy (string, value, valuelen);
3005   string[valuelen] = 0;
3006
3007   /* Because this function deletes the key we require the string
3008      "--force" in the data to make clear that something serious might
3009      happen.  */
3010   sscanf (string, "--force %d %d %n", &key, &algo, &n);
3011   if (n < 12)
3012     {
3013       err = gpg_error (GPG_ERR_INV_DATA);
3014       goto leave;
3015     }
3016
3017   keyno = key - 1;
3018   if (keyno < 0 || keyno > 2)
3019     err = gpg_error (GPG_ERR_INV_ID);
3020   else if (algo == PUBKEY_ALGO_RSA)
3021     {
3022       unsigned int nbits;
3023
3024       errno = 0;
3025       nbits = strtoul (string+n+3, NULL, 10);
3026       if (errno)
3027         err = gpg_error (GPG_ERR_INV_DATA);
3028       else if (nbits < 1024)
3029         err = gpg_error (GPG_ERR_TOO_SHORT);
3030       else if (nbits > 4096)
3031         err = gpg_error (GPG_ERR_TOO_LARGE);
3032       else
3033         err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3034     }
3035   else if (algo == PUBKEY_ALGO_ECDH || algo == PUBKEY_ALGO_ECDSA
3036            || algo == PUBKEY_ALGO_EDDSA)
3037     {
3038       const char *oidstr;
3039       gcry_mpi_t oid;
3040       const unsigned char *oidbuf;
3041       size_t oid_len;
3042
3043       oidstr = openpgp_curve_to_oid (string+n, NULL);
3044       if (!oidstr)
3045         {
3046           err = gpg_error (GPG_ERR_INV_DATA);
3047           goto leave;
3048         }
3049
3050       err = openpgp_oid_from_str (oidstr, &oid);
3051       if (err)
3052         goto leave;
3053
3054       oidbuf = gcry_mpi_get_opaque (oid, &n);
3055       oid_len = (n+7)/8;
3056
3057       /* We have enough room at STRING.  */
3058       string[0] = algo;
3059       memcpy (string+1, oidbuf+1, oid_len-1);
3060       err = change_keyattr (app, keyno, string, oid_len, pincb, pincb_arg);
3061       gcry_mpi_release (oid);
3062     }
3063   else
3064     err = gpg_error (GPG_ERR_PUBKEY_ALGO);
3065
3066  leave:
3067   xfree (string);
3068   return err;
3069 }
3070
3071
3072 static gpg_error_t
3073 rsa_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3074               void *pincb_arg, int keyno,
3075               const unsigned char *buf, size_t buflen, int depth)
3076 {
3077   gpg_error_t err;
3078   const unsigned char *tok;
3079   size_t toklen;
3080   int last_depth1, last_depth2;
3081   const unsigned char *rsa_n = NULL;
3082   const unsigned char *rsa_e = NULL;
3083   const unsigned char *rsa_p = NULL;
3084   const unsigned char *rsa_q = NULL;
3085   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
3086   unsigned int nbits;
3087   unsigned int maxbits;
3088   unsigned char *template = NULL;
3089   unsigned char *tp;
3090   size_t template_len;
3091   unsigned char fprbuf[20];
3092   u32 created_at = 0;
3093
3094   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
3095     {
3096       log_error (_("unsupported algorithm: %s"), "RSA");
3097       err = gpg_error (GPG_ERR_INV_VALUE);
3098       goto leave;
3099     }
3100
3101   last_depth1 = depth;
3102   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3103          && depth && depth >= last_depth1)
3104     {
3105       if (tok)
3106         {
3107           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3108           goto leave;
3109         }
3110       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3111         goto leave;
3112       if (tok && toklen == 1)
3113         {
3114           const unsigned char **mpi;
3115           size_t *mpi_len;
3116
3117           switch (*tok)
3118             {
3119             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
3120             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
3121             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
3122             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
3123             default: mpi = NULL;  mpi_len = NULL; break;
3124             }
3125           if (mpi && *mpi)
3126             {
3127               err = gpg_error (GPG_ERR_DUP_VALUE);
3128               goto leave;
3129             }
3130           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3131             goto leave;
3132           if (tok && mpi)
3133             {
3134               /* Strip off leading zero bytes and save. */
3135               for (;toklen && !*tok; toklen--, tok++)
3136                 ;
3137               *mpi = tok;
3138               *mpi_len = toklen;
3139             }
3140         }
3141       /* Skip until end of list. */
3142       last_depth2 = depth;
3143       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3144              && depth && depth >= last_depth2)
3145         ;
3146       if (err)
3147         goto leave;
3148     }
3149   /* Parse other attributes. */
3150   last_depth1 = depth;
3151   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3152          && depth && depth >= last_depth1)
3153     {
3154       if (tok)
3155         {
3156           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3157           goto leave;
3158         }
3159       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3160         goto leave;
3161       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3162         {
3163           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3164             goto leave;
3165           if (tok)
3166             {
3167               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3168                    tok++, toklen--)
3169                 created_at = created_at*10 + (*tok - '0');
3170             }
3171         }
3172       /* Skip until end of list. */
3173       last_depth2 = depth;
3174       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3175              && depth && depth >= last_depth2)
3176         ;
3177       if (err)
3178         goto leave;
3179     }
3180
3181
3182   /* Check that we have all parameters and that they match the card
3183      description. */
3184   if (!created_at)
3185     {
3186       log_error (_("creation timestamp missing\n"));
3187       err = gpg_error (GPG_ERR_INV_VALUE);
3188       goto leave;
3189     }
3190
3191   maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3192   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
3193   if (opt.verbose)
3194     log_info ("RSA modulus size is %u bits (%u bytes)\n",
3195               nbits, (unsigned int)rsa_n_len);
3196   if (nbits && nbits != maxbits
3197       && app->app_local->extcap.algo_attr_change)
3198     {
3199       /* Try to switch the key to a new length.  */
3200       err = change_rsa_keyattr (app, keyno, nbits, pincb, pincb_arg);
3201       if (!err)
3202         maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3203     }
3204   if (nbits != maxbits)
3205     {
3206       log_error (_("RSA modulus missing or not of size %d bits\n"),
3207                  (int)maxbits);
3208       err = gpg_error (GPG_ERR_BAD_SECKEY);
3209       goto leave;
3210     }
3211
3212   maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
3213   if (maxbits > 32 && !app->app_local->extcap.is_v2)
3214     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
3215   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
3216   if (nbits < 2 || nbits > maxbits)
3217     {
3218       log_error (_("RSA public exponent missing or larger than %d bits\n"),
3219                  (int)maxbits);
3220       err = gpg_error (GPG_ERR_BAD_SECKEY);
3221       goto leave;
3222     }
3223
3224   maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
3225   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
3226   if (nbits != maxbits)
3227     {
3228       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3229                  "P", (int)maxbits);
3230       err = gpg_error (GPG_ERR_BAD_SECKEY);
3231       goto leave;
3232     }
3233   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
3234   if (nbits != maxbits)
3235     {
3236       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3237                  "Q", (int)maxbits);
3238       err = gpg_error (GPG_ERR_BAD_SECKEY);
3239       goto leave;
3240     }
3241
3242   /* We need to remove the cached public key.  */
3243   xfree (app->app_local->pk[keyno].key);
3244   app->app_local->pk[keyno].key = NULL;
3245   app->app_local->pk[keyno].keylen = 0;
3246   app->app_local->pk[keyno].read_done = 0;
3247
3248
3249   if (app->app_local->extcap.is_v2)
3250     {
3251       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
3252       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
3253       gcry_mpi_t mpi_e, mpi_p, mpi_q;
3254       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
3255       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
3256       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
3257       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
3258       int exmode;
3259
3260       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
3261       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
3262       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
3263       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
3264
3265       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
3266       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
3267       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
3268       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
3269       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
3270
3271       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
3272       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
3273       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
3274
3275       gcry_mpi_release (mpi_e);
3276       gcry_mpi_release (mpi_p);
3277       gcry_mpi_release (mpi_q);
3278       gcry_mpi_release (mpi_u);
3279       gcry_mpi_release (mpi_dp);
3280       gcry_mpi_release (mpi_dq);
3281       gcry_mpi_release (mpi_tmp);
3282
3283       /* Build the private key template as described in section 4.3.3.7 of
3284          the OpenPGP card specs version 2.0.  */
3285       err = build_privkey_template (app, keyno,
3286                                     rsa_n, rsa_n_len,
3287                                     rsa_e, rsa_e_len,
3288                                     rsa_p, rsa_p_len,
3289                                     rsa_q, rsa_q_len,
3290                                     rsa_u, rsa_u_len,
3291                                     rsa_dp, rsa_dp_len,
3292                                     rsa_dq, rsa_dq_len,
3293                                     &template, &template_len);
3294       xfree(rsa_u);
3295       xfree(rsa_dp);
3296       xfree(rsa_dq);
3297
3298       if (err)
3299         goto leave;
3300
3301       /* Prepare for storing the key.  */
3302       err = verify_chv3 (app, pincb, pincb_arg);
3303       if (err)
3304         goto leave;
3305
3306       /* Store the key. */
3307       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3308         exmode = 1;    /* Use extended length w/o a limit.  */
3309       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3310         exmode = -254;
3311       else
3312         exmode = 0;
3313       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3314                                   template, template_len);
3315     }
3316   else
3317     {
3318       /* Build the private key template as described in section 4.3.3.6 of
3319          the OpenPGP card specs version 1.1:
3320          0xC0   <length> public exponent
3321          0xC1   <length> prime p
3322          0xC2   <length> prime q
3323       */
3324       assert (rsa_e_len <= 4);
3325       template_len = (1 + 1 + 4
3326                       + 1 + 1 + rsa_p_len
3327                       + 1 + 1 + rsa_q_len);
3328       template = tp = xtrymalloc_secure (template_len);
3329       if (!template)
3330         {
3331           err = gpg_error_from_syserror ();
3332           goto leave;
3333         }
3334       *tp++ = 0xC0;
3335       *tp++ = 4;
3336       memcpy (tp, rsa_e, rsa_e_len);
3337       if (rsa_e_len < 4)
3338         {
3339           /* Right justify E. */
3340           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
3341           memset (tp, 0, 4-rsa_e_len);
3342         }
3343       tp += 4;
3344
3345       *tp++ = 0xC1;
3346       *tp++ = rsa_p_len;
3347       memcpy (tp, rsa_p, rsa_p_len);
3348       tp += rsa_p_len;
3349
3350       *tp++ = 0xC2;
3351       *tp++ = rsa_q_len;
3352       memcpy (tp, rsa_q, rsa_q_len);
3353       tp += rsa_q_len;
3354
3355       assert (tp - template == template_len);
3356
3357       /* Prepare for storing the key.  */
3358       err = verify_chv3 (app, pincb, pincb_arg);
3359       if (err)
3360         goto leave;
3361
3362       /* Store the key. */
3363       err = iso7816_put_data (app->slot, 0,
3364                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
3365                               template, template_len);
3366     }
3367   if (err)
3368     {
3369       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3370       goto leave;
3371     }
3372
3373   err = store_fpr (app, keyno, created_at, fprbuf, PUBKEY_ALGO_RSA,
3374                    rsa_n, rsa_n_len, rsa_e, rsa_e_len);
3375   if (err)
3376     goto leave;
3377
3378
3379  leave:
3380   xfree (template);
3381   return err;
3382 }
3383
3384
3385 static gpg_error_t
3386 ecc_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3387               void *pincb_arg, int keyno,
3388               const unsigned char *buf, size_t buflen, int depth)
3389 {
3390   gpg_error_t err;
3391   const unsigned char *tok;
3392   size_t toklen;
3393   int last_depth1, last_depth2;
3394   const unsigned char *ecc_q = NULL;
3395   const unsigned char *ecc_d = NULL;
3396   size_t ecc_q_len, ecc_d_len;
3397   const char *curve = NULL;
3398   u32 created_at = 0;
3399   const char *oidstr;
3400   int flag_djb_tweak = 0;
3401   int algo;
3402   gcry_mpi_t oid = NULL;
3403   const unsigned char *oidbuf;
3404   unsigned int n;
3405   size_t oid_len;
3406   unsigned char fprbuf[20];
3407
3408   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3409      curve = "NIST P-256" */
3410   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3411      curve = "secp256k1" */
3412   /* (private-key(ecc(curve%s)(flags eddsa)(q%m)(d%m))(created-at%d)):
3413       curve = "Ed25519" */
3414   last_depth1 = depth;
3415   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3416          && depth && depth >= last_depth1)
3417     {
3418       if (tok)
3419         {
3420           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3421           goto leave;
3422         }
3423       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3424         goto leave;
3425
3426       if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
3427         {
3428           char *curve_name;
3429
3430           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3431             goto leave;
3432
3433           curve_name = xtrymalloc (toklen+1);
3434           if (!curve_name)
3435             {
3436               err = gpg_error_from_syserror ();
3437               goto leave;
3438             }
3439
3440           memcpy (curve_name, tok, toklen);
3441           curve_name[toklen] = 0;
3442           curve = openpgp_is_curve_supported (curve_name, NULL);
3443           xfree (curve_name);
3444         }
3445       else if (tok && toklen == 5 && !memcmp (tok, "flags", 5))
3446         {
3447           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3448             goto leave;
3449
3450           if (tok)
3451             {
3452               if ((toklen == 5 && !memcmp (tok, "eddsa", 5))
3453                   || (toklen == 9 && !memcmp (tok, "djb-tweak", 9)))
3454                 flag_djb_tweak = 1;
3455             }
3456         }
3457       else if (tok && toklen == 1)
3458         {
3459           const unsigned char **buf2;
3460           size_t *buf2len;
3461           int native = flag_djb_tweak;
3462
3463           switch (*tok)
3464             {
3465             case 'q': buf2 = &ecc_q; buf2len = &ecc_q_len; break;
3466             case 'd': buf2 = &ecc_d; buf2len = &ecc_d_len; native = 0; break;
3467             default: buf2 = NULL;  buf2len = NULL; break;
3468             }
3469           if (buf2 && *buf2)
3470             {
3471               err = gpg_error (GPG_ERR_DUP_VALUE);
3472               goto leave;
3473             }
3474           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3475             goto leave;
3476           if (tok && buf2)
3477             {
3478               if (!native)
3479                 /* Strip off leading zero bytes and save. */
3480                 for (;toklen && !*tok; toklen--, tok++)
3481                   ;
3482
3483               *buf2 = tok;
3484               *buf2len = toklen;
3485             }
3486         }
3487       /* Skip until end of list. */
3488       last_depth2 = depth;
3489       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3490              && depth && depth >= last_depth2)
3491         ;
3492       if (err)
3493         goto leave;
3494     }
3495   /* Parse other attributes. */
3496   last_depth1 = depth;
3497   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3498          && depth && depth >= last_depth1)
3499     {
3500       if (tok)
3501         {
3502           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3503           goto leave;
3504         }
3505       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3506         goto leave;
3507       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3508         {
3509           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3510             goto leave;
3511           if (tok)
3512             {
3513               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3514                    tok++, toklen--)
3515                 created_at = created_at*10 + (*tok - '0');
3516             }
3517         }
3518       /* Skip until end of list. */
3519       last_depth2 = depth;
3520       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3521              && depth && depth >= last_depth2)
3522         ;
3523       if (err)
3524         goto leave;
3525     }
3526
3527
3528   /* Check that we have all parameters and that they match the card
3529      description. */
3530   if (!curve)
3531     {
3532       log_error (_("unsupported curve\n"));
3533       err = gpg_error (GPG_ERR_INV_VALUE);
3534       goto leave;
3535     }
3536   if (!created_at)
3537     {
3538       log_error (_("creation timestamp missing\n"));
3539       err = gpg_error (GPG_ERR_INV_VALUE);
3540       goto leave;
3541     }
3542   if (flag_djb_tweak && keyno != 1)
3543     algo = PUBKEY_ALGO_EDDSA;
3544   else if (keyno == 1)
3545     algo = PUBKEY_ALGO_ECDH;
3546   else
3547     algo = PUBKEY_ALGO_ECDSA;
3548
3549   oidstr = openpgp_curve_to_oid (curve, NULL);
3550   err = openpgp_oid_from_str (oidstr, &oid);
3551   if (err)
3552     goto leave;
3553   oidbuf = gcry_mpi_get_opaque (oid, &n);
3554   if (!oidbuf)
3555     {
3556       err = gpg_error_from_syserror ();
3557       goto leave;
3558     }
3559   oid_len = (n+7)/8;
3560
3561   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_ECC
3562       || app->app_local->keyattr[keyno].ecc.curve != curve
3563       || (flag_djb_tweak !=
3564           (app->app_local->keyattr[keyno].ecc.flags & ECC_FLAG_DJB_TWEAK)))
3565     {
3566       if (app->app_local->extcap.algo_attr_change)
3567         {
3568           unsigned char keyattr[oid_len];
3569
3570           keyattr[0] = algo;
3571           memcpy (keyattr+1, oidbuf+1, oid_len-1);
3572           err = change_keyattr (app, keyno, keyattr, oid_len, pincb, pincb_arg);
3573           if (err)
3574             goto leave;
3575         }
3576       else
3577         {
3578           log_error ("key attribute on card doesn't match\n");
3579           err = gpg_error (GPG_ERR_INV_VALUE);
3580           goto leave;
3581         }
3582     }
3583
3584   if (opt.verbose)
3585     log_info ("ECC private key size is %u bytes\n", (unsigned int)ecc_d_len);
3586
3587   /* We need to remove the cached public key.  */
3588   xfree (app->app_local->pk[keyno].key);
3589   app->app_local->pk[keyno].key = NULL;
3590   app->app_local->pk[keyno].keylen = 0;
3591   app->app_local->pk[keyno].read_done = 0;
3592
3593   if (app->app_local->extcap.is_v2)
3594     {
3595       /* Build the private key template as described in section 4.3.3.7 of
3596          the OpenPGP card specs version 2.0.  */
3597       unsigned char *template;
3598       size_t template_len;
3599       int exmode;
3600
3601       err = build_ecc_privkey_template (app, keyno,
3602                                         ecc_d, ecc_d_len,
3603                                         ecc_q, ecc_q_len,
3604                                         &template, &template_len);
3605       if (err)
3606         goto leave;
3607
3608       /* Prepare for storing the key.  */
3609       err = verify_chv3 (app, pincb, pincb_arg);
3610       if (err)
3611         {
3612           xfree (template);
3613           goto leave;
3614         }
3615
3616       /* Store the key. */
3617       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3618         exmode = 1;    /* Use extended length w/o a limit.  */
3619       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3620         exmode = -254;
3621       else
3622         exmode = 0;
3623       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3624                                   template, template_len);
3625       xfree (template);
3626     }
3627   else
3628     err = gpg_error (GPG_ERR_NOT_SUPPORTED);
3629
3630   if (err)
3631     {
3632       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3633       goto leave;
3634     }
3635
3636   err = store_fpr (app, keyno, created_at, fprbuf, algo, oidbuf, oid_len,
3637                    ecc_q, ecc_q_len, ecdh_params (curve), (size_t)4);
3638
3639  leave:
3640   gcry_mpi_release (oid);
3641   return err;
3642 }
3643
3644 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
3645    canonical encoded S-expression with the secret key in KEYDATA and
3646    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
3647    usual keyid which for OpenPGP is the string "OPENPGP.n" with
3648    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
3649    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
3650    the pinentry callback.  */
3651 static gpg_error_t
3652 do_writekey (app_t app, ctrl_t ctrl,
3653              const char *keyid, unsigned int flags,
3654              gpg_error_t (*pincb)(void*, const char *, char **),
3655              void *pincb_arg,
3656              const unsigned char *keydata, size_t keydatalen)
3657 {
3658   gpg_error_t err;
3659   int force = (flags & 1);
3660   int keyno;
3661   const unsigned char *buf, *tok;
3662   size_t buflen, toklen;
3663   int depth;
3664
3665   (void)ctrl;
3666
3667   if (!strcmp (keyid, "OPENPGP.1"))
3668     keyno = 0;
3669   else if (!strcmp (keyid, "OPENPGP.2"))
3670     keyno = 1;
3671   else if (!strcmp (keyid, "OPENPGP.3"))
3672     keyno = 2;
3673   else
3674     return gpg_error (GPG_ERR_INV_ID);
3675
3676   err = does_key_exist (app, keyno, 0, force);
3677   if (err)
3678     return err;
3679
3680
3681   /*
3682      Parse the S-expression
3683    */
3684   buf = keydata;
3685   buflen = keydatalen;
3686   depth = 0;
3687   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3688     goto leave;
3689   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3690     goto leave;
3691   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
3692     {
3693       if (!tok)
3694         ;
3695       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
3696         log_info ("protected-private-key passed to writekey\n");
3697       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
3698         log_info ("shadowed-private-key passed to writekey\n");
3699       err = gpg_error (GPG_ERR_BAD_SECKEY);
3700       goto leave;
3701     }
3702   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3703     goto leave;
3704   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3705     goto leave;
3706   if (tok && toklen == 3 && memcmp ("rsa", tok, toklen) == 0)
3707     err = rsa_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
3708   else if (tok && toklen == 3 && memcmp ("ecc", tok, toklen) == 0)
3709     err = ecc_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
3710   else
3711     {
3712       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
3713       goto leave;
3714     }
3715
3716  leave:
3717   return err;
3718 }
3719
3720
3721
3722 /* Handle the GENKEY command. */
3723 static gpg_error_t
3724 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
3725            time_t createtime,
3726            gpg_error_t (*pincb)(void*, const char *, char **),
3727            void *pincb_arg)
3728 {
3729   gpg_error_t err;
3730   char numbuf[30];
3731   unsigned char *buffer = NULL;
3732   const unsigned char *keydata;
3733   size_t buflen, keydatalen;
3734   u32 created_at;
3735   int keyno = atoi (keynostr) - 1;
3736   int force = (flags & 1);
3737   time_t start_at;
3738   int exmode = 0;
3739   int le_value = 256; /* Use legacy value. */
3740
3741   if (keyno < 0 || keyno > 2)
3742     return gpg_error (GPG_ERR_INV_ID);
3743
3744   /* We flush the cache to increase the traffic before a key
3745      generation.  This _might_ help a card to gather more entropy. */
3746   flush_cache (app);
3747
3748   /* Obviously we need to remove the cached public key.  */
3749   xfree (app->app_local->pk[keyno].key);
3750   app->app_local->pk[keyno].key = NULL;
3751   app->app_local->pk[keyno].keylen = 0;
3752   app->app_local->pk[keyno].read_done = 0;
3753
3754   /* Check whether a key already exists.  */
3755   err = does_key_exist (app, keyno, 1, force);
3756   if (err)
3757     return err;
3758
3759   if (app->app_local->keyattr[keyno].key_type == KEY_TYPE_RSA)
3760     {
3761       unsigned int keybits = app->app_local->keyattr[keyno].rsa.n_bits;
3762
3763       /* Because we send the key parameter back via status lines we need
3764          to put a limit on the max. allowed keysize.  2048 bit will
3765          already lead to a 527 byte long status line and thus a 4096 bit
3766          key would exceed the Assuan line length limit.  */
3767       if (keybits > 4096)
3768         return gpg_error (GPG_ERR_TOO_LARGE);
3769
3770       /* Test whether we will need extended length mode.  (1900 is an
3771          arbitrary length which for sure fits into a short apdu.)  */
3772       if (app->app_local->cardcap.ext_lc_le && keybits > 1900)
3773         {
3774           exmode = 1;    /* Use extended length w/o a limit.  */
3775           le_value = app->app_local->extcap.max_rsp_data;
3776           /* No need to check le_value because it comes from a 16 bit
3777              value and thus can't create an overflow on a 32 bit
3778              system.  */
3779         }
3780     }
3781
3782   /* Prepare for key generation by verifying the Admin PIN.  */
3783   err = verify_chv3 (app, pincb, pincb_arg);
3784   if (err)
3785     return err;
3786
3787
3788   log_info (_("please wait while key is being generated ...\n"));
3789   start_at = time (NULL);
3790   err = iso7816_generate_keypair (app->slot, exmode,
3791                                   (keyno == 0? "\xB6" :
3792                                    keyno == 1? "\xB8" : "\xA4"),
3793                                   2, le_value, &buffer, &buflen);
3794   if (err)
3795     {
3796       log_error (_("generating key failed\n"));
3797       return gpg_error (GPG_ERR_CARD);
3798     }
3799
3800   {
3801     int nsecs = (int)(time (NULL) - start_at);
3802     log_info (ngettext("key generation completed (%d second)\n",
3803                        "key generation completed (%d seconds)\n",
3804                        nsecs), nsecs);
3805   }
3806
3807   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
3808   if (!keydata)
3809     {
3810       err = gpg_error (GPG_ERR_CARD);
3811       log_error (_("response does not contain the public key data\n"));
3812       goto leave;
3813     }
3814
3815   created_at = (u32)(createtime? createtime : gnupg_get_time ());
3816   sprintf (numbuf, "%u", created_at);
3817   send_status_info (ctrl, "KEY-CREATED-AT",
3818                     numbuf, (size_t)strlen(numbuf), NULL, 0);
3819
3820   err = read_public_key (app, ctrl, created_at, keyno, buffer, buflen);
3821  leave:
3822   xfree (buffer);
3823   return err;
3824 }
3825
3826
3827 static unsigned long
3828 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
3829 {
3830   unsigned long ul;
3831
3832   if (valuelen == 3 )
3833     ul = (value[0] << 16) | (value[1] << 8) | value[2];
3834   else
3835     {
3836       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
3837       ul = 0;
3838     }
3839   return ul;
3840 }
3841
3842 static unsigned long
3843 get_sig_counter (app_t app)
3844 {
3845   void *relptr;
3846   unsigned char *value;
3847   size_t valuelen;
3848   unsigned long ul;
3849
3850   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
3851   if (!relptr)
3852     return 0;
3853   ul = convert_sig_counter_value (value, valuelen);
3854   xfree (relptr);
3855   return ul;
3856 }
3857
3858 static gpg_error_t
3859 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
3860 {
3861   const unsigned char *fpr;
3862   unsigned char *buffer;
3863   size_t buflen, n;
3864   int rc, i;
3865
3866   assert (keyno >= 0 && keyno <= 2);
3867
3868   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
3869   if (rc)
3870     {
3871       log_error (_("error reading application data\n"));
3872       return gpg_error (GPG_ERR_GENERAL);
3873     }
3874   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
3875   if (!fpr || n != 60)
3876     {
3877       xfree (buffer);
3878       log_error (_("error reading fingerprint DO\n"));
3879       return gpg_error (GPG_ERR_GENERAL);
3880     }
3881   fpr += keyno*20;
3882   for (i=0; i < 20; i++)
3883     if (sha1fpr[i] != fpr[i])
3884       {
3885         xfree (buffer);
3886         log_info (_("fingerprint on card does not match requested one\n"));
3887         return gpg_error (GPG_ERR_WRONG_SECKEY);
3888       }
3889   xfree (buffer);
3890   return 0;
3891 }
3892
3893
3894 /* If a fingerprint has been specified check it against the one on the
3895    card.  This allows for a meaningful error message in case the key
3896    on the card has been replaced but the shadow information known to
3897    gpg has not been updated.  If there is no fingerprint we assume
3898    that this is okay. */
3899 static gpg_error_t
3900 check_against_given_fingerprint (app_t app, const char *fpr, int key)
3901 {
3902   unsigned char tmp[20];
3903   const char *s;
3904   int n;
3905
3906   for (s=fpr, n=0; hexdigitp (s); s++, n++)
3907     ;
3908   if (n != 40)
3909     return gpg_error (GPG_ERR_INV_ID);
3910   else if (!*s)
3911     ; /* okay */
3912   else
3913     return gpg_error (GPG_ERR_INV_ID);
3914
3915   for (s=fpr, n=0; n < 20; s += 2, n++)
3916         tmp[n] = xtoi_2 (s);
3917   return compare_fingerprint (app, key-1, tmp);
3918 }
3919
3920
3921
3922 /* Compute a digital signature on INDATA which is expected to be the
3923    raw message digest. For this application the KEYIDSTR consists of
3924    the serialnumber and the fingerprint delimited by a slash.
3925
3926    Note that this function may return the error code
3927    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3928    not match the one required for the requested action (e.g. the
3929    serial number does not match).
3930
3931    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
3932    operation to the auth command.
3933 */
3934 static gpg_error_t
3935 do_sign (app_t app, const char *keyidstr, int hashalgo,
3936          gpg_error_t (*pincb)(void*, const char *, char **),
3937          void *pincb_arg,
3938          const void *indata, size_t indatalen,
3939          unsigned char **outdata, size_t *outdatalen )
3940 {
3941   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
3942     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
3943       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
3944   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
3945     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
3946       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
3947   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
3948     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
3949       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
3950       0x1C  };
3951   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
3952     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3953       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
3954       0x00, 0x04, 0x20  };
3955   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
3956     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3957       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
3958       0x00, 0x04, 0x30  };
3959   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
3960     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3961       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
3962       0x00, 0x04, 0x40  };
3963   int rc;
3964   unsigned char data[19+64];
3965   size_t datalen;
3966   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
3967   const char *s;
3968   int n;
3969   const char *fpr = NULL;
3970   unsigned long sigcount;
3971   int use_auth = 0;
3972   int exmode, le_value;
3973
3974   if (!keyidstr || !*keyidstr)
3975     return gpg_error (GPG_ERR_INV_VALUE);
3976
3977   /* Strip off known prefixes.  */
3978 #define X(a,b,c,d) \
3979   if (hashalgo == GCRY_MD_ ## a                               \
3980       && (d)                                                  \
3981       && indatalen == sizeof b ## _prefix + (c)               \
3982       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
3983     {                                                         \
3984       indata = (const char*)indata + sizeof b ## _prefix;     \
3985       indatalen -= sizeof b ## _prefix;                       \
3986     }
3987
3988   if (indatalen == 20)
3989     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
3990   else X(SHA1,   sha1,   20, 1)
3991   else X(RMD160, rmd160, 20, 1)
3992   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
3993   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
3994   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
3995   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
3996   else if ((indatalen == 28 || indatalen == 32
3997             || indatalen == 48 || indatalen ==64)
3998            && app->app_local->extcap.is_v2)
3999     ;  /* Assume a plain SHA-3 digest has been given.  */
4000   else
4001     {
4002       log_error (_("card does not support digest algorithm %s\n"),
4003                  gcry_md_algo_name (hashalgo));
4004       /* Or the supplied digest length does not match an algorithm.  */
4005       return gpg_error (GPG_ERR_INV_VALUE);
4006     }
4007 #undef X
4008
4009   /* Check whether an OpenPGP card of any version has been requested. */
4010   if (!strcmp (keyidstr, "OPENPGP.1"))
4011     ;
4012   else if (!strcmp (keyidstr, "OPENPGP.3"))
4013     use_auth = 1;
4014   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
4015     return gpg_error (GPG_ERR_INV_ID);
4016   else
4017     {
4018       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
4019         ;
4020       if (n != 32)
4021         return gpg_error (GPG_ERR_INV_ID);
4022       else if (!*s)
4023         ; /* no fingerprint given: we allow this for now. */
4024       else if (*s == '/')
4025         fpr = s + 1;
4026       else
4027         return gpg_error (GPG_ERR_INV_ID);
4028
4029       for (s=keyidstr, n=0; n < 16; s += 2, n++)
4030         tmp_sn[n] = xtoi_2 (s);
4031
4032       if (app->serialnolen != 16)
4033         return gpg_error (GPG_ERR_INV_CARD);
4034       if (memcmp (app->serialno, tmp_sn, 16))
4035         return gpg_error (GPG_ERR_WRONG_CARD);
4036     }
4037
4038   /* If a fingerprint has been specified check it against the one on
4039      the card.  This is allows for a meaningful error message in case
4040      the key on the card has been replaced but the shadow information
4041      known to gpg was not updated.  If there is no fingerprint, gpg
4042      will detect a bogus signature anyway due to the
4043      verify-after-signing feature. */
4044   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
4045   if (rc)
4046     return rc;
4047
4048   /* Concatenate prefix and digest.  */
4049 #define X(a,b,d) \
4050   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
4051     {                                                         \
4052       datalen = sizeof b ## _prefix + indatalen;              \
4053       assert (datalen <= sizeof data);                        \
4054       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
4055       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
4056     }
4057
4058   if (use_auth
4059       || app->app_local->keyattr[use_auth? 2: 0].key_type == KEY_TYPE_RSA)
4060     {
4061       X(SHA1,   sha1,   1)
4062       else X(RMD160, rmd160, 1)
4063       else X(SHA224, sha224, app->app_local->extcap.is_v2)
4064       else X(SHA256, sha256, app->app_local->extcap.is_v2)
4065       else X(SHA384, sha384, app->app_local->extcap.is_v2)
4066       else X(SHA512, sha512, app->app_local->extcap.is_v2)
4067       else
4068         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
4069     }
4070   else
4071     {
4072       datalen = indatalen;
4073       memcpy (data, indata, indatalen);
4074     }
4075 #undef X
4076
4077   /* Redirect to the AUTH command if asked to. */
4078   if (use_auth)
4079     {
4080       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
4081                       data, datalen,
4082                       outdata, outdatalen);
4083     }
4084
4085   /* Show the number of signature done using this key.  */
4086   sigcount = get_sig_counter (app);
4087   log_info (_("signatures created so far: %lu\n"), sigcount);
4088
4089   /* Check CHV if needed.  */
4090   if (!app->did_chv1 || app->force_chv1 )
4091     {
4092       char *pinvalue;
4093
4094       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
4095       if (rc)
4096         return rc;
4097
4098       app->did_chv1 = 1;
4099
4100       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
4101          sync, thus we verify CHV2 here using the given PIN.  Cards
4102          with version2 to not have the need for a separate CHV2 and
4103          internally use just one.  Obviously we can't do that if the
4104          pinpad has been used. */
4105       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
4106         {
4107           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
4108           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
4109             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
4110           if (rc)
4111             {
4112               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
4113               xfree (pinvalue);
4114               flush_cache_after_error (app);
4115               return rc;
4116             }
4117           app->did_chv2 = 1;
4118         }
4119       xfree (pinvalue);
4120     }
4121
4122
4123   if (app->app_local->cardcap.ext_lc_le)
4124     {
4125       exmode = 1;    /* Use extended length.  */
4126       le_value = app->app_local->extcap.max_rsp_data;
4127     }
4128   else
4129     {
4130       exmode = 0;
4131       le_value = 0;
4132     }
4133   rc = iso7816_compute_ds (app->slot, exmode, data, datalen, le_value,
4134                            outdata, outdatalen);
4135   return rc;
4136 }
4137
4138 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
4139    on INDATA which is expected to be the raw message digest. For this
4140    application the KEYIDSTR consists of the serialnumber and the
4141    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
4142    be given.
4143
4144    Note that this function may return the error code
4145    GPG_ERR_WRONG_CARD to indicate that the card currently present does
4146    not match the one required for the requested action (e.g. the
4147    serial number does not match). */
4148 static gpg_error_t
4149 do_auth (app_t app, const char *keyidstr,
4150          gpg_error_t (*pincb)(void*, const char *, char **),
4151          void *pincb_arg,
4152          const void *indata, size_t indatalen,
4153          unsigned char **outdata, size_t *outdatalen )
4154 {
4155   int rc;
4156   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
4157   const char *s;
4158   int n;
4159   const char *fpr = NULL;
4160
4161   if (!keyidstr || !*keyidstr)
4162     return gpg_error (GPG_ERR_INV_VALUE);
4163   if (app->app_local->keyattr[2].key_type == KEY_TYPE_RSA
4164       && indatalen > 101) /* For a 2048 bit key. */
4165     return gpg_error (GPG_ERR_INV_VALUE);
4166
4167   if (app->app_local->keyattr[2].key_type == KEY_TYPE_ECC)
4168     {
4169       if (!(app->app_local->keyattr[2].ecc.flags & ECC_FLAG_DJB_TWEAK)
4170           && (indatalen == 51 || indatalen == 67 || indatalen == 83))
4171         {
4172           const char *p = (const char *)indata + 19;
4173           indata = p;
4174           indatalen -= 19;
4175         }
4176       else
4177         {
4178           const char *p = (const char *)indata + 15;
4179           indata = p;
4180           indatalen -= 15;
4181         }
4182     }
4183
4184   /* Check whet