scd: Format change to specify "rsa2048" for KEY-ATTR.
[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> rsa<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+3, 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   if (app->app_local->keyattr[keyno].key_type != KEY_TYPE_RSA)
2989     {
2990       log_error (_("unsupported algorithm: %s"), "RSA");
2991       err = gpg_error (GPG_ERR_INV_VALUE);
2992       goto leave;
2993     }
2994
2995   last_depth1 = depth;
2996   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2997          && depth && depth >= last_depth1)
2998     {
2999       if (tok)
3000         {
3001           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3002           goto leave;
3003         }
3004       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3005         goto leave;
3006       if (tok && toklen == 1)
3007         {
3008           const unsigned char **mpi;
3009           size_t *mpi_len;
3010
3011           switch (*tok)
3012             {
3013             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
3014             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
3015             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
3016             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
3017             default: mpi = NULL;  mpi_len = NULL; break;
3018             }
3019           if (mpi && *mpi)
3020             {
3021               err = gpg_error (GPG_ERR_DUP_VALUE);
3022               goto leave;
3023             }
3024           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3025             goto leave;
3026           if (tok && mpi)
3027             {
3028               /* Strip off leading zero bytes and save. */
3029               for (;toklen && !*tok; toklen--, tok++)
3030                 ;
3031               *mpi = tok;
3032               *mpi_len = toklen;
3033             }
3034         }
3035       /* Skip until end of list. */
3036       last_depth2 = depth;
3037       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3038              && depth && depth >= last_depth2)
3039         ;
3040       if (err)
3041         goto leave;
3042     }
3043   /* Parse other attributes. */
3044   last_depth1 = depth;
3045   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3046          && depth && depth >= last_depth1)
3047     {
3048       if (tok)
3049         {
3050           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3051           goto leave;
3052         }
3053       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3054         goto leave;
3055       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3056         {
3057           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3058             goto leave;
3059           if (tok)
3060             {
3061               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3062                    tok++, toklen--)
3063                 created_at = created_at*10 + (*tok - '0');
3064             }
3065         }
3066       /* Skip until end of list. */
3067       last_depth2 = depth;
3068       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3069              && depth && depth >= last_depth2)
3070         ;
3071       if (err)
3072         goto leave;
3073     }
3074
3075
3076   /* Check that we have all parameters and that they match the card
3077      description. */
3078   if (!created_at)
3079     {
3080       log_error (_("creation timestamp missing\n"));
3081       err = gpg_error (GPG_ERR_INV_VALUE);
3082       goto leave;
3083     }
3084
3085   maxbits = app->app_local->keyattr[keyno].rsa.n_bits;
3086   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
3087   if (opt.verbose)
3088     log_info ("RSA modulus size is %u bits (%u bytes)\n",
3089               nbits, (unsigned int)rsa_n_len);
3090   if (nbits != maxbits)
3091     {
3092       log_error (_("RSA modulus missing or not of size %d bits\n"),
3093                  (int)maxbits);
3094       err = gpg_error (GPG_ERR_BAD_SECKEY);
3095       goto leave;
3096     }
3097
3098   maxbits = app->app_local->keyattr[keyno].rsa.e_bits;
3099   if (maxbits > 32 && !app->app_local->extcap.is_v2)
3100     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
3101   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
3102   if (nbits < 2 || nbits > maxbits)
3103     {
3104       log_error (_("RSA public exponent missing or larger than %d bits\n"),
3105                  (int)maxbits);
3106       err = gpg_error (GPG_ERR_BAD_SECKEY);
3107       goto leave;
3108     }
3109
3110   maxbits = app->app_local->keyattr[keyno].rsa.n_bits/2;
3111   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
3112   if (nbits != maxbits)
3113     {
3114       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3115                  "P", (int)maxbits);
3116       err = gpg_error (GPG_ERR_BAD_SECKEY);
3117       goto leave;
3118     }
3119   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
3120   if (nbits != maxbits)
3121     {
3122       log_error (_("RSA prime %s missing or not of size %d bits\n"),
3123                  "Q", (int)maxbits);
3124       err = gpg_error (GPG_ERR_BAD_SECKEY);
3125       goto leave;
3126     }
3127
3128   /* We need to remove the cached public key.  */
3129   xfree (app->app_local->pk[keyno].key);
3130   app->app_local->pk[keyno].key = NULL;
3131   app->app_local->pk[keyno].keylen = 0;
3132   app->app_local->pk[keyno].read_done = 0;
3133
3134
3135   if (app->app_local->extcap.is_v2)
3136     {
3137       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
3138       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
3139       gcry_mpi_t mpi_e, mpi_p, mpi_q;
3140       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
3141       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
3142       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
3143       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
3144       int exmode;
3145
3146       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
3147       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
3148       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
3149       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
3150
3151       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
3152       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
3153       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
3154       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
3155       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
3156
3157       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
3158       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
3159       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
3160
3161       gcry_mpi_release (mpi_e);
3162       gcry_mpi_release (mpi_p);
3163       gcry_mpi_release (mpi_q);
3164       gcry_mpi_release (mpi_u);
3165       gcry_mpi_release (mpi_dp);
3166       gcry_mpi_release (mpi_dq);
3167       gcry_mpi_release (mpi_tmp);
3168
3169       /* Build the private key template as described in section 4.3.3.7 of
3170          the OpenPGP card specs version 2.0.  */
3171       err = build_privkey_template (app, keyno,
3172                                     rsa_n, rsa_n_len,
3173                                     rsa_e, rsa_e_len,
3174                                     rsa_p, rsa_p_len,
3175                                     rsa_q, rsa_q_len,
3176                                     rsa_u, rsa_u_len,
3177                                     rsa_dp, rsa_dp_len,
3178                                     rsa_dq, rsa_dq_len,
3179                                     &template, &template_len);
3180       xfree(rsa_u);
3181       xfree(rsa_dp);
3182       xfree(rsa_dq);
3183
3184       if (err)
3185         goto leave;
3186
3187       /* Prepare for storing the key.  */
3188       err = verify_chv3 (app, pincb, pincb_arg);
3189       if (err)
3190         goto leave;
3191
3192       /* Store the key. */
3193       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3194         exmode = 1;    /* Use extended length w/o a limit.  */
3195       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3196         exmode = -254;
3197       else
3198         exmode = 0;
3199       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3200                                   template, template_len);
3201     }
3202   else
3203     {
3204       /* Build the private key template as described in section 4.3.3.6 of
3205          the OpenPGP card specs version 1.1:
3206          0xC0   <length> public exponent
3207          0xC1   <length> prime p
3208          0xC2   <length> prime q
3209       */
3210       assert (rsa_e_len <= 4);
3211       template_len = (1 + 1 + 4
3212                       + 1 + 1 + rsa_p_len
3213                       + 1 + 1 + rsa_q_len);
3214       template = tp = xtrymalloc_secure (template_len);
3215       if (!template)
3216         {
3217           err = gpg_error_from_syserror ();
3218           goto leave;
3219         }
3220       *tp++ = 0xC0;
3221       *tp++ = 4;
3222       memcpy (tp, rsa_e, rsa_e_len);
3223       if (rsa_e_len < 4)
3224         {
3225           /* Right justify E. */
3226           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
3227           memset (tp, 0, 4-rsa_e_len);
3228         }
3229       tp += 4;
3230
3231       *tp++ = 0xC1;
3232       *tp++ = rsa_p_len;
3233       memcpy (tp, rsa_p, rsa_p_len);
3234       tp += rsa_p_len;
3235
3236       *tp++ = 0xC2;
3237       *tp++ = rsa_q_len;
3238       memcpy (tp, rsa_q, rsa_q_len);
3239       tp += rsa_q_len;
3240
3241       assert (tp - template == template_len);
3242
3243       /* Prepare for storing the key.  */
3244       err = verify_chv3 (app, pincb, pincb_arg);
3245       if (err)
3246         goto leave;
3247
3248       /* Store the key. */
3249       err = iso7816_put_data (app->slot, 0,
3250                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
3251                               template, template_len);
3252     }
3253   if (err)
3254     {
3255       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3256       goto leave;
3257     }
3258
3259   err = store_fpr (app, keyno, created_at, fprbuf, KEY_TYPE_RSA,
3260                    rsa_n, rsa_n_len, rsa_e, rsa_e_len);
3261   if (err)
3262     goto leave;
3263
3264
3265  leave:
3266   xfree (template);
3267   return err;
3268 }
3269
3270
3271 static gpg_error_t
3272 ecc_writekey (app_t app, gpg_error_t (*pincb)(void*, const char *, char **),
3273               void *pincb_arg, int keyno,
3274               const unsigned char *buf, size_t buflen, int depth)
3275 {
3276   gpg_error_t err;
3277   const unsigned char *tok;
3278   size_t toklen;
3279   int last_depth1, last_depth2;
3280   const unsigned char *ecc_q = NULL;
3281   const unsigned char *ecc_d = NULL;
3282   size_t ecc_q_len, ecc_d_len;
3283   unsigned char *template = NULL;
3284   size_t template_len;
3285   unsigned char fprbuf[20];
3286   u32 created_at = 0;
3287   int curve = CURVE_UNKNOWN;
3288
3289   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3290      curve = "NIST P-256" */
3291   /* (private-key(ecc(curve%s)(q%m)(d%m))(created-at%d)):
3292      curve = "secp256k1" */
3293   /* (private-key(ecc(curve%s)(flags eddsa)(q%m)(d%m))(created-at%d)):
3294       curve = "Ed25519" */
3295   last_depth1 = depth;
3296   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3297          && depth && depth >= last_depth1)
3298     {
3299       if (tok)
3300         {
3301           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3302           goto leave;
3303         }
3304       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3305         goto leave;
3306
3307       if (tok && toklen == 5 && !memcmp (tok, "curve", 5))
3308         {
3309           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3310             goto leave;
3311
3312           if (tok && toklen == 10 && !memcmp (tok, "NIST P-256", 10))
3313             curve = CURVE_NIST_P256;
3314           else if (tok && toklen == 9 && !memcmp (tok, "secp256k1", 9))
3315             curve = CURVE_SEC_P256K1;
3316           else if (tok && toklen == 7 && !memcmp (tok, "Ed25519", 7))
3317             curve = CURVE_ED25519;
3318           else
3319             {
3320               log_error (_("unsupported curve\n"));
3321               err = gpg_error (GPG_ERR_INV_VALUE);
3322               goto leave;
3323             }
3324         }
3325       else if (tok && toklen == 1)
3326         {
3327           const unsigned char **buf2;
3328           size_t *buf2len;
3329
3330           switch (*tok)
3331             {
3332             case 'q': buf2 = &ecc_q; buf2len = &ecc_q_len; break;
3333             case 'd': buf2 = &ecc_d; buf2len = &ecc_d_len; break;
3334             default: buf2 = NULL;  buf2len = NULL; break;
3335             }
3336           if (buf2 && *buf2)
3337             {
3338               err = gpg_error (GPG_ERR_DUP_VALUE);
3339               goto leave;
3340             }
3341           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3342             goto leave;
3343           if (tok && buf2 && curve != CURVE_ED25519)
3344             /* It's MPI.  Strip off leading zero bytes and save. */
3345             for (;toklen && !*tok; toklen--, tok++)
3346               ;
3347
3348           *buf2 = tok;
3349           *buf2len = toklen;
3350         }
3351       /* Skip until end of list. */
3352       last_depth2 = depth;
3353       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3354              && depth && depth >= last_depth2)
3355         ;
3356       if (err)
3357         goto leave;
3358     }
3359   /* Parse other attributes. */
3360   last_depth1 = depth;
3361   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3362          && depth && depth >= last_depth1)
3363     {
3364       if (tok)
3365         {
3366           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
3367           goto leave;
3368         }
3369       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3370         goto leave;
3371       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
3372         {
3373           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
3374             goto leave;
3375           if (tok)
3376             {
3377               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
3378                    tok++, toklen--)
3379                 created_at = created_at*10 + (*tok - '0');
3380             }
3381         }
3382       /* Skip until end of list. */
3383       last_depth2 = depth;
3384       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
3385              && depth && depth >= last_depth2)
3386         ;
3387       if (err)
3388         goto leave;
3389     }
3390
3391
3392   /* Check that we have all parameters and that they match the card
3393      description. */
3394   if (!created_at)
3395     {
3396       log_error (_("creation timestamp missing\n"));
3397       err = gpg_error (GPG_ERR_INV_VALUE);
3398       goto leave;
3399     }
3400
3401   if (opt.verbose)
3402     log_info ("ECC private key size is %u bytes\n", (unsigned int)ecc_d_len);
3403
3404   /* We need to remove the cached public key.  */
3405   xfree (app->app_local->pk[keyno].key);
3406   app->app_local->pk[keyno].key = NULL;
3407   app->app_local->pk[keyno].keylen = 0;
3408   app->app_local->pk[keyno].read_done = 0;
3409
3410   if (app->app_local->extcap.is_v2)
3411     {
3412       /* Build the private key template as described in section 4.3.3.7 of
3413          the OpenPGP card specs version 2.0.  */
3414       int exmode;
3415
3416       err = build_ecc_privkey_template (app, keyno,
3417                                         ecc_d, ecc_d_len,
3418                                         &template, &template_len);
3419       if (err)
3420         goto leave;
3421
3422       /* Prepare for storing the key.  */
3423       err = verify_chv3 (app, pincb, pincb_arg);
3424       if (err)
3425         goto leave;
3426
3427       /* Store the key. */
3428       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
3429         exmode = 1;    /* Use extended length w/o a limit.  */
3430       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
3431         exmode = -254;
3432       else
3433         exmode = 0;
3434       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
3435                                   template, template_len);
3436     }
3437   else
3438     return gpg_error (GPG_ERR_NOT_SUPPORTED);
3439
3440   if (err)
3441     {
3442       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
3443       goto leave;
3444     }
3445
3446   err = store_fpr (app, keyno, created_at, fprbuf,
3447                    curve == CURVE_ED25519 ? KEY_TYPE_EDDSA : KEY_TYPE_ECC,
3448                    curve == CURVE_ED25519 ?
3449                    "\x09\x2b\x06\x01\x04\x01\xda\x47\x0f\x01"
3450                    : curve == CURVE_NIST_P256 ?
3451                    "\x08\x2a\x86\x48\xce\x3d\x03\x01\x07"
3452                    : "\x05\x2b\x81\x04\x00\x0a",
3453                    (size_t)(curve == CURVE_ED25519 ? 10
3454                             : curve == CURVE_NIST_P256? 9 : 6),
3455                    ecc_q, ecc_q_len, "\x03\x01\x08\x07", (size_t)4);
3456   if (err)
3457     goto leave;
3458
3459
3460  leave:
3461   xfree (template);
3462   return err;
3463 }
3464
3465 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
3466    canonical encoded S-expression with the secret key in KEYDATA and
3467    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
3468    usual keyid which for OpenPGP is the string "OPENPGP.n" with
3469    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
3470    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
3471    the pinentry callback.  */
3472 static gpg_error_t
3473 do_writekey (app_t app, ctrl_t ctrl,
3474              const char *keyid, unsigned int flags,
3475              gpg_error_t (*pincb)(void*, const char *, char **),
3476              void *pincb_arg,
3477              const unsigned char *keydata, size_t keydatalen)
3478 {
3479   gpg_error_t err;
3480   int force = (flags & 1);
3481   int keyno;
3482   const unsigned char *buf, *tok;
3483   size_t buflen, toklen;
3484   int depth;
3485
3486   (void)ctrl;
3487
3488   if (!strcmp (keyid, "OPENPGP.1"))
3489     keyno = 0;
3490   else if (!strcmp (keyid, "OPENPGP.2"))
3491     keyno = 1;
3492   else if (!strcmp (keyid, "OPENPGP.3"))
3493     keyno = 2;
3494   else
3495     return gpg_error (GPG_ERR_INV_ID);
3496
3497   err = does_key_exist (app, keyno, 0, force);
3498   if (err)
3499     return err;
3500
3501
3502   /*
3503      Parse the S-expression
3504    */
3505   buf = keydata;
3506   buflen = keydatalen;
3507   depth = 0;
3508   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3509     goto leave;
3510   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3511     goto leave;
3512   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
3513     {
3514       if (!tok)
3515         ;
3516       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
3517         log_info ("protected-private-key passed to writekey\n");
3518       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
3519         log_info ("shadowed-private-key passed to writekey\n");
3520       err = gpg_error (GPG_ERR_BAD_SECKEY);
3521       goto leave;
3522     }
3523   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3524     goto leave;
3525   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
3526     goto leave;
3527   if (tok && toklen == 3 && memcmp ("rsa", tok, toklen) == 0)
3528     err = rsa_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
3529   else if (tok && toklen == 3 && memcmp ("ecc", tok, toklen) == 0)
3530     err = ecc_writekey (app, pincb, pincb_arg, keyno, buf, buflen, depth);
3531   else
3532     {
3533       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
3534       goto leave;
3535     }
3536
3537  leave:
3538   return err;
3539 }
3540
3541
3542
3543 /* Handle the GENKEY command. */
3544 static gpg_error_t
3545 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
3546            time_t createtime,
3547            gpg_error_t (*pincb)(void*, const char *, char **),
3548            void *pincb_arg)
3549 {
3550   int rc;
3551   char numbuf[30];
3552   unsigned char fprbuf[20];
3553   const unsigned char *keydata, *m, *e;
3554   unsigned char *buffer = NULL;
3555   size_t buflen, keydatalen, mlen, elen;
3556   time_t created_at;
3557   int keyno = atoi (keynostr);
3558   int force = (flags & 1);
3559   time_t start_at;
3560   int exmode;
3561   int le_value;
3562   unsigned int keybits;
3563
3564   if (keyno < 1 || keyno > 3)
3565     return gpg_error (GPG_ERR_INV_ID);
3566   keyno--;
3567
3568   /* We flush the cache to increase the traffic before a key
3569      generation.  This _might_ help a card to gather more entropy. */
3570   flush_cache (app);
3571
3572   /* Obviously we need to remove the cached public key.  */
3573   xfree (app->app_local->pk[keyno].key);
3574   app->app_local->pk[keyno].key = NULL;
3575   app->app_local->pk[keyno].keylen = 0;
3576   app->app_local->pk[keyno].read_done = 0;
3577
3578   /* Check whether a key already exists.  */
3579   rc = does_key_exist (app, keyno, 1, force);
3580   if (rc)
3581     return rc;
3582
3583   /* Because we send the key parameter back via status lines we need
3584      to put a limit on the max. allowed keysize.  2048 bit will
3585      already lead to a 527 byte long status line and thus a 4096 bit
3586      key would exceed the Assuan line length limit.  */
3587   keybits = app->app_local->keyattr[keyno].rsa.n_bits;
3588   if (keybits > 4096)
3589     return gpg_error (GPG_ERR_TOO_LARGE);
3590
3591   /* Prepare for key generation by verifying the Admin PIN.  */
3592   rc = verify_chv3 (app, pincb, pincb_arg);
3593   if (rc)
3594     goto leave;
3595
3596   /* Test whether we will need extended length mode.  (1900 is an
3597      arbitrary length which for sure fits into a short apdu.)  */
3598   if (app->app_local->cardcap.ext_lc_le && keybits > 1900)
3599     {
3600       exmode = 1;    /* Use extended length w/o a limit.  */
3601       le_value = app->app_local->extcap.max_rsp_data;
3602       /* No need to check le_value because it comes from a 16 bit
3603          value and thus can't create an overflow on a 32 bit
3604          system.  */
3605     }
3606   else
3607     {
3608       exmode = 0;
3609       le_value = 256; /* Use legacy value. */
3610     }
3611
3612   log_info (_("please wait while key is being generated ...\n"));
3613   start_at = time (NULL);
3614   rc = iso7816_generate_keypair
3615 /* # warning key generation temporary replaced by reading an existing key. */
3616 /*   rc = iso7816_read_public_key */
3617     (app->slot, exmode,
3618      (const unsigned char*)(keyno == 0? "\xB6" :
3619                             keyno == 1? "\xB8" : "\xA4"), 2,
3620      le_value,
3621      &buffer, &buflen);
3622   if (rc)
3623     {
3624       rc = gpg_error (GPG_ERR_CARD);
3625       log_error (_("generating key failed\n"));
3626       goto leave;
3627     }
3628   log_info (_("key generation completed (%d seconds)\n"),
3629             (int)(time (NULL) - start_at));
3630
3631   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
3632   if (!keydata)
3633     {
3634       rc = gpg_error (GPG_ERR_CARD);
3635       log_error (_("response does not contain the public key data\n"));
3636       goto leave;
3637     }
3638
3639   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
3640   if (!m)
3641     {
3642       rc = gpg_error (GPG_ERR_CARD);
3643       log_error (_("response does not contain the RSA modulus\n"));
3644       goto leave;
3645     }
3646   /* log_printhex ("RSA n:", m, mlen); */
3647   send_key_data (ctrl, "n", m, mlen);
3648
3649   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
3650   if (!e)
3651     {
3652       rc = gpg_error (GPG_ERR_CARD);
3653       log_error (_("response does not contain the RSA public exponent\n"));
3654       goto leave;
3655     }
3656   /* log_printhex ("RSA e:", e, elen); */
3657   send_key_data (ctrl, "e", e, elen);
3658
3659   created_at = createtime? createtime : gnupg_get_time ();
3660   sprintf (numbuf, "%lu", (unsigned long)created_at);
3661   send_status_info (ctrl, "KEY-CREATED-AT",
3662                     numbuf, (size_t)strlen(numbuf), NULL, 0);
3663
3664   rc = store_fpr (app, keyno, (u32)created_at, fprbuf, KEY_TYPE_RSA,
3665                   m, mlen, e, elen);
3666   if (rc)
3667     goto leave;
3668   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
3669
3670
3671  leave:
3672   xfree (buffer);
3673   return rc;
3674 }
3675
3676
3677 static unsigned long
3678 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
3679 {
3680   unsigned long ul;
3681
3682   if (valuelen == 3 )
3683     ul = (value[0] << 16) | (value[1] << 8) | value[2];
3684   else
3685     {
3686       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
3687       ul = 0;
3688     }
3689   return ul;
3690 }
3691
3692 static unsigned long
3693 get_sig_counter (app_t app)
3694 {
3695   void *relptr;
3696   unsigned char *value;
3697   size_t valuelen;
3698   unsigned long ul;
3699
3700   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
3701   if (!relptr)
3702     return 0;
3703   ul = convert_sig_counter_value (value, valuelen);
3704   xfree (relptr);
3705   return ul;
3706 }
3707
3708 static gpg_error_t
3709 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
3710 {
3711   const unsigned char *fpr;
3712   unsigned char *buffer;
3713   size_t buflen, n;
3714   int rc, i;
3715
3716   assert (keyno >= 1 && keyno <= 3);
3717
3718   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
3719   if (rc)
3720     {
3721       log_error (_("error reading application data\n"));
3722       return gpg_error (GPG_ERR_GENERAL);
3723     }
3724   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
3725   if (!fpr || n != 60)
3726     {
3727       xfree (buffer);
3728       log_error (_("error reading fingerprint DO\n"));
3729       return gpg_error (GPG_ERR_GENERAL);
3730     }
3731   fpr += (keyno-1)*20;
3732   for (i=0; i < 20; i++)
3733     if (sha1fpr[i] != fpr[i])
3734       {
3735         xfree (buffer);
3736         log_info (_("fingerprint on card does not match requested one\n"));
3737         return gpg_error (GPG_ERR_WRONG_SECKEY);
3738       }
3739   xfree (buffer);
3740   return 0;
3741 }
3742
3743
3744 /* If a fingerprint has been specified check it against the one on the
3745    card.  This allows for a meaningful error message in case the key
3746    on the card has been replaced but the shadow information known to
3747    gpg has not been updated.  If there is no fingerprint we assume
3748    that this is okay. */
3749 static gpg_error_t
3750 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
3751 {
3752   unsigned char tmp[20];
3753   const char *s;
3754   int n;
3755
3756   for (s=fpr, n=0; hexdigitp (s); s++, n++)
3757     ;
3758   if (n != 40)
3759     return gpg_error (GPG_ERR_INV_ID);
3760   else if (!*s)
3761     ; /* okay */
3762   else
3763     return gpg_error (GPG_ERR_INV_ID);
3764
3765   for (s=fpr, n=0; n < 20; s += 2, n++)
3766         tmp[n] = xtoi_2 (s);
3767   return compare_fingerprint (app, keyno, tmp);
3768 }
3769
3770
3771
3772 /* Compute a digital signature on INDATA which is expected to be the
3773    raw message digest. For this application the KEYIDSTR consists of
3774    the serialnumber and the fingerprint delimited by a slash.
3775
3776    Note that this function may return the error code
3777    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3778    not match the one required for the requested action (e.g. the
3779    serial number does not match).
3780
3781    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
3782    operation to the auth command.
3783 */
3784 static gpg_error_t
3785 do_sign (app_t app, const char *keyidstr, int hashalgo,
3786          gpg_error_t (*pincb)(void*, const char *, char **),
3787          void *pincb_arg,
3788          const void *indata, size_t indatalen,
3789          unsigned char **outdata, size_t *outdatalen )
3790 {
3791   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
3792     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
3793       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
3794   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
3795     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
3796       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
3797   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
3798     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
3799       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
3800       0x1C  };
3801   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
3802     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3803       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
3804       0x00, 0x04, 0x20  };
3805   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
3806     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3807       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
3808       0x00, 0x04, 0x30  };
3809   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
3810     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3811       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
3812       0x00, 0x04, 0x40  };
3813   int rc;
3814   unsigned char data[19+64];
3815   size_t datalen;
3816   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
3817   const char *s;
3818   int n;
3819   const char *fpr = NULL;
3820   unsigned long sigcount;
3821   int use_auth = 0;
3822   int exmode, le_value;
3823
3824   if (!keyidstr || !*keyidstr)
3825     return gpg_error (GPG_ERR_INV_VALUE);
3826
3827   /* Strip off known prefixes.  */
3828 #define X(a,b,c,d) \
3829   if (hashalgo == GCRY_MD_ ## a                               \
3830       && (d)                                                  \
3831       && indatalen == sizeof b ## _prefix + (c)               \
3832       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
3833     {                                                         \
3834       indata = (const char*)indata + sizeof b ## _prefix;     \
3835       indatalen -= sizeof b ## _prefix;                       \
3836     }
3837
3838   if (indatalen == 20)
3839     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
3840   else X(SHA1,   sha1,   20, 1)
3841   else X(RMD160, rmd160, 20, 1)
3842   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
3843   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
3844   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
3845   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
3846   else if ((indatalen == 28 || indatalen == 32
3847             || indatalen == 48 || indatalen ==64)
3848            && app->app_local->extcap.is_v2)
3849     ;  /* Assume a plain SHA-3 digest has been given.  */
3850   else
3851     {
3852       log_error (_("card does not support digest algorithm %s\n"),
3853                  gcry_md_algo_name (hashalgo));
3854       /* Or the supplied digest length does not match an algorithm.  */
3855       return gpg_error (GPG_ERR_INV_VALUE);
3856     }
3857 #undef X
3858
3859   /* Check whether an OpenPGP card of any version has been requested. */
3860   if (!strcmp (keyidstr, "OPENPGP.1"))
3861     ;
3862   else if (!strcmp (keyidstr, "OPENPGP.3"))
3863     use_auth = 1;
3864   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3865     return gpg_error (GPG_ERR_INV_ID);
3866   else
3867     {
3868       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3869         ;
3870       if (n != 32)
3871         return gpg_error (GPG_ERR_INV_ID);
3872       else if (!*s)
3873         ; /* no fingerprint given: we allow this for now. */
3874       else if (*s == '/')
3875         fpr = s + 1;
3876       else
3877         return gpg_error (GPG_ERR_INV_ID);
3878
3879       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3880         tmp_sn[n] = xtoi_2 (s);
3881
3882       if (app->serialnolen != 16)
3883         return gpg_error (GPG_ERR_INV_CARD);
3884       if (memcmp (app->serialno, tmp_sn, 16))
3885         return gpg_error (GPG_ERR_WRONG_CARD);
3886     }
3887
3888   /* If a fingerprint has been specified check it against the one on
3889      the card.  This is allows for a meaningful error message in case
3890      the key on the card has been replaced but the shadow information
3891      known to gpg was not updated.  If there is no fingerprint, gpg
3892      will detect a bogus signature anyway due to the
3893      verify-after-signing feature. */
3894   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
3895   if (rc)
3896     return rc;
3897
3898   /* Concatenate prefix and digest.  */
3899 #define X(a,b,d) \
3900   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
3901     {                                                         \
3902       datalen = sizeof b ## _prefix + indatalen;              \
3903       assert (datalen <= sizeof data);                        \
3904       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
3905       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
3906     }
3907
3908   if (use_auth
3909       || app->app_local->keyattr[use_auth? 2: 0].key_type == KEY_TYPE_RSA)
3910     {
3911       X(SHA1,   sha1,   1)
3912       else X(RMD160, rmd160, 1)
3913       else X(SHA224, sha224, app->app_local->extcap.is_v2)
3914       else X(SHA256, sha256, app->app_local->extcap.is_v2)
3915       else X(SHA384, sha384, app->app_local->extcap.is_v2)
3916       else X(SHA512, sha512, app->app_local->extcap.is_v2)
3917       else
3918         return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3919     }
3920   else
3921     {
3922       datalen = indatalen;
3923       memcpy (data, indata, indatalen);
3924     }
3925 #undef X
3926
3927   /* Redirect to the AUTH command if asked to. */
3928   if (use_auth)
3929     {
3930       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
3931                       data, datalen,
3932                       outdata, outdatalen);
3933     }
3934
3935   /* Show the number of signature done using this key.  */
3936   sigcount = get_sig_counter (app);
3937   log_info (_("signatures created so far: %lu\n"), sigcount);
3938
3939   /* Check CHV if needed.  */
3940   if (!app->did_chv1 || app->force_chv1 )
3941     {
3942       char *pinvalue;
3943
3944       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
3945       if (rc)
3946         return rc;
3947
3948       app->did_chv1 = 1;
3949
3950       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
3951          sync, thus we verify CHV2 here using the given PIN.  Cards
3952          with version2 to not have the need for a separate CHV2 and
3953          internally use just one.  Obviously we can't do that if the
3954          pinpad has been used. */
3955       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
3956         {
3957           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
3958           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
3959             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
3960           if (rc)
3961             {
3962               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
3963               xfree (pinvalue);
3964               flush_cache_after_error (app);
3965               return rc;
3966             }
3967           app->did_chv2 = 1;
3968         }
3969       xfree (pinvalue);
3970     }
3971
3972
3973   if (app->app_local->cardcap.ext_lc_le)
3974     {
3975       exmode = 1;    /* Use extended length.  */
3976       le_value = app->app_local->extcap.max_rsp_data;
3977     }
3978   else
3979     {
3980       exmode = 0;
3981       le_value = 0;
3982     }
3983   rc = iso7816_compute_ds (app->slot, exmode, data, datalen, le_value,
3984                            outdata, outdatalen);
3985   return rc;
3986 }
3987
3988 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
3989    on INDATA which is expected to be the raw message digest. For this
3990    application the KEYIDSTR consists of the serialnumber and the
3991    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
3992    be given.
3993
3994    Note that this function may return the error code
3995    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3996    not match the one required for the requested action (e.g. the
3997    serial number does not match). */
3998 static gpg_error_t
3999 do_auth (app_t app, const char *keyidstr,
4000          gpg_error_t (*pincb)(void*, const char *, char **),
4001          void *pincb_arg,
4002          const void *indata, size_t indatalen,
4003          unsigned char **outdata, size_t *outdatalen )
4004 {
4005   int rc;
4006   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
4007   const char *s;
4008   int n;
4009   const char *fpr = NULL;
4010
4011   if (!keyidstr || !*keyidstr)
4012     return gpg_error (GPG_ERR_INV_VALUE);
4013   if (app->app_local->keyattr[2].key_type == KEY_TYPE_RSA
4014       && indatalen > 101) /* For a 2048 bit key. */
4015     return gpg_error (GPG_ERR_INV_VALUE);
4016
4017   if (app->app_local->keyattr[2].key_type == KEY_TYPE_ECC
4018       && (indatalen == 51 || indatalen == 67 || indatalen == 83))
4019     {
4020       const char *p = (const char *)indata + 19;
4021       indata = p;
4022       indatalen -= 19;
4023     }
4024   else if (app->app_local->keyattr[2].key_type == KEY_TYPE_EDDSA)
4025     {
4026       const char *p = (const char *)indata + 15;
4027       indata = p;
4028       indatalen -= 15;
4029     }
4030
4031   /* Check whether an OpenPGP card of any version has been requested. */
4032   if (!strcmp (keyidstr, "OPENPGP.3"))
4033     ;
4034   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
4035     return gpg_error (GPG_ERR_INV_ID);
4036   else
4037     {
4038       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
4039         ;
4040       if (n != 32)
4041         return gpg_error (GPG_ERR_INV_ID);
4042       else if (!*s)
4043         ; /* no fingerprint given: we allow this for now. */
4044       else if (*s == '/')
4045         fpr = s + 1;
4046       else
4047         return gpg_error (GPG_ERR_INV_ID);
4048
4049       for (s=keyidstr, n=0; n < 16; s += 2, n++)
4050         tmp_sn[n] = xtoi_2 (s);
4051
4052       if (app->serialnolen != 16)
4053         return gpg_error (GPG_ERR_INV_CARD);
4054       if (memcmp (app->serialno, tmp_sn, 16))
4055         return gpg_error (GPG_ERR_WRONG_CARD);
4056     }
4057
4058   /* If a fingerprint has been specified check it against the one on
4059      the card.  This is allows for a meaningful error message in case
4060      the key on the card has been replaced but the shadow information
4061      known to gpg was not updated.  If there is no fingerprint, gpg
4062      will detect a bogus signature anyway due to the
4063      verify-after-signing feature. */
4064   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
4065   if (rc)
4066     return rc;
4067
4068   rc = verify_chv2 (app, pincb, pincb_arg);
4069   if (!rc)
4070     {
4071       int exmode, le_value;
4072
4073       if (app->app_local->cardcap.ext_lc_le)
4074         {
4075           exmode = 1;    /* Use extended length.  */
4076           le_value = app->app_local->extcap.max_rsp_data;
4077         }
4078       else
4079         {
4080           exmode = 0;
4081           le_value = 0;
4082         }
4083       rc = iso7816_internal_authenticate (app->slot, exmode,
4084                                           indata, indatalen, le_value,
4085                                           outdata, outdatalen);
4086     }
4087   return rc;
4088 }
4089
4090
4091 static gpg_error_t
4092 do_decipher (app_t app, const char *keyidstr,
4093              gpg_error_t (*pincb)(void*, const char *, char **),
4094              void *pincb_arg,
4095              const void *indata, size_t indatalen,
4096              unsigned char **outdata, size_t *outdatalen,
4097              unsigned int *r_info)
4098 {
4099   int rc;
4100   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
4101   const char *s;
4102   int n;
4103   const char *fpr = NULL;
4104   int exmode, le_value;
4105   unsigned char *fixbuf = NULL;
4106   int padind = 0;
4107   int fixuplen = 0;
4108
4109   if (!keyidstr || !*keyidstr || !indatalen)
4110     return gpg_error (GPG_ERR_INV_VALUE);
4111
4112   /* Check whether an OpenPGP card of any version has been requested. */
4113   if (!strcmp (keyidstr, "OPENPGP.2"))
4114     ;
4115   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
4116     return gpg_error (GPG_ERR_INV_ID);
4117   else
4118     {
4119       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
4120         ;
4121       if (n != 32)
4122         return gpg_error (GPG_ERR_INV_ID);
4123       else if (!*s)
4124         ; /* no fingerprint given: we allow this for now. */
4125       else if (*s == '/')
4126         fpr = s + 1;
4127       else
4128         return gpg_error (GPG_ERR_INV_ID);
4129
4130       for (s=keyidstr, n=0; n < 16; s += 2, n++)
4131         tmp_sn[n] = xtoi_2 (s);
4132
4133       if (app->serialnolen != 16)
4134         return gpg_error (GPG_ERR_INV_CARD);
4135       if (memcmp (app->serialno, tmp_sn, 16))
4136         return gpg_error (GPG_ERR_WRONG_CARD);
4137     }
4138
4139   /* If a fingerprint has been specified check it against the one on
4140      the card.  This is allows for a meaningful error message in case
4141      the key on the card has been replaced but the shadow information
4142      known to gpg was not updated.  If there is no fingerprint, the
4143      decryption won't produce the right plaintext anyway. */
4144   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
4145   if (rc)
4146     return rc;
4147
4148   rc = verify_chv2 (app, pincb, pincb_arg);
4149   if (rc)
4150     return rc;
4151
4152   if (indatalen == 16 + 1 || indatalen == 32 + 1)
4153     /* PSO:DECIPHER with symmetric key.  */
4154     padind = -1;
4155   else if (app->app_local->keyattr[1].key_type == KEY_TYPE_RSA)
4156     {
4157       /* We might encounter a couple of leading zeroes in the
4158          cryptogram.  Due to internal use of MPIs these leading zeroes
4159          are stripped.  However the OpenPGP card expects exactly 128
4160          bytes for the cryptogram (for a 1k key).  Thus we need to fix
4161          it up.  We do this for up to 16 leading zero bytes; a
4162          cryptogram with more than this is with a very high
4163          probability anyway broken.  If a signed conversion was used
4164          we may also encounter one leading zero followed by the correct
4165          length.  We fix that as well.  */
4166       if (indatalen >= (128-16) && indatalen < 128)