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