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