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