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