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