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