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