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