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