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