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