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