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