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