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