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