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