SCD: handle keypad request on the card.
[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   /* Keypad request specified on card.  */
195   struct
196   {
197     unsigned int specified:1;
198     unsigned int varlen:1;
199     int fixedlen_user;
200     int fixedlen_admin;
201   } keypad;
202
203   struct
204   {
205     unsigned int n_bits;     /* Size of the modulus in bits.  The rest
206                                 of this strucuire is only valid if
207                                 this is not 0.  */
208     unsigned int e_bits;     /* Size of the public exponent in bits.  */
209     rsa_key_format_t format;
210   } keyattr[3];
211
212 };
213
214
215
216 /***** Local prototypes  *****/
217 static unsigned long convert_sig_counter_value (const unsigned char *value,
218                                                 size_t valuelen);
219 static unsigned long get_sig_counter (app_t app);
220 static gpg_error_t do_auth (app_t app, const char *keyidstr,
221                             gpg_error_t (*pincb)(void*, const char *, char **),
222                             void *pincb_arg,
223                             const void *indata, size_t indatalen,
224                             unsigned char **outdata, size_t *outdatalen);
225 static void parse_algorithm_attribute (app_t app, int keyno);
226 static gpg_error_t change_keyattr_from_string
227                            (app_t app,
228                             gpg_error_t (*pincb)(void*, const char *, char **),
229                             void *pincb_arg,
230                             const void *value, size_t valuelen);
231
232
233
234
235 \f
236 /* Deconstructor. */
237 static void
238 do_deinit (app_t app)
239 {
240   if (app && app->app_local)
241     {
242       struct cache_s *c, *c2;
243       int i;
244
245       for (c = app->app_local->cache; c; c = c2)
246         {
247           c2 = c->next;
248           xfree (c);
249         }
250
251       for (i=0; i < DIM (app->app_local->pk); i++)
252         {
253           xfree (app->app_local->pk[i].key);
254           app->app_local->pk[i].read_done = 0;
255         }
256       xfree (app->app_local);
257       app->app_local = NULL;
258     }
259 }
260
261
262 /* Wrapper around iso7816_get_data which first tries to get the data
263    from the cache.  With GET_IMMEDIATE passed as true, the cache is
264    bypassed.  With TRY_EXTLEN extended lengths APDUs are use if
265    supported by the card.  */
266 static gpg_error_t
267 get_cached_data (app_t app, int tag,
268                  unsigned char **result, size_t *resultlen,
269                  int get_immediate, int try_extlen)
270 {
271   gpg_error_t err;
272   int i;
273   unsigned char *p;
274   size_t len;
275   struct cache_s *c;
276   int exmode;
277
278   *result = NULL;
279   *resultlen = 0;
280
281   if (!get_immediate)
282     {
283       for (c=app->app_local->cache; c; c = c->next)
284         if (c->tag == tag)
285           {
286             if(c->length)
287               {
288                 p = xtrymalloc (c->length);
289                 if (!p)
290                   return gpg_error (gpg_err_code_from_errno (errno));
291                 memcpy (p, c->data, c->length);
292                 *result = p;
293               }
294
295             *resultlen = c->length;
296
297             return 0;
298           }
299     }
300
301   if (try_extlen && app->app_local->cardcap.ext_lc_le)
302     exmode = app->app_local->extcap.max_rsp_data;
303   else
304     exmode = 0;
305
306   err = iso7816_get_data (app->slot, exmode, tag, &p, &len);
307   if (err)
308     return err;
309   *result = p;
310   *resultlen = len;
311
312   /* Check whether we should cache this object. */
313   if (get_immediate)
314     return 0;
315
316   for (i=0; data_objects[i].tag; i++)
317     if (data_objects[i].tag == tag)
318       {
319         if (data_objects[i].dont_cache)
320           return 0;
321         break;
322       }
323
324   /* Okay, cache it. */
325   for (c=app->app_local->cache; c; c = c->next)
326     assert (c->tag != tag);
327
328   c = xtrymalloc (sizeof *c + len);
329   if (c)
330     {
331       memcpy (c->data, p, len);
332       c->length = len;
333       c->tag = tag;
334       c->next = app->app_local->cache;
335       app->app_local->cache = c;
336     }
337
338   return 0;
339 }
340
341 /* Remove DO at TAG from the cache. */
342 static void
343 flush_cache_item (app_t app, int tag)
344 {
345   struct cache_s *c, *cprev;
346   int i;
347
348   if (!app->app_local)
349     return;
350
351   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
352     if (c->tag == tag)
353       {
354         if (cprev)
355           cprev->next = c->next;
356         else
357           app->app_local->cache = c->next;
358         xfree (c);
359
360         for (c=app->app_local->cache; c ; c = c->next)
361           {
362             assert (c->tag != tag); /* Oops: duplicated entry. */
363           }
364         return;
365       }
366
367   /* Try again if we have an outer tag. */
368   for (i=0; data_objects[i].tag; i++)
369     if (data_objects[i].tag == tag && data_objects[i].get_from
370         && data_objects[i].get_from != tag)
371       flush_cache_item (app, data_objects[i].get_from);
372 }
373
374 /* Flush all entries from the cache which might be out of sync after
375    an error. */
376 static void
377 flush_cache_after_error (app_t app)
378 {
379   int i;
380
381   for (i=0; data_objects[i].tag; i++)
382     if (data_objects[i].flush_on_error)
383       flush_cache_item (app, data_objects[i].tag);
384 }
385
386
387 /* Flush the entire cache. */
388 static void
389 flush_cache (app_t app)
390 {
391   if (app && app->app_local)
392     {
393       struct cache_s *c, *c2;
394
395       for (c = app->app_local->cache; c; c = c2)
396         {
397           c2 = c->next;
398           xfree (c);
399         }
400       app->app_local->cache = NULL;
401     }
402 }
403
404
405 /* Get the DO identified by TAG from the card in SLOT and return a
406    buffer with its content in RESULT and NBYTES.  The return value is
407    NULL if not found or a pointer which must be used to release the
408    buffer holding value. */
409 static void *
410 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
411             int *r_rc)
412 {
413   int rc, i;
414   unsigned char *buffer;
415   size_t buflen;
416   unsigned char *value;
417   size_t valuelen;
418   int dummyrc;
419   int exmode;
420
421   if (!r_rc)
422     r_rc = &dummyrc;
423
424   *result = NULL;
425   *nbytes = 0;
426   *r_rc = 0;
427   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
428     ;
429
430   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
431     {
432       if (data_objects[i].try_extlen && app->app_local->cardcap.ext_lc_le)
433         exmode = app->app_local->extcap.max_rsp_data;
434       else
435         exmode = 0;
436       rc = iso7816_get_data (app->slot, exmode, tag, &buffer, &buflen);
437       if (rc)
438         {
439           *r_rc = rc;
440           return NULL;
441         }
442       *result = buffer;
443       *nbytes = buflen;
444       return buffer;
445     }
446
447   value = NULL;
448   rc = -1;
449   if (data_objects[i].tag && data_objects[i].get_from)
450     {
451       rc = get_cached_data (app, data_objects[i].get_from,
452                             &buffer, &buflen,
453                             (data_objects[i].dont_cache
454                              || data_objects[i].get_immediate_in_v11),
455                             data_objects[i].try_extlen);
456       if (!rc)
457         {
458           const unsigned char *s;
459
460           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
461           if (!s)
462             value = NULL; /* not found */
463           else if (valuelen > buflen - (s - buffer))
464             {
465               log_error ("warning: constructed DO too short\n");
466               value = NULL;
467               xfree (buffer); buffer = NULL;
468             }
469           else
470             value = buffer + (s - buffer);
471         }
472     }
473
474   if (!value) /* Not in a constructed DO, try simple. */
475     {
476       rc = get_cached_data (app, tag, &buffer, &buflen,
477                             (data_objects[i].dont_cache
478                              || data_objects[i].get_immediate_in_v11),
479                             data_objects[i].try_extlen);
480       if (!rc)
481         {
482           value = buffer;
483           valuelen = buflen;
484         }
485     }
486
487   if (!rc)
488     {
489       *nbytes = valuelen;
490       *result = value;
491       return buffer;
492     }
493   *r_rc = rc;
494   return NULL;
495 }
496
497
498 static void
499 dump_all_do (int slot)
500 {
501   int rc, i, j;
502   unsigned char *buffer;
503   size_t buflen;
504
505   for (i=0; data_objects[i].tag; i++)
506     {
507       if (data_objects[i].get_from)
508         continue;
509
510       /* We don't try extended length APDU because such large DO would
511          be pretty useless in a log file.  */
512       rc = iso7816_get_data (slot, 0, data_objects[i].tag, &buffer, &buflen);
513       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
514         ;
515       else if (rc)
516         log_info ("DO '%s' not available: %s\n",
517                   data_objects[i].desc, gpg_strerror (rc));
518       else
519         {
520           if (data_objects[i].binary)
521             {
522               log_info ("DO '%s': ", data_objects[i].desc);
523               log_printhex ("", buffer, buflen);
524             }
525           else
526             log_info ("DO '%s': '%.*s'\n",
527                       data_objects[i].desc,
528                       (int)buflen, buffer); /* FIXME: sanitize */
529
530           if (data_objects[i].constructed)
531             {
532               for (j=0; data_objects[j].tag; j++)
533                 {
534                   const unsigned char *value;
535                   size_t valuelen;
536
537                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
538                     continue;
539                   value = find_tlv_unchecked (buffer, buflen,
540                                               data_objects[j].tag, &valuelen);
541                   if (!value)
542                     ; /* not found */
543                   else if (valuelen > buflen - (value - buffer))
544                     log_error ("warning: constructed DO too short\n");
545                   else
546                     {
547                       if (data_objects[j].binary)
548                         {
549                           log_info ("DO '%s': ", data_objects[j].desc);
550                           if (valuelen > 200)
551                             log_info ("[%u]\n", (unsigned int)valuelen);
552                           else
553                             log_printhex ("", value, valuelen);
554                         }
555                       else
556                         log_info ("DO '%s': '%.*s'\n",
557                                   data_objects[j].desc,
558                                   (int)valuelen, value); /* FIXME: sanitize */
559                     }
560                 }
561             }
562         }
563       xfree (buffer); buffer = NULL;
564     }
565 }
566
567
568 /* Count the number of bits, assuming the A represents an unsigned big
569    integer of length LEN bytes. */
570 static unsigned int
571 count_bits (const unsigned char *a, size_t len)
572 {
573   unsigned int n = len * 8;
574   int i;
575
576   for (; len && !*a; len--, a++, n -=8)
577     ;
578   if (len)
579     {
580       for (i=7; i && !(*a & (1<<i)); i--)
581         n--;
582     }
583   return n;
584 }
585
586 /* GnuPG makes special use of the login-data DO, this function parses
587    the login data to store the flags for later use.  It may be called
588    at any time and should be called after changing the login-data DO.
589
590    Everything up to a LF is considered a mailbox or account name.  If
591    the first LF is followed by DC4 (0x14) control sequence are
592    expected up to the next LF.  Control sequences are separated by FS
593    (0x18) and consist of key=value pairs.  There are two keys defined:
594
595     F=<flags>
596
597     Where FLAGS is a plain hexadecimal number representing flag values.
598     The lsb is here the rightmost bit.  Defined flags bits are:
599
600       Bit 0 = CHV1 and CHV2 are not syncronized
601       Bit 1 = CHV2 has been been set to the default PIN of "123456"
602               (this implies that bit 0 is also set).
603
604     P=<keypad-request>
605
606     Where KEYPAD_REQUEST is 0 or a pair of two integers: <n>,<m>.
607     0 means use keypad with variable length input.  <n>,<m> means use
608     keypad with fixed length input.  N for user PIN, M for admin PIN.
609
610 */
611 static void
612 parse_login_data (app_t app)
613 {
614   unsigned char *buffer, *p;
615   size_t buflen, len;
616   void *relptr;
617
618   /* Set defaults.  */
619   app->app_local->flags.no_sync = 0;
620   app->app_local->flags.def_chv2 = 0;
621   app->app_local->keypad.specified = 0;
622   app->app_local->keypad.varlen = 0;
623   app->app_local->keypad.fixedlen_user = 6;
624   app->app_local->keypad.fixedlen_admin = 8;
625
626   /* Read the DO.  */
627   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
628   if (!relptr)
629     return; /* Ooops. */
630   for (; buflen; buflen--, buffer++)
631     if (*buffer == '\n')
632       break;
633   if (buflen < 2 || buffer[1] != '\x14')
634     return; /* No control sequences.  */
635   buflen--;
636   buffer++;
637   do
638     {
639       buflen--;
640       buffer++;
641       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
642         {
643           /* Flags control sequence found.  */
644           int lastdig = 0;
645
646           /* For now we are only interested in the last digit, so skip
647              any leading digits but bail out on invalid characters. */
648           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
649             lastdig = xtoi_1 (p);
650           buffer = p;
651           buflen = len;
652           if (len && !(*p == '\n' || *p == '\x18'))
653             goto next;  /* Invalid characters in field.  */
654           app->app_local->flags.no_sync = !!(lastdig & 1);
655           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
656         }
657       else if (buflen > 1 && *buffer == 'P' && buffer[1] == '=')
658         {
659           /* Keypad request control sequence found.  */
660           buffer += 2;
661           buflen -= 2;
662
663           if (buflen)
664             {
665               if (*buffer == '0')
666                 {
667                   buffer++;
668                   buflen--;
669                   if (buflen && !(*buffer == '\n' || *buffer == '\x18'))
670                     goto next;
671                   app->app_local->keypad.specified = 1;
672                   app->app_local->keypad.varlen = 1;
673                 }
674               else if (digitp (buffer))
675                 {
676                   char *q;
677                   int n, m;
678
679                   n = strtol (buffer, &q, 10);
680                   if (*q++ != ',' || !digitp (q))
681                     goto next;
682                   m = strtol (q, &q, 10);
683                   buffer = q;
684                   if (buflen < ((unsigned char *)q - buffer))
685                     {
686                       buflen = 0;
687                       break;
688                     }
689                   else
690                     buflen -= ((unsigned char *)q - buffer);
691
692                   if (buflen && !(*buffer == '\n' || *buffer == '\x18'))
693                     goto next;
694                   app->app_local->keypad.specified = 1;
695                   app->app_local->keypad.fixedlen_user = n;
696                   app->app_local->keypad.fixedlen_admin = m;
697                 }
698             }
699         }
700     next:
701       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
702         if (*buffer == '\n')
703           buflen = 1;
704     }
705   while (buflen);
706
707   xfree (relptr);
708 }
709
710 /* Note, that FPR must be at least 20 bytes. */
711 static gpg_error_t
712 store_fpr (app_t app, int keynumber, u32 timestamp,
713            const unsigned char *m, size_t mlen,
714            const unsigned char *e, size_t elen,
715            unsigned char *fpr, unsigned int card_version)
716 {
717   unsigned int n, nbits;
718   unsigned char *buffer, *p;
719   int tag, tag2;
720   int rc;
721
722   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
723     ;
724   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
725     ;
726
727   n = 6 + 2 + mlen + 2 + elen;
728   p = buffer = xtrymalloc (3 + n);
729   if (!buffer)
730     return gpg_error_from_syserror ();
731
732   *p++ = 0x99;     /* ctb */
733   *p++ = n >> 8;   /* 2 byte length header */
734   *p++ = n;
735   *p++ = 4;        /* key packet version */
736   *p++ = timestamp >> 24;
737   *p++ = timestamp >> 16;
738   *p++ = timestamp >>  8;
739   *p++ = timestamp;
740   *p++ = 1; /* RSA */
741   nbits = count_bits (m, mlen);
742   *p++ = nbits >> 8;
743   *p++ = nbits;
744   memcpy (p, m, mlen); p += mlen;
745   nbits = count_bits (e, elen);
746   *p++ = nbits >> 8;
747   *p++ = nbits;
748   memcpy (p, e, elen); p += elen;
749
750   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
751
752   xfree (buffer);
753
754   tag = (card_version > 0x0007? 0xC7 : 0xC6) + keynumber;
755   flush_cache_item (app, 0xC5);
756   tag2 = 0xCE + keynumber;
757   flush_cache_item (app, 0xCD);
758
759   rc = iso7816_put_data (app->slot, 0, tag, fpr, 20);
760   if (rc)
761     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
762
763   if (!rc && card_version > 0x0100)
764     {
765       unsigned char buf[4];
766
767       buf[0] = timestamp >> 24;
768       buf[1] = timestamp >> 16;
769       buf[2] = timestamp >>  8;
770       buf[3] = timestamp;
771
772       rc = iso7816_put_data (app->slot, 0, tag2, buf, 4);
773       if (rc)
774         log_error (_("failed to store the creation date: %s\n"),
775                    gpg_strerror (rc));
776     }
777
778   return rc;
779 }
780
781
782 static void
783 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
784                       int number, const unsigned char *fpr)
785 {
786   int i;
787   char buf[41];
788   char numbuf[25];
789
790   for (i=0; i < 20 && !fpr[i]; i++)
791     ;
792   if (i==20)
793     return; /* All zero. */
794   bin2hex (fpr, 20, buf);
795   if (number == -1)
796     *numbuf = 0; /* Don't print the key number */
797   else
798     sprintf (numbuf, "%d", number);
799   send_status_info (ctrl, keyword,
800                     numbuf, (size_t)strlen(numbuf),
801                     buf, (size_t)strlen (buf), NULL, 0);
802 }
803
804 static void
805 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
806                           int number, const unsigned char *stamp)
807 {
808   char numbuf1[50], numbuf2[50];
809   unsigned long value;
810
811   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
812   if (!value)
813     return;
814   sprintf (numbuf1, "%d", number);
815   sprintf (numbuf2, "%lu", value);
816   send_status_info (ctrl, keyword,
817                     numbuf1, (size_t)strlen(numbuf1),
818                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
819 }
820
821 static void
822 send_key_data (ctrl_t ctrl, const char *name,
823                const unsigned char *a, size_t alen)
824 {
825   char *buffer, *buf;
826   size_t buflen;
827
828   buffer = buf = bin2hex (a, alen, NULL);
829   if (!buffer)
830     {
831       log_error ("memory allocation error in send_key_data\n");
832       return;
833     }
834   buflen = strlen (buffer);
835
836   /* 768 is the hexified size for the modulus of an 3072 bit key.  We
837      use extra chunks to transmit larger data (i.e for 4096 bit).  */
838   for ( ;buflen > 768; buflen -= 768, buf += 768)
839     send_status_info (ctrl, "KEY-DATA",
840                       "-", 1,
841                       buf, 768,
842                       NULL, 0);
843   send_status_info (ctrl, "KEY-DATA",
844                     name, (size_t)strlen(name),
845                     buf, buflen,
846                     NULL, 0);
847   xfree (buffer);
848 }
849
850
851 static void
852 send_key_attr (ctrl_t ctrl, app_t app, const char *keyword, int number)
853 {
854   char buffer[200];
855
856   assert (number >=0 && number < DIM(app->app_local->keyattr));
857
858   /* We only support RSA thus the algo identifier is fixed to 1.  */
859   snprintf (buffer, sizeof buffer, "%d 1 %u %u %d",
860             number+1,
861             app->app_local->keyattr[number].n_bits,
862             app->app_local->keyattr[number].e_bits,
863             app->app_local->keyattr[number].format);
864   send_status_direct (ctrl, keyword, buffer);
865 }
866
867
868 /* Implement the GETATTR command.  This is similar to the LEARN
869    command but returns just one value via the status interface. */
870 static gpg_error_t
871 do_getattr (app_t app, ctrl_t ctrl, const char *name)
872 {
873   static struct {
874     const char *name;
875     int tag;
876     int special;
877   } table[] = {
878     { "DISP-NAME",    0x005B },
879     { "LOGIN-DATA",   0x005E },
880     { "DISP-LANG",    0x5F2D },
881     { "DISP-SEX",     0x5F35 },
882     { "PUBKEY-URL",   0x5F50 },
883     { "KEY-FPR",      0x00C5, 3 },
884     { "KEY-TIME",     0x00CD, 4 },
885     { "KEY-ATTR",     0x0000, -5 },
886     { "CA-FPR",       0x00C6, 3 },
887     { "CHV-STATUS",   0x00C4, 1 },
888     { "SIG-COUNTER",  0x0093, 2 },
889     { "SERIALNO",     0x004F, -1 },
890     { "AID",          0x004F },
891     { "EXTCAP",       0x0000, -2 },
892     { "PRIVATE-DO-1", 0x0101 },
893     { "PRIVATE-DO-2", 0x0102 },
894     { "PRIVATE-DO-3", 0x0103 },
895     { "PRIVATE-DO-4", 0x0104 },
896     { "$AUTHKEYID",   0x0000, -3 },
897     { "$DISPSERIALNO",0x0000, -4 },
898     { NULL, 0 }
899   };
900   int idx, i, rc;
901   void *relptr;
902   unsigned char *value;
903   size_t valuelen;
904
905   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
906     ;
907   if (!table[idx].name)
908     return gpg_error (GPG_ERR_INV_NAME);
909
910   if (table[idx].special == -1)
911     {
912       /* The serial number is very special.  We could have used the
913          AID DO to retrieve it, but we have it already in the app
914          context and the stamp argument is required anyway which we
915          can't by other means. The AID DO is available anyway but not
916          hex formatted. */
917       char *serial;
918       time_t stamp;
919       char tmp[50];
920
921       if (!app_get_serial_and_stamp (app, &serial, &stamp))
922         {
923           sprintf (tmp, "%lu", (unsigned long)stamp);
924           send_status_info (ctrl, "SERIALNO",
925                             serial, strlen (serial),
926                             tmp, strlen (tmp),
927                             NULL, 0);
928           xfree (serial);
929         }
930       return 0;
931     }
932   if (table[idx].special == -2)
933     {
934       char tmp[100];
935
936       snprintf (tmp, sizeof tmp,
937                 "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d sm=%d",
938                 app->app_local->extcap.get_challenge,
939                 app->app_local->extcap.key_import,
940                 app->app_local->extcap.change_force_chv,
941                 app->app_local->extcap.private_dos,
942                 app->app_local->extcap.max_certlen_3,
943                 app->app_local->extcap.algo_attr_change,
944                 (app->app_local->extcap.sm_supported
945                  ? (app->app_local->extcap.sm_aes128? 7 : 2)
946                  : 0));
947       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
948       return 0;
949     }
950   if (table[idx].special == -3)
951     {
952       char const tmp[] = "OPENPGP.3";
953       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
954       return 0;
955     }
956   if (table[idx].special == -4)
957     {
958       char *serial;
959       time_t stamp;
960
961       if (!app_get_serial_and_stamp (app, &serial, &stamp))
962         {
963           if (strlen (serial) > 16+12)
964             {
965               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
966               xfree (serial);
967               return 0;
968             }
969           xfree (serial);
970         }
971       return gpg_error (GPG_ERR_INV_NAME);
972     }
973   if (table[idx].special == -5)
974     {
975       for (i=0; i < 3; i++)
976         send_key_attr (ctrl, app, table[idx].name, i);
977       return 0;
978     }
979
980   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
981   if (relptr)
982     {
983       if (table[idx].special == 1)
984         {
985           char numbuf[7*23];
986
987           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
988             sprintf (numbuf+strlen (numbuf), " %d", value[i]);
989           send_status_info (ctrl, table[idx].name,
990                             numbuf, strlen (numbuf), NULL, 0);
991         }
992       else if (table[idx].special == 2)
993         {
994           char numbuf[50];
995
996           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
997           send_status_info (ctrl, table[idx].name,
998                             numbuf, strlen (numbuf), NULL, 0);
999         }
1000       else if (table[idx].special == 3)
1001         {
1002           if (valuelen >= 60)
1003             for (i=0; i < 3; i++)
1004               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
1005         }
1006       else if (table[idx].special == 4)
1007         {
1008           if (valuelen >= 12)
1009             for (i=0; i < 3; i++)
1010               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
1011         }
1012       else
1013         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
1014
1015       xfree (relptr);
1016     }
1017   return rc;
1018 }
1019
1020 /* Retrieve the fingerprint from the card inserted in SLOT and write
1021    the according hex representation to FPR.  Caller must have provide
1022    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
1023    error code. */
1024 #if GNUPG_MAJOR_VERSION > 1
1025 static gpg_error_t
1026 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
1027 {
1028   gpg_error_t err = 0;
1029   void *relptr;
1030   unsigned char *value;
1031   size_t valuelen;
1032
1033   assert (keyno >=0 && keyno <= 2);
1034
1035   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
1036   if (relptr && valuelen >= 60)
1037     bin2hex (value+keyno*20, 20, fpr);
1038   else
1039     err = gpg_error (GPG_ERR_NOT_FOUND);
1040   xfree (relptr);
1041   return err;
1042 }
1043 #endif /*GNUPG_MAJOR_VERSION > 1*/
1044
1045
1046 /* Retrieve the public key material for the RSA key, whose fingerprint
1047    is FPR, from gpg output, which can be read through the stream FP.
1048    The RSA modulus will be stored at the address of M and MLEN, the
1049    public exponent at E and ELEN.  Returns zero on success, an error
1050    code on failure.  Caller must release the allocated buffers at M
1051    and E if the function returns success.  */
1052 #if GNUPG_MAJOR_VERSION > 1
1053 static gpg_error_t
1054 retrieve_key_material (FILE *fp, const char *hexkeyid,
1055                        const unsigned char **m, size_t *mlen,
1056                        const unsigned char **e, size_t *elen)
1057 {
1058   gcry_error_t err = 0;
1059   char *line = NULL;    /* read_line() buffer. */
1060   size_t line_size = 0; /* Helper for for read_line. */
1061   int found_key = 0;    /* Helper to find a matching key. */
1062   unsigned char *m_new = NULL;
1063   unsigned char *e_new = NULL;
1064   size_t m_new_n = 0;
1065   size_t e_new_n = 0;
1066
1067   /* Loop over all records until we have found the subkey
1068      corresponding to the fingerprint. Inm general the first record
1069      should be the pub record, but we don't rely on that.  Given that
1070      we only need to look at one key, it is sufficient to compare the
1071      keyid so that we don't need to look at "fpr" records. */
1072   for (;;)
1073     {
1074       char *p;
1075       char *fields[6];
1076       int nfields;
1077       size_t max_length;
1078       gcry_mpi_t mpi;
1079       int i;
1080
1081       max_length = 4096;
1082       i = read_line (fp, &line, &line_size, &max_length);
1083       if (!i)
1084         break; /* EOF. */
1085       if (i < 0)
1086         {
1087           err = gpg_error_from_syserror ();
1088           goto leave; /* Error. */
1089         }
1090       if (!max_length)
1091         {
1092           err = gpg_error (GPG_ERR_TRUNCATED);
1093           goto leave;  /* Line truncated - we better stop processing.  */
1094         }
1095
1096       /* Parse the line into fields. */
1097       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
1098         {
1099           fields[nfields] = p;
1100           p = strchr (p, ':');
1101           if (p)
1102             *(p++) = 0;
1103         }
1104       if (!nfields)
1105         continue; /* No fields at all - skip line.  */
1106
1107       if (!found_key)
1108         {
1109           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1110                && nfields > 4 && !strcmp (fields[4], hexkeyid))
1111             found_key = 1;
1112           continue;
1113         }
1114
1115       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1116         break; /* Next key - stop.  */
1117
1118       if ( strcmp (fields[0], "pkd") )
1119         continue; /* Not a key data record.  */
1120       i = 0; /* Avoid erroneous compiler warning. */
1121       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1122            || (!i && m_new) || (i && e_new))
1123         {
1124           err = gpg_error (GPG_ERR_GENERAL);
1125           goto leave; /* Error: Invalid key data record or not an RSA key.  */
1126         }
1127
1128       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1129       if (err)
1130         mpi = NULL;
1131       else if (!i)
1132         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1133       else
1134         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1135       gcry_mpi_release (mpi);
1136       if (err)
1137         goto leave;
1138     }
1139
1140   if (m_new && e_new)
1141     {
1142       *m = m_new;
1143       *mlen = m_new_n;
1144       m_new = NULL;
1145       *e = e_new;
1146       *elen = e_new_n;
1147       e_new = NULL;
1148     }
1149   else
1150     err = gpg_error (GPG_ERR_GENERAL);
1151
1152  leave:
1153   xfree (m_new);
1154   xfree (e_new);
1155   xfree (line);
1156   return err;
1157 }
1158 #endif /*GNUPG_MAJOR_VERSION > 1*/
1159
1160
1161 /* Get the public key for KEYNO and store it as an S-expresion with
1162    the APP handle.  On error that field gets cleared.  If we already
1163    know about the public key we will just return.  Note that this does
1164    not mean a key is available; this is soley indicated by the
1165    presence of the app->app_local->pk[KEYNO-1].key field.
1166
1167    Note that GnuPG 1.x does not need this and it would be too time
1168    consuming to send it just for the fun of it. However, given that we
1169    use the same code in gpg 1.4, we can't use the gcry S-expresion
1170    here but need to open encode it. */
1171 #if GNUPG_MAJOR_VERSION > 1
1172 static gpg_error_t
1173 get_public_key (app_t app, int keyno)
1174 {
1175   gpg_error_t err = 0;
1176   unsigned char *buffer;
1177   const unsigned char *keydata, *m, *e;
1178   size_t buflen, keydatalen, mlen, elen;
1179   unsigned char *mbuf = NULL;
1180   unsigned char *ebuf = NULL;
1181   char *keybuf = NULL;
1182   char *keybuf_p;
1183
1184   if (keyno < 1 || keyno > 3)
1185     return gpg_error (GPG_ERR_INV_ID);
1186   keyno--;
1187
1188   /* Already cached? */
1189   if (app->app_local->pk[keyno].read_done)
1190     return 0;
1191
1192   xfree (app->app_local->pk[keyno].key);
1193   app->app_local->pk[keyno].key = NULL;
1194   app->app_local->pk[keyno].keylen = 0;
1195
1196   m = e = NULL; /* (avoid cc warning) */
1197
1198   if (app->card_version > 0x0100)
1199     {
1200       int exmode, le_value;
1201
1202       /* We may simply read the public key out of these cards.  */
1203       if (app->app_local->cardcap.ext_lc_le)
1204         {
1205           exmode = 1;    /* Use extended length.  */
1206           le_value = app->app_local->extcap.max_rsp_data;
1207         }
1208       else
1209         {
1210           exmode = 0;
1211           le_value = 256; /* Use legacy value. */
1212         }
1213
1214       err = iso7816_read_public_key
1215         (app->slot, exmode,
1216          (const unsigned char*)(keyno == 0? "\xB6" :
1217                                 keyno == 1? "\xB8" : "\xA4"), 2,
1218          le_value,
1219          &buffer, &buflen);
1220       if (err)
1221         {
1222           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1223           goto leave;
1224         }
1225
1226       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1227       if (!keydata)
1228         {
1229           err = gpg_error (GPG_ERR_CARD);
1230           log_error (_("response does not contain the public key data\n"));
1231           goto leave;
1232         }
1233
1234       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1235       if (!m)
1236         {
1237           err = gpg_error (GPG_ERR_CARD);
1238           log_error (_("response does not contain the RSA modulus\n"));
1239           goto leave;
1240         }
1241
1242
1243       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1244       if (!e)
1245         {
1246           err = gpg_error (GPG_ERR_CARD);
1247           log_error (_("response does not contain the RSA public exponent\n"));
1248           goto leave;
1249         }
1250
1251       /* Prepend numbers with a 0 if needed.  */
1252       if (mlen && (*m & 0x80))
1253         {
1254           mbuf = xtrymalloc ( mlen + 1);
1255           if (!mbuf)
1256             {
1257               err = gpg_error_from_syserror ();
1258               goto leave;
1259             }
1260           *mbuf = 0;
1261           memcpy (mbuf+1, m, mlen);
1262           mlen++;
1263           m = mbuf;
1264         }
1265       if (elen && (*e & 0x80))
1266         {
1267           ebuf = xtrymalloc ( elen + 1);
1268           if (!ebuf)
1269             {
1270               err = gpg_error_from_syserror ();
1271               goto leave;
1272             }
1273           *ebuf = 0;
1274           memcpy (ebuf+1, e, elen);
1275           elen++;
1276           e = ebuf;
1277         }
1278
1279     }
1280   else
1281     {
1282       /* Due to a design problem in v1.0 cards we can't get the public
1283          key out of these cards without doing a verify on CHV3.
1284          Clearly that is not an option and thus we try to locate the
1285          key using an external helper.
1286
1287          The helper we use here is gpg itself, which should know about
1288          the key in any case.  */
1289
1290       char fpr[41];
1291       char *hexkeyid;
1292       char *command = NULL;
1293       FILE *fp;
1294       int ret;
1295
1296       buffer = NULL; /* We don't need buffer.  */
1297
1298       err = retrieve_fpr_from_card (app, keyno, fpr);
1299       if (err)
1300         {
1301           log_error ("error while retrieving fpr from card: %s\n",
1302                      gpg_strerror (err));
1303           goto leave;
1304         }
1305       hexkeyid = fpr + 24;
1306
1307       ret = estream_asprintf (&command,
1308                               "gpg --list-keys --with-colons --with-key-data '%s'",
1309                               fpr);
1310       if (ret < 0)
1311         {
1312           err = gpg_error_from_syserror ();
1313           goto leave;
1314         }
1315
1316       fp = popen (command, "r");
1317       xfree (command);
1318       if (!fp)
1319         {
1320           err = gpg_error_from_syserror ();
1321           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1322           goto leave;
1323         }
1324
1325       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1326       fclose (fp);
1327       if (err)
1328         {
1329           log_error ("error while retrieving key material through pipe: %s\n",
1330                      gpg_strerror (err));
1331           goto leave;
1332         }
1333     }
1334
1335   /* Allocate a buffer to construct the S-expression.  */
1336   /* FIXME: We should provide a generalized S-expression creation
1337      mechanism. */
1338   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1339   if (!keybuf)
1340     {
1341       err = gpg_error_from_syserror ();
1342       goto leave;
1343     }
1344
1345   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1346   keybuf_p = keybuf + strlen (keybuf);
1347   memcpy (keybuf_p, m, mlen);
1348   keybuf_p += mlen;
1349   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1350   keybuf_p += strlen (keybuf_p);
1351   memcpy (keybuf_p, e, elen);
1352   keybuf_p += elen;
1353   strcpy (keybuf_p, ")))");
1354   keybuf_p += strlen (keybuf_p);
1355
1356   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1357   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1358
1359  leave:
1360   /* Set a flag to indicate that we tried to read the key.  */
1361   app->app_local->pk[keyno].read_done = 1;
1362
1363   xfree (buffer);
1364   xfree (mbuf);
1365   xfree (ebuf);
1366   return 0;
1367 }
1368 #endif /* GNUPG_MAJOR_VERSION > 1 */
1369
1370
1371
1372 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1373    This is used by the LEARN command. */
1374 static gpg_error_t
1375 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1376 {
1377   gpg_error_t err = 0;
1378   /* Note that GnuPG 1.x does not need this and it would be too time
1379      consuming to send it just for the fun of it. */
1380 #if GNUPG_MAJOR_VERSION > 1
1381   unsigned char grip[20];
1382   char gripstr[41];
1383   char idbuf[50];
1384
1385   err = get_public_key (app, keyno);
1386   if (err)
1387     goto leave;
1388
1389   assert (keyno >= 1 && keyno <= 3);
1390   if (!app->app_local->pk[keyno-1].key)
1391     goto leave; /* No such key - ignore. */
1392
1393   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1394                                  app->app_local->pk[keyno-1].keylen,
1395                                  grip);
1396   if (err)
1397     goto leave;
1398
1399   bin2hex (grip, 20, gripstr);
1400
1401   sprintf (idbuf, "OPENPGP.%d", keyno);
1402   send_status_info (ctrl, "KEYPAIRINFO",
1403                     gripstr, 40,
1404                     idbuf, strlen (idbuf),
1405                     NULL, (size_t)0);
1406
1407  leave:
1408 #endif /* GNUPG_MAJOR_VERSION > 1 */
1409
1410   return err;
1411 }
1412
1413
1414 /* Handle the LEARN command for OpenPGP.  */
1415 static gpg_error_t
1416 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1417 {
1418   (void)flags;
1419
1420   do_getattr (app, ctrl, "EXTCAP");
1421   do_getattr (app, ctrl, "DISP-NAME");
1422   do_getattr (app, ctrl, "DISP-LANG");
1423   do_getattr (app, ctrl, "DISP-SEX");
1424   do_getattr (app, ctrl, "PUBKEY-URL");
1425   do_getattr (app, ctrl, "LOGIN-DATA");
1426   do_getattr (app, ctrl, "KEY-FPR");
1427   if (app->card_version > 0x0100)
1428     do_getattr (app, ctrl, "KEY-TIME");
1429   do_getattr (app, ctrl, "CA-FPR");
1430   do_getattr (app, ctrl, "CHV-STATUS");
1431   do_getattr (app, ctrl, "SIG-COUNTER");
1432   if (app->app_local->extcap.private_dos)
1433     {
1434       do_getattr (app, ctrl, "PRIVATE-DO-1");
1435       do_getattr (app, ctrl, "PRIVATE-DO-2");
1436       if (app->did_chv2)
1437         do_getattr (app, ctrl, "PRIVATE-DO-3");
1438       if (app->did_chv3)
1439         do_getattr (app, ctrl, "PRIVATE-DO-4");
1440     }
1441   send_keypair_info (app, ctrl, 1);
1442   send_keypair_info (app, ctrl, 2);
1443   send_keypair_info (app, ctrl, 3);
1444   /* Note: We do not send the Cardholder Certificate, because that is
1445      relativly long and for OpenPGP applications not really needed.  */
1446   return 0;
1447 }
1448
1449
1450 /* Handle the READKEY command for OpenPGP.  On success a canonical
1451    encoded S-expression with the public key will get stored at PK and
1452    its length (for assertions) at PKLEN; the caller must release that
1453    buffer. On error PK and PKLEN are not changed and an error code is
1454    returned.  */
1455 static gpg_error_t
1456 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1457 {
1458 #if GNUPG_MAJOR_VERSION > 1
1459   gpg_error_t err;
1460   int keyno;
1461   unsigned char *buf;
1462
1463   if (!strcmp (keyid, "OPENPGP.1"))
1464     keyno = 1;
1465   else if (!strcmp (keyid, "OPENPGP.2"))
1466     keyno = 2;
1467   else if (!strcmp (keyid, "OPENPGP.3"))
1468     keyno = 3;
1469   else
1470     return gpg_error (GPG_ERR_INV_ID);
1471
1472   err = get_public_key (app, keyno);
1473   if (err)
1474     return err;
1475
1476   buf = app->app_local->pk[keyno-1].key;
1477   if (!buf)
1478     return gpg_error (GPG_ERR_NO_PUBKEY);
1479   *pklen = app->app_local->pk[keyno-1].keylen;;
1480   *pk = xtrymalloc (*pklen);
1481   if (!*pk)
1482     {
1483       err = gpg_error_from_syserror ();
1484       *pklen = 0;
1485       return err;
1486     }
1487   memcpy (*pk, buf, *pklen);
1488   return 0;
1489 #else
1490   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1491 #endif
1492 }
1493
1494 /* Read the standard certificate of an OpenPGP v2 card.  It is
1495    returned in a freshly allocated buffer with that address stored at
1496    CERT and the length of the certificate stored at CERTLEN.  CERTID
1497    needs to be set to "OPENPGP.3".  */
1498 static gpg_error_t
1499 do_readcert (app_t app, const char *certid,
1500              unsigned char **cert, size_t *certlen)
1501 {
1502 #if GNUPG_MAJOR_VERSION > 1
1503   gpg_error_t err;
1504   unsigned char *buffer;
1505   size_t buflen;
1506   void *relptr;
1507
1508   *cert = NULL;
1509   *certlen = 0;
1510   if (strcmp (certid, "OPENPGP.3"))
1511     return gpg_error (GPG_ERR_INV_ID);
1512   if (!app->app_local->extcap.is_v2)
1513     return gpg_error (GPG_ERR_NOT_FOUND);
1514
1515   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1516   if (!relptr)
1517     return gpg_error (GPG_ERR_NOT_FOUND);
1518
1519   if (!buflen)
1520     err = gpg_error (GPG_ERR_NOT_FOUND);
1521   else if (!(*cert = xtrymalloc (buflen)))
1522     err = gpg_error_from_syserror ();
1523   else
1524     {
1525       memcpy (*cert, buffer, buflen);
1526       *certlen = buflen;
1527       err  = 0;
1528     }
1529   xfree (relptr);
1530   return err;
1531 #else
1532   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1533 #endif
1534 }
1535
1536
1537 /* Decide if we use keypad of reader for PIN input according to the
1538    user preference on the card.  Returns 0 if we use keypad, 1 otherwise.  */
1539 static int
1540 check_keypad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1541 {
1542   /* User specifies no preference on card, then, use pinentry.  */
1543   if (app->app_local->keypad.specified == 0)
1544     return 1;
1545
1546   if (app->app_local->keypad.varlen)
1547     if (pininfo->fixedlen == 0)
1548       return 0;
1549     else
1550       /* On card, user specifies varlen but reader doesn't have the feature.  */
1551       return 1;
1552   else
1553     {
1554       if (admin_pin)
1555         pininfo->fixedlen = app->app_local->keypad.fixedlen_admin;
1556       else
1557         pininfo->fixedlen = app->app_local->keypad.fixedlen_user;
1558
1559       if (pininfo->fixedlen < pininfo->minlen
1560           || pininfo->fixedlen > pininfo->maxlen)
1561         return 1;
1562
1563       return 0;
1564     }
1565 }
1566
1567
1568 /* Verify a CHV either using using the pinentry or if possibile by
1569    using a keypad.  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 keypad 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_keypad
1635       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo)
1636       && !check_keypad_request (app, &pininfo, 0))
1637     {
1638       /* The reader supports the verify command through the keypad.
1639          Note that the pincb appends a text to the prompt telling the
1640          user to use the keypad. */
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 keypad 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 keypad (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_keypad
1819           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo)
1820           && !check_keypad_request (app, &pininfo, 1))
1821         {
1822           /* The reader supports the verify command through the keypad. */
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_keypad = 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_keypad
2069           && !iso7816_check_keypad (app->slot,
2070                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2071           && !check_keypad_request (app, &pininfo, chvno == 3))
2072         use_keypad = 1;
2073
2074       if (reset_mode)
2075         {
2076           /* To reset a PIN the Admin PIN is required. */
2077           use_keypad = 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_keypad)
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_keypad = 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_keypad)
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_keypad)
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          keypad 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 }