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