scd: better handling of extended APDU.
[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 #include "../include/host2net.h"
70
71
72 /* A table describing the DOs of the card.  */
73 static struct {
74   int tag;
75   int constructed;
76   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
77   int binary:1;
78   int dont_cache:1;
79   int flush_on_error:1;
80   int get_immediate_in_v11:1; /* Enable a hack to bypass the cache of
81                                  this data object if it is used in 1.1
82                                  and later versions of the card.  This
83                                  does not work with composite DO and
84                                  is currently only useful for the CHV
85                                  status bytes. */
86   int try_extlen:1;           /* Large object; try to use an extended
87                                  length APDU.  */
88   char *desc;
89 } data_objects[] = {
90   { 0x005E, 0,    0, 1, 0, 0, 0, 0, "Login Data" },
91   { 0x5F50, 0,    0, 0, 0, 0, 0, 0, "URL" },
92   { 0x5F52, 0,    0, 1, 0, 0, 0, 0, "Historical Bytes" },
93   { 0x0065, 1,    0, 1, 0, 0, 0, 0, "Cardholder Related Data"},
94   { 0x005B, 0, 0x65, 0, 0, 0, 0, 0, "Name" },
95   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, 0, "Language preferences" },
96   { 0x5F35, 0, 0x65, 0, 0, 0, 0, 0, "Sex" },
97   { 0x006E, 1,    0, 1, 0, 0, 0, 0, "Application Related Data" },
98   { 0x004F, 0, 0x6E, 1, 0, 0, 0, 0, "AID" },
99   { 0x0073, 1,    0, 1, 0, 0, 0, 0, "Discretionary Data Objects" },
100   { 0x0047, 0, 0x6E, 1, 1, 0, 0, 0, "Card Capabilities" },
101   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, 0, "Extended Card Capabilities" },
102   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Signature" },
103   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Decryption" },
104   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, 0, "Algorithm Attributes Authentication" },
105   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, 0, "CHV Status Bytes" },
106   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, 0, "Fingerprints" },
107   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, 0, "CA Fingerprints" },
108   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, 0, "Generation time" },
109   { 0x007A, 1,    0, 1, 0, 0, 0, 0, "Security Support Template" },
110   { 0x0093, 0, 0x7A, 1, 1, 0, 0, 0, "Digital Signature Counter" },
111   { 0x0101, 0,    0, 0, 0, 0, 0, 0, "Private DO 1"},
112   { 0x0102, 0,    0, 0, 0, 0, 0, 0, "Private DO 2"},
113   { 0x0103, 0,    0, 0, 0, 0, 0, 0, "Private DO 3"},
114   { 0x0104, 0,    0, 0, 0, 0, 0, 0, "Private DO 4"},
115   { 0x7F21, 1,    0, 1, 0, 0, 0, 1, "Cardholder certificate"},
116   { 0 }
117 };
118
119
120 /* The format of RSA private keys.  */
121 typedef enum
122   {
123     RSA_UNKNOWN_FMT,
124     RSA_STD,
125     RSA_STD_N,
126     RSA_CRT,
127     RSA_CRT_N
128   }
129 rsa_key_format_t;
130
131
132 /* One cache item for DOs.  */
133 struct cache_s {
134   struct cache_s *next;
135   int tag;
136   size_t length;
137   unsigned char data[1];
138 };
139
140
141 /* Object with application (i.e. OpenPGP card) specific data.  */
142 struct app_local_s {
143   /* A linked list with cached DOs.  */
144   struct cache_s *cache;
145
146   /* Keep track of the public keys.  */
147   struct
148   {
149     int read_done;   /* True if we have at least tried to read them.  */
150     unsigned char *key; /* This is a malloced buffer with a canonical
151                            encoded S-expression encoding a public
152                            key. Might be NULL if key is not
153                            available.  */
154     size_t keylen;      /* The length of the above S-expression.  This
155                            is usually only required for cross checks
156                            because the length of an S-expression is
157                            implicitly available.  */
158   } pk[3];
159
160   unsigned char status_indicator; /* The card status indicator.  */
161
162   unsigned int manufacturer:16;   /* Manufacturer ID from the s/n.  */
163
164   /* Keep track of the ISO card capabilities.  */
165   struct
166   {
167     unsigned int cmd_chaining:1;  /* Command chaining is supported.  */
168     unsigned int ext_lc_le:1;     /* Extended Lc and Le are supported.  */
169   } cardcap;
170
171   /* Keep track of extended card capabilities.  */
172   struct
173   {
174     unsigned int is_v2:1;              /* This is a v2.0 compatible card.  */
175     unsigned int get_challenge:1;
176     unsigned int key_import:1;
177     unsigned int change_force_chv:1;
178     unsigned int private_dos:1;
179     unsigned int algo_attr_change:1;   /* Algorithm attributes changeable.  */
180     unsigned int sm_supported:1;       /* Secure Messaging is supported.  */
181     unsigned int sm_aes128:1;          /* Use AES-128 for SM.  */
182     unsigned int max_certlen_3:16;
183     unsigned int max_get_challenge:16; /* Maximum size for get_challenge.  */
184     unsigned int max_cmd_data:16;      /* Maximum data size for a command.  */
185     unsigned int max_rsp_data:16;      /* Maximum size of a response.  */
186   } extcap;
187
188   /* Flags used to control the application.  */
189   struct
190   {
191     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
192     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
193   } flags;
194
195   /* Pinpad request specified on card.  */
196   struct
197   {
198     unsigned int specified:1;
199     int fixedlen_user;
200     int fixedlen_admin;
201   } pinpad;
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=<pinpad-request>
605
606     Where PINPAD_REQUEST is in the format of: <n> or <n>,<m>.
607     N for user PIN, M for admin PIN.  If M is missing it means M=N.
608     0 means to force not to use pinpad.
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->pinpad.specified = 0;
622   app->app_local->pinpad.fixedlen_user = -1;
623   app->app_local->pinpad.fixedlen_admin = -1;
624
625   /* Read the DO.  */
626   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
627   if (!relptr)
628     return; /* Ooops. */
629   for (; buflen; buflen--, buffer++)
630     if (*buffer == '\n')
631       break;
632   if (buflen < 2 || buffer[1] != '\x14')
633     {
634       xfree (relptr);
635       return; /* No control sequences.  */
636     }
637
638   buflen--;
639   buffer++;
640   do
641     {
642       buflen--;
643       buffer++;
644       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
645         {
646           /* Flags control sequence found.  */
647           int lastdig = 0;
648
649           /* For now we are only interested in the last digit, so skip
650              any leading digits but bail out on invalid characters. */
651           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
652             lastdig = xtoi_1 (p);
653           buffer = p;
654           buflen = len;
655           if (len && !(*p == '\n' || *p == '\x18'))
656             goto next;  /* Invalid characters in field.  */
657           app->app_local->flags.no_sync = !!(lastdig & 1);
658           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
659         }
660       else if (buflen > 1 && *buffer == 'P' && buffer[1] == '=')
661         {
662           /* Pinpad request control sequence found.  */
663           buffer += 2;
664           buflen -= 2;
665
666           if (buflen)
667             {
668               if (digitp (buffer))
669                 {
670                   char *q;
671                   int n, m;
672
673                   n = strtol (buffer, &q, 10);
674                   if (q >= (char *)buffer + buflen
675                       || *q == '\x18' || *q == '\n')
676                     m = n;
677                   else
678                     {
679                       if (*q++ != ',' || !digitp (q))
680                         goto next;
681                       m = strtol (q, &q, 10);
682                     }
683
684                   if (buflen < ((unsigned char *)q - buffer))
685                     break;
686
687                   buflen -= ((unsigned char *)q - buffer);
688                   buffer = q;
689
690                   if (buflen && !(*buffer == '\n' || *buffer == '\x18'))
691                     goto next;
692                   app->app_local->pinpad.specified = 1;
693                   app->app_local->pinpad.fixedlen_user = n;
694                   app->app_local->pinpad.fixedlen_admin = m;
695                 }
696             }
697         }
698     next:
699       /* Skip to FS (0x18) or LF (\n).  */
700       for (; buflen && *buffer != '\x18' && *buffer != '\n'; buflen--)
701         buffer++;
702     }
703   while (buflen && *buffer != '\n');
704
705   xfree (relptr);
706 }
707
708 /* Note, that FPR must be at least 20 bytes. */
709 static gpg_error_t
710 store_fpr (app_t app, int keynumber, u32 timestamp,
711            const unsigned char *m, size_t mlen,
712            const unsigned char *e, size_t elen,
713            unsigned char *fpr, unsigned int card_version)
714 {
715   unsigned int n, nbits;
716   unsigned char *buffer, *p;
717   int tag, tag2;
718   int rc;
719
720   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
721     ;
722   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
723     ;
724
725   n = 6 + 2 + mlen + 2 + elen;
726   p = buffer = xtrymalloc (3 + n);
727   if (!buffer)
728     return gpg_error_from_syserror ();
729
730   *p++ = 0x99;     /* ctb */
731   *p++ = n >> 8;   /* 2 byte length header */
732   *p++ = n;
733   *p++ = 4;        /* key packet version */
734   *p++ = timestamp >> 24;
735   *p++ = timestamp >> 16;
736   *p++ = timestamp >>  8;
737   *p++ = timestamp;
738   *p++ = 1; /* RSA */
739   nbits = count_bits (m, mlen);
740   *p++ = nbits >> 8;
741   *p++ = nbits;
742   memcpy (p, m, mlen); p += mlen;
743   nbits = count_bits (e, elen);
744   *p++ = nbits >> 8;
745   *p++ = nbits;
746   memcpy (p, e, elen); p += elen;
747
748   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
749
750   xfree (buffer);
751
752   tag = (card_version > 0x0007? 0xC7 : 0xC6) + keynumber;
753   flush_cache_item (app, 0xC5);
754   tag2 = 0xCE + keynumber;
755   flush_cache_item (app, 0xCD);
756
757   rc = iso7816_put_data (app->slot, 0, tag, fpr, 20);
758   if (rc)
759     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
760
761   if (!rc && card_version > 0x0100)
762     {
763       unsigned char buf[4];
764
765       buf[0] = timestamp >> 24;
766       buf[1] = timestamp >> 16;
767       buf[2] = timestamp >>  8;
768       buf[3] = timestamp;
769
770       rc = iso7816_put_data (app->slot, 0, tag2, buf, 4);
771       if (rc)
772         log_error (_("failed to store the creation date: %s\n"),
773                    gpg_strerror (rc));
774     }
775
776   return rc;
777 }
778
779
780 static void
781 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
782                       int number, const unsigned char *fpr)
783 {
784   int i;
785   char buf[41];
786   char numbuf[25];
787
788   for (i=0; i < 20 && !fpr[i]; i++)
789     ;
790   if (i==20)
791     return; /* All zero. */
792   bin2hex (fpr, 20, buf);
793   if (number == -1)
794     *numbuf = 0; /* Don't print the key number */
795   else
796     sprintf (numbuf, "%d", number);
797   send_status_info (ctrl, keyword,
798                     numbuf, (size_t)strlen(numbuf),
799                     buf, (size_t)strlen (buf), NULL, 0);
800 }
801
802 static void
803 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
804                           int number, const unsigned char *stamp)
805 {
806   char numbuf1[50], numbuf2[50];
807   unsigned long value;
808
809   value = buf32_to_ulong (stamp);
810   if (!value)
811     return;
812   sprintf (numbuf1, "%d", number);
813   sprintf (numbuf2, "%lu", value);
814   send_status_info (ctrl, keyword,
815                     numbuf1, (size_t)strlen(numbuf1),
816                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
817 }
818
819 static void
820 send_key_data (ctrl_t ctrl, const char *name,
821                const unsigned char *a, size_t alen)
822 {
823   char *buffer, *buf;
824   size_t buflen;
825
826   buffer = buf = bin2hex (a, alen, NULL);
827   if (!buffer)
828     {
829       log_error ("memory allocation error in send_key_data\n");
830       return;
831     }
832   buflen = strlen (buffer);
833
834   /* 768 is the hexified size for the modulus of an 3072 bit key.  We
835      use extra chunks to transmit larger data (i.e for 4096 bit).  */
836   for ( ;buflen > 768; buflen -= 768, buf += 768)
837     send_status_info (ctrl, "KEY-DATA",
838                       "-", 1,
839                       buf, 768,
840                       NULL, 0);
841   send_status_info (ctrl, "KEY-DATA",
842                     name, (size_t)strlen(name),
843                     buf, buflen,
844                     NULL, 0);
845   xfree (buffer);
846 }
847
848
849 static void
850 send_key_attr (ctrl_t ctrl, app_t app, const char *keyword, int number)
851 {
852   char buffer[200];
853
854   assert (number >=0 && number < DIM(app->app_local->keyattr));
855
856   /* We only support RSA thus the algo identifier is fixed to 1.  */
857   snprintf (buffer, sizeof buffer, "%d 1 %u %u %d",
858             number+1,
859             app->app_local->keyattr[number].n_bits,
860             app->app_local->keyattr[number].e_bits,
861             app->app_local->keyattr[number].format);
862   send_status_direct (ctrl, keyword, buffer);
863 }
864
865
866 /* Implement the GETATTR command.  This is similar to the LEARN
867    command but returns just one value via the status interface. */
868 static gpg_error_t
869 do_getattr (app_t app, ctrl_t ctrl, const char *name)
870 {
871   static struct {
872     const char *name;
873     int tag;
874     int special;
875   } table[] = {
876     { "DISP-NAME",    0x005B },
877     { "LOGIN-DATA",   0x005E },
878     { "DISP-LANG",    0x5F2D },
879     { "DISP-SEX",     0x5F35 },
880     { "PUBKEY-URL",   0x5F50 },
881     { "KEY-FPR",      0x00C5, 3 },
882     { "KEY-TIME",     0x00CD, 4 },
883     { "KEY-ATTR",     0x0000, -5 },
884     { "CA-FPR",       0x00C6, 3 },
885     { "CHV-STATUS",   0x00C4, 1 },
886     { "SIG-COUNTER",  0x0093, 2 },
887     { "SERIALNO",     0x004F, -1 },
888     { "AID",          0x004F },
889     { "EXTCAP",       0x0000, -2 },
890     { "PRIVATE-DO-1", 0x0101 },
891     { "PRIVATE-DO-2", 0x0102 },
892     { "PRIVATE-DO-3", 0x0103 },
893     { "PRIVATE-DO-4", 0x0104 },
894     { "$AUTHKEYID",   0x0000, -3 },
895     { "$DISPSERIALNO",0x0000, -4 },
896     { NULL, 0 }
897   };
898   int idx, i, rc;
899   void *relptr;
900   unsigned char *value;
901   size_t valuelen;
902
903   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
904     ;
905   if (!table[idx].name)
906     return gpg_error (GPG_ERR_INV_NAME);
907
908   if (table[idx].special == -1)
909     {
910       /* The serial number is very special.  We could have used the
911          AID DO to retrieve it, but we have it already in the app
912          context and the stamp argument is required anyway which we
913          can't by other means. The AID DO is available anyway but not
914          hex formatted. */
915       char *serial;
916       time_t stamp;
917       char tmp[50];
918
919       if (!app_get_serial_and_stamp (app, &serial, &stamp))
920         {
921           sprintf (tmp, "%lu", (unsigned long)stamp);
922           send_status_info (ctrl, "SERIALNO",
923                             serial, strlen (serial),
924                             tmp, strlen (tmp),
925                             NULL, 0);
926           xfree (serial);
927         }
928       return 0;
929     }
930   if (table[idx].special == -2)
931     {
932       char tmp[100];
933
934       snprintf (tmp, sizeof tmp,
935                 "gc=%d ki=%d fc=%d pd=%d mcl3=%u aac=%d sm=%d",
936                 app->app_local->extcap.get_challenge,
937                 app->app_local->extcap.key_import,
938                 app->app_local->extcap.change_force_chv,
939                 app->app_local->extcap.private_dos,
940                 app->app_local->extcap.max_certlen_3,
941                 app->app_local->extcap.algo_attr_change,
942                 (app->app_local->extcap.sm_supported
943                  ? (app->app_local->extcap.sm_aes128? 7 : 2)
944                  : 0));
945       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
946       return 0;
947     }
948   if (table[idx].special == -3)
949     {
950       char const tmp[] = "OPENPGP.3";
951       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
952       return 0;
953     }
954   if (table[idx].special == -4)
955     {
956       char *serial;
957       time_t stamp;
958
959       if (!app_get_serial_and_stamp (app, &serial, &stamp))
960         {
961           if (strlen (serial) > 16+12)
962             {
963               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
964               xfree (serial);
965               return 0;
966             }
967           xfree (serial);
968         }
969       return gpg_error (GPG_ERR_INV_NAME);
970     }
971   if (table[idx].special == -5)
972     {
973       for (i=0; i < 3; i++)
974         send_key_attr (ctrl, app, table[idx].name, i);
975       return 0;
976     }
977
978   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
979   if (relptr)
980     {
981       if (table[idx].special == 1)
982         {
983           char numbuf[7*23];
984
985           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
986             sprintf (numbuf+strlen (numbuf), " %d", value[i]);
987           send_status_info (ctrl, table[idx].name,
988                             numbuf, strlen (numbuf), NULL, 0);
989         }
990       else if (table[idx].special == 2)
991         {
992           char numbuf[50];
993
994           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
995           send_status_info (ctrl, table[idx].name,
996                             numbuf, strlen (numbuf), NULL, 0);
997         }
998       else if (table[idx].special == 3)
999         {
1000           if (valuelen >= 60)
1001             for (i=0; i < 3; i++)
1002               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
1003         }
1004       else if (table[idx].special == 4)
1005         {
1006           if (valuelen >= 12)
1007             for (i=0; i < 3; i++)
1008               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
1009         }
1010       else
1011         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
1012
1013       xfree (relptr);
1014     }
1015   return rc;
1016 }
1017
1018 /* Retrieve the fingerprint from the card inserted in SLOT and write
1019    the according hex representation to FPR.  Caller must have provide
1020    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
1021    error code. */
1022 #if GNUPG_MAJOR_VERSION > 1
1023 static gpg_error_t
1024 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
1025 {
1026   gpg_error_t err = 0;
1027   void *relptr;
1028   unsigned char *value;
1029   size_t valuelen;
1030
1031   assert (keyno >=0 && keyno <= 2);
1032
1033   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
1034   if (relptr && valuelen >= 60)
1035     bin2hex (value+keyno*20, 20, fpr);
1036   else
1037     err = gpg_error (GPG_ERR_NOT_FOUND);
1038   xfree (relptr);
1039   return err;
1040 }
1041 #endif /*GNUPG_MAJOR_VERSION > 1*/
1042
1043
1044 /* Retrieve the public key material for the RSA key, whose fingerprint
1045    is FPR, from gpg output, which can be read through the stream FP.
1046    The RSA modulus will be stored at the address of M and MLEN, the
1047    public exponent at E and ELEN.  Returns zero on success, an error
1048    code on failure.  Caller must release the allocated buffers at M
1049    and E if the function returns success.  */
1050 #if GNUPG_MAJOR_VERSION > 1
1051 static gpg_error_t
1052 retrieve_key_material (FILE *fp, const char *hexkeyid,
1053                        const unsigned char **m, size_t *mlen,
1054                        const unsigned char **e, size_t *elen)
1055 {
1056   gcry_error_t err = 0;
1057   char *line = NULL;    /* read_line() buffer. */
1058   size_t line_size = 0; /* Helper for for read_line. */
1059   int found_key = 0;    /* Helper to find a matching key. */
1060   unsigned char *m_new = NULL;
1061   unsigned char *e_new = NULL;
1062   size_t m_new_n = 0;
1063   size_t e_new_n = 0;
1064
1065   /* Loop over all records until we have found the subkey
1066      corresponding to the fingerprint. Inm general the first record
1067      should be the pub record, but we don't rely on that.  Given that
1068      we only need to look at one key, it is sufficient to compare the
1069      keyid so that we don't need to look at "fpr" records. */
1070   for (;;)
1071     {
1072       char *p;
1073       char *fields[6];
1074       int nfields;
1075       size_t max_length;
1076       gcry_mpi_t mpi;
1077       int i;
1078
1079       max_length = 4096;
1080       i = read_line (fp, &line, &line_size, &max_length);
1081       if (!i)
1082         break; /* EOF. */
1083       if (i < 0)
1084         {
1085           err = gpg_error_from_syserror ();
1086           goto leave; /* Error. */
1087         }
1088       if (!max_length)
1089         {
1090           err = gpg_error (GPG_ERR_TRUNCATED);
1091           goto leave;  /* Line truncated - we better stop processing.  */
1092         }
1093
1094       /* Parse the line into fields. */
1095       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
1096         {
1097           fields[nfields] = p;
1098           p = strchr (p, ':');
1099           if (p)
1100             *(p++) = 0;
1101         }
1102       if (!nfields)
1103         continue; /* No fields at all - skip line.  */
1104
1105       if (!found_key)
1106         {
1107           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1108                && nfields > 4 && !strcmp (fields[4], hexkeyid))
1109             found_key = 1;
1110           continue;
1111         }
1112
1113       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
1114         break; /* Next key - stop.  */
1115
1116       if ( strcmp (fields[0], "pkd") )
1117         continue; /* Not a key data record.  */
1118       i = 0; /* Avoid erroneous compiler warning. */
1119       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
1120            || (!i && m_new) || (i && e_new))
1121         {
1122           err = gpg_error (GPG_ERR_GENERAL);
1123           goto leave; /* Error: Invalid key data record or not an RSA key.  */
1124         }
1125
1126       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
1127       if (err)
1128         mpi = NULL;
1129       else if (!i)
1130         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
1131       else
1132         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
1133       gcry_mpi_release (mpi);
1134       if (err)
1135         goto leave;
1136     }
1137
1138   if (m_new && e_new)
1139     {
1140       *m = m_new;
1141       *mlen = m_new_n;
1142       m_new = NULL;
1143       *e = e_new;
1144       *elen = e_new_n;
1145       e_new = NULL;
1146     }
1147   else
1148     err = gpg_error (GPG_ERR_GENERAL);
1149
1150  leave:
1151   xfree (m_new);
1152   xfree (e_new);
1153   xfree (line);
1154   return err;
1155 }
1156 #endif /*GNUPG_MAJOR_VERSION > 1*/
1157
1158
1159 /* Get the public key for KEYNO and store it as an S-expresion with
1160    the APP handle.  On error that field gets cleared.  If we already
1161    know about the public key we will just return.  Note that this does
1162    not mean a key is available; this is soley indicated by the
1163    presence of the app->app_local->pk[KEYNO-1].key field.
1164
1165    Note that GnuPG 1.x does not need this and it would be too time
1166    consuming to send it just for the fun of it. However, given that we
1167    use the same code in gpg 1.4, we can't use the gcry S-expresion
1168    here but need to open encode it. */
1169 #if GNUPG_MAJOR_VERSION > 1
1170 static gpg_error_t
1171 get_public_key (app_t app, int keyno)
1172 {
1173   gpg_error_t err = 0;
1174   unsigned char *buffer;
1175   const unsigned char *keydata, *m, *e;
1176   size_t buflen, keydatalen, mlen, elen;
1177   unsigned char *mbuf = NULL;
1178   unsigned char *ebuf = NULL;
1179   char *keybuf = NULL;
1180   char *keybuf_p;
1181
1182   if (keyno < 1 || keyno > 3)
1183     return gpg_error (GPG_ERR_INV_ID);
1184   keyno--;
1185
1186   /* Already cached? */
1187   if (app->app_local->pk[keyno].read_done)
1188     return 0;
1189
1190   xfree (app->app_local->pk[keyno].key);
1191   app->app_local->pk[keyno].key = NULL;
1192   app->app_local->pk[keyno].keylen = 0;
1193
1194   m = e = NULL; /* (avoid cc warning) */
1195
1196   if (app->card_version > 0x0100)
1197     {
1198       int exmode, le_value;
1199
1200       /* We may simply read the public key out of these cards.  */
1201       if (app->app_local->cardcap.ext_lc_le)
1202         {
1203           exmode = 1;    /* Use extended length.  */
1204           le_value = app->app_local->extcap.max_rsp_data;
1205         }
1206       else
1207         {
1208           exmode = 0;
1209           le_value = 256; /* Use legacy value. */
1210         }
1211
1212       err = iso7816_read_public_key
1213         (app->slot, exmode,
1214          (const unsigned char*)(keyno == 0? "\xB6" :
1215                                 keyno == 1? "\xB8" : "\xA4"), 2,
1216          le_value,
1217          &buffer, &buflen);
1218       if (err)
1219         {
1220           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1221           goto leave;
1222         }
1223
1224       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1225       if (!keydata)
1226         {
1227           err = gpg_error (GPG_ERR_CARD);
1228           log_error (_("response does not contain the public key data\n"));
1229           goto leave;
1230         }
1231
1232       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1233       if (!m)
1234         {
1235           err = gpg_error (GPG_ERR_CARD);
1236           log_error (_("response does not contain the RSA modulus\n"));
1237           goto leave;
1238         }
1239
1240
1241       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1242       if (!e)
1243         {
1244           err = gpg_error (GPG_ERR_CARD);
1245           log_error (_("response does not contain the RSA public exponent\n"));
1246           goto leave;
1247         }
1248
1249       /* Prepend numbers with a 0 if needed.  */
1250       if (mlen && (*m & 0x80))
1251         {
1252           mbuf = xtrymalloc ( mlen + 1);
1253           if (!mbuf)
1254             {
1255               err = gpg_error_from_syserror ();
1256               goto leave;
1257             }
1258           *mbuf = 0;
1259           memcpy (mbuf+1, m, mlen);
1260           mlen++;
1261           m = mbuf;
1262         }
1263       if (elen && (*e & 0x80))
1264         {
1265           ebuf = xtrymalloc ( elen + 1);
1266           if (!ebuf)
1267             {
1268               err = gpg_error_from_syserror ();
1269               goto leave;
1270             }
1271           *ebuf = 0;
1272           memcpy (ebuf+1, e, elen);
1273           elen++;
1274           e = ebuf;
1275         }
1276
1277     }
1278   else
1279     {
1280       /* Due to a design problem in v1.0 cards we can't get the public
1281          key out of these cards without doing a verify on CHV3.
1282          Clearly that is not an option and thus we try to locate the
1283          key using an external helper.
1284
1285          The helper we use here is gpg itself, which should know about
1286          the key in any case.  */
1287
1288       char fpr[41];
1289       char *hexkeyid;
1290       char *command = NULL;
1291       FILE *fp;
1292       int ret;
1293
1294       buffer = NULL; /* We don't need buffer.  */
1295
1296       err = retrieve_fpr_from_card (app, keyno, fpr);
1297       if (err)
1298         {
1299           log_error ("error while retrieving fpr from card: %s\n",
1300                      gpg_strerror (err));
1301           goto leave;
1302         }
1303       hexkeyid = fpr + 24;
1304
1305       ret = estream_asprintf (&command,
1306                               "gpg --list-keys --with-colons --with-key-data '%s'",
1307                               fpr);
1308       if (ret < 0)
1309         {
1310           err = gpg_error_from_syserror ();
1311           goto leave;
1312         }
1313
1314       fp = popen (command, "r");
1315       xfree (command);
1316       if (!fp)
1317         {
1318           err = gpg_error_from_syserror ();
1319           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1320           goto leave;
1321         }
1322
1323       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1324       pclose (fp);
1325       if (err)
1326         {
1327           log_error ("error while retrieving key material through pipe: %s\n",
1328                      gpg_strerror (err));
1329           goto leave;
1330         }
1331     }
1332
1333   /* Allocate a buffer to construct the S-expression.  */
1334   /* FIXME: We should provide a generalized S-expression creation
1335      mechanism. */
1336   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1337   if (!keybuf)
1338     {
1339       err = gpg_error_from_syserror ();
1340       goto leave;
1341     }
1342
1343   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1344   keybuf_p = keybuf + strlen (keybuf);
1345   memcpy (keybuf_p, m, mlen);
1346   keybuf_p += mlen;
1347   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1348   keybuf_p += strlen (keybuf_p);
1349   memcpy (keybuf_p, e, elen);
1350   keybuf_p += elen;
1351   strcpy (keybuf_p, ")))");
1352   keybuf_p += strlen (keybuf_p);
1353
1354   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1355   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1356
1357  leave:
1358   /* Set a flag to indicate that we tried to read the key.  */
1359   app->app_local->pk[keyno].read_done = 1;
1360
1361   xfree (buffer);
1362   xfree (mbuf);
1363   xfree (ebuf);
1364   return 0;
1365 }
1366 #endif /* GNUPG_MAJOR_VERSION > 1 */
1367
1368
1369
1370 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1371    This is used by the LEARN command. */
1372 static gpg_error_t
1373 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1374 {
1375   gpg_error_t err = 0;
1376   /* Note that GnuPG 1.x does not need this and it would be too time
1377      consuming to send it just for the fun of it. */
1378 #if GNUPG_MAJOR_VERSION > 1
1379   unsigned char grip[20];
1380   char gripstr[41];
1381   char idbuf[50];
1382
1383   err = get_public_key (app, keyno);
1384   if (err)
1385     goto leave;
1386
1387   assert (keyno >= 1 && keyno <= 3);
1388   if (!app->app_local->pk[keyno-1].key)
1389     goto leave; /* No such key - ignore. */
1390
1391   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1392                                  app->app_local->pk[keyno-1].keylen,
1393                                  grip);
1394   if (err)
1395     goto leave;
1396
1397   bin2hex (grip, 20, gripstr);
1398
1399   sprintf (idbuf, "OPENPGP.%d", keyno);
1400   send_status_info (ctrl, "KEYPAIRINFO",
1401                     gripstr, 40,
1402                     idbuf, strlen (idbuf),
1403                     NULL, (size_t)0);
1404
1405  leave:
1406 #endif /* GNUPG_MAJOR_VERSION > 1 */
1407
1408   return err;
1409 }
1410
1411
1412 /* Handle the LEARN command for OpenPGP.  */
1413 static gpg_error_t
1414 do_learn_status (app_t app, ctrl_t ctrl, unsigned int flags)
1415 {
1416   (void)flags;
1417
1418   do_getattr (app, ctrl, "EXTCAP");
1419   do_getattr (app, ctrl, "DISP-NAME");
1420   do_getattr (app, ctrl, "DISP-LANG");
1421   do_getattr (app, ctrl, "DISP-SEX");
1422   do_getattr (app, ctrl, "PUBKEY-URL");
1423   do_getattr (app, ctrl, "LOGIN-DATA");
1424   do_getattr (app, ctrl, "KEY-FPR");
1425   if (app->card_version > 0x0100)
1426     do_getattr (app, ctrl, "KEY-TIME");
1427   do_getattr (app, ctrl, "CA-FPR");
1428   do_getattr (app, ctrl, "CHV-STATUS");
1429   do_getattr (app, ctrl, "SIG-COUNTER");
1430   if (app->app_local->extcap.private_dos)
1431     {
1432       do_getattr (app, ctrl, "PRIVATE-DO-1");
1433       do_getattr (app, ctrl, "PRIVATE-DO-2");
1434       if (app->did_chv2)
1435         do_getattr (app, ctrl, "PRIVATE-DO-3");
1436       if (app->did_chv3)
1437         do_getattr (app, ctrl, "PRIVATE-DO-4");
1438     }
1439   send_keypair_info (app, ctrl, 1);
1440   send_keypair_info (app, ctrl, 2);
1441   send_keypair_info (app, ctrl, 3);
1442   /* Note: We do not send the Cardholder Certificate, because that is
1443      relativly long and for OpenPGP applications not really needed.  */
1444   return 0;
1445 }
1446
1447
1448 /* Handle the READKEY command for OpenPGP.  On success a canonical
1449    encoded S-expression with the public key will get stored at PK and
1450    its length (for assertions) at PKLEN; the caller must release that
1451    buffer. On error PK and PKLEN are not changed and an error code is
1452    returned.  */
1453 static gpg_error_t
1454 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1455 {
1456 #if GNUPG_MAJOR_VERSION > 1
1457   gpg_error_t err;
1458   int keyno;
1459   unsigned char *buf;
1460
1461   if (!strcmp (keyid, "OPENPGP.1"))
1462     keyno = 1;
1463   else if (!strcmp (keyid, "OPENPGP.2"))
1464     keyno = 2;
1465   else if (!strcmp (keyid, "OPENPGP.3"))
1466     keyno = 3;
1467   else
1468     return gpg_error (GPG_ERR_INV_ID);
1469
1470   err = get_public_key (app, keyno);
1471   if (err)
1472     return err;
1473
1474   buf = app->app_local->pk[keyno-1].key;
1475   if (!buf)
1476     return gpg_error (GPG_ERR_NO_PUBKEY);
1477   *pklen = app->app_local->pk[keyno-1].keylen;;
1478   *pk = xtrymalloc (*pklen);
1479   if (!*pk)
1480     {
1481       err = gpg_error_from_syserror ();
1482       *pklen = 0;
1483       return err;
1484     }
1485   memcpy (*pk, buf, *pklen);
1486   return 0;
1487 #else
1488   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1489 #endif
1490 }
1491
1492 /* Read the standard certificate of an OpenPGP v2 card.  It is
1493    returned in a freshly allocated buffer with that address stored at
1494    CERT and the length of the certificate stored at CERTLEN.  CERTID
1495    needs to be set to "OPENPGP.3".  */
1496 static gpg_error_t
1497 do_readcert (app_t app, const char *certid,
1498              unsigned char **cert, size_t *certlen)
1499 {
1500 #if GNUPG_MAJOR_VERSION > 1
1501   gpg_error_t err;
1502   unsigned char *buffer;
1503   size_t buflen;
1504   void *relptr;
1505
1506   *cert = NULL;
1507   *certlen = 0;
1508   if (strcmp (certid, "OPENPGP.3"))
1509     return gpg_error (GPG_ERR_INV_ID);
1510   if (!app->app_local->extcap.is_v2)
1511     return gpg_error (GPG_ERR_NOT_FOUND);
1512
1513   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1514   if (!relptr)
1515     return gpg_error (GPG_ERR_NOT_FOUND);
1516
1517   if (!buflen)
1518     err = gpg_error (GPG_ERR_NOT_FOUND);
1519   else if (!(*cert = xtrymalloc (buflen)))
1520     err = gpg_error_from_syserror ();
1521   else
1522     {
1523       memcpy (*cert, buffer, buflen);
1524       *certlen = buflen;
1525       err  = 0;
1526     }
1527   xfree (relptr);
1528   return err;
1529 #else
1530   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1531 #endif
1532 }
1533
1534
1535 /* Decide if we use the pinpad of the reader for PIN input according
1536    to the user preference on the card, and the capability of the
1537    reader.  This routine is only called when the reader has pinpad.
1538    Returns 0 if we use pinpad, 1 otherwise.  */
1539 static int
1540 check_pinpad_request (app_t app, pininfo_t *pininfo, int admin_pin)
1541 {
1542   if (app->app_local->pinpad.specified == 0) /* No preference on card.  */
1543     {
1544       if (pininfo->fixedlen == 0) /* Reader has varlen capability.  */
1545         return 0;                 /* Then, use pinpad.  */
1546       else
1547         /*
1548          * Reader has limited capability, and it may not match PIN of
1549          * the card.
1550          */
1551         return 1;
1552     }
1553
1554   if (admin_pin)
1555     pininfo->fixedlen = app->app_local->pinpad.fixedlen_admin;
1556   else
1557     pininfo->fixedlen = app->app_local->pinpad.fixedlen_user;
1558
1559   if (pininfo->fixedlen == 0    /* User requests disable pinpad.  */
1560       || pininfo->fixedlen < pininfo->minlen
1561       || pininfo->fixedlen > pininfo->maxlen
1562       /* Reader doesn't have the capability to input a PIN which
1563        * length is FIXEDLEN.  */)
1564     return 1;
1565
1566   return 0;
1567 }
1568
1569
1570 /* Verify a CHV either using using the pinentry or if possibile by
1571    using a pinpad.  PINCB and PINCB_ARG describe the usual callback
1572    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1573    used with CHV1.  PINVALUE is the address of a pointer which will
1574    receive a newly allocated block with the actual PIN (this is useful
1575    in case that PIN shall be used for another verify operation).  The
1576    caller needs to free this value.  If the function returns with
1577    success and NULL is stored at PINVALUE, the caller should take this
1578    as an indication that the pinpad has been used.
1579    */
1580 static gpg_error_t
1581 verify_a_chv (app_t app,
1582               gpg_error_t (*pincb)(void*, const char *, char **),
1583               void *pincb_arg,
1584               int chvno, unsigned long sigcount, char **pinvalue)
1585 {
1586   int rc = 0;
1587   char *prompt_buffer = NULL;
1588   const char *prompt;
1589   pininfo_t pininfo;
1590   int minlen = 6;
1591
1592   assert (chvno == 1 || chvno == 2);
1593
1594   *pinvalue = NULL;
1595
1596   if (chvno == 2 && app->app_local->flags.def_chv2)
1597     {
1598       /* Special case for def_chv2 mechanism. */
1599       if (opt.verbose)
1600         log_info (_("using default PIN as %s\n"), "CHV2");
1601       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1602       if (rc)
1603         {
1604           /* Verification of CHV2 with the default PIN failed,
1605              although the card pretends to have the default PIN set as
1606              CHV2.  We better disable the def_chv2 flag now. */
1607           log_info (_("failed to use default PIN as %s: %s"
1608                       " - disabling further default use\n"),
1609                     "CHV2", gpg_strerror (rc));
1610           app->app_local->flags.def_chv2 = 0;
1611         }
1612       return rc;
1613     }
1614
1615   memset (&pininfo, 0, sizeof pininfo);
1616   pininfo.fixedlen = -1;
1617   pininfo.minlen = minlen;
1618
1619
1620   if (chvno == 1)
1621     {
1622 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1623       size_t promptsize = strlen (PROMPTSTRING) + 50;
1624
1625       prompt_buffer = xtrymalloc (promptsize);
1626       if (!prompt_buffer)
1627         return gpg_error_from_syserror ();
1628       snprintf (prompt_buffer, promptsize-1, PROMPTSTRING, sigcount);
1629       prompt = prompt_buffer;
1630 #undef PROMPTSTRING
1631     }
1632   else
1633     prompt = _("||Please enter the PIN");
1634
1635
1636   if (!opt.disable_pinpad
1637       && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
1638       && !check_pinpad_request (app, &pininfo, 0))
1639     {
1640       /* The reader supports the verify command through the pinpad.
1641          Note that the pincb appends a text to the prompt telling the
1642          user to use the pinpad. */
1643       rc = pincb (pincb_arg, prompt, NULL);
1644       prompt = NULL;
1645       xfree (prompt_buffer);
1646       prompt_buffer = NULL;
1647       if (rc)
1648         {
1649           log_info (_("PIN callback returned error: %s\n"),
1650                     gpg_strerror (rc));
1651           return rc;
1652         }
1653       rc = iso7816_verify_kp (app->slot, 0x80+chvno, &pininfo);
1654       /* Dismiss the prompt. */
1655       pincb (pincb_arg, NULL, NULL);
1656
1657       assert (!*pinvalue);
1658     }
1659   else
1660     {
1661       /* The reader has no pinpad or we don't want to use it. */
1662       rc = pincb (pincb_arg, prompt, pinvalue);
1663       prompt = NULL;
1664       xfree (prompt_buffer);
1665       prompt_buffer = NULL;
1666       if (rc)
1667         {
1668           log_info (_("PIN callback returned error: %s\n"),
1669                     gpg_strerror (rc));
1670           return rc;
1671         }
1672
1673       if (strlen (*pinvalue) < minlen)
1674         {
1675           log_error (_("PIN for CHV%d is too short;"
1676                        " minimum length is %d\n"), chvno, minlen);
1677           xfree (*pinvalue);
1678           *pinvalue = NULL;
1679           return gpg_error (GPG_ERR_BAD_PIN);
1680         }
1681
1682       rc = iso7816_verify (app->slot, 0x80+chvno,
1683                            *pinvalue, strlen (*pinvalue));
1684     }
1685
1686   if (rc)
1687     {
1688       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1689       xfree (*pinvalue);
1690       *pinvalue = NULL;
1691       flush_cache_after_error (app);
1692     }
1693
1694   return rc;
1695 }
1696
1697
1698 /* Verify CHV2 if required.  Depending on the configuration of the
1699    card CHV1 will also be verified. */
1700 static gpg_error_t
1701 verify_chv2 (app_t app,
1702              gpg_error_t (*pincb)(void*, const char *, char **),
1703              void *pincb_arg)
1704 {
1705   int rc;
1706   char *pinvalue;
1707
1708   if (app->did_chv2)
1709     return 0;  /* We already verified CHV2.  */
1710
1711   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1712   if (rc)
1713     return rc;
1714   app->did_chv2 = 1;
1715
1716   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1717     {
1718       /* For convenience we verify CHV1 here too.  We do this only if
1719          the card is not configured to require a verification before
1720          each CHV1 controlled operation (force_chv1) and if we are not
1721          using the pinpad (PINVALUE == NULL). */
1722       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1723       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1724         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1725       if (rc)
1726         {
1727           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1728           flush_cache_after_error (app);
1729         }
1730       else
1731         app->did_chv1 = 1;
1732     }
1733
1734   xfree (pinvalue);
1735
1736   return rc;
1737 }
1738
1739
1740 /* Build the prompt to enter the Admin PIN.  The prompt depends on the
1741    current sdtate of the card.  */
1742 static gpg_error_t
1743 build_enter_admin_pin_prompt (app_t app, char **r_prompt)
1744 {
1745   void *relptr;
1746   unsigned char *value;
1747   size_t valuelen;
1748   int remaining;
1749   char *prompt;
1750
1751   *r_prompt = NULL;
1752
1753   relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1754   if (!relptr || valuelen < 7)
1755     {
1756       log_error (_("error retrieving CHV status from card\n"));
1757       xfree (relptr);
1758       return gpg_error (GPG_ERR_CARD);
1759     }
1760   if (value[6] == 0)
1761     {
1762       log_info (_("card is permanently locked!\n"));
1763       xfree (relptr);
1764       return gpg_error (GPG_ERR_BAD_PIN);
1765     }
1766   remaining = value[6];
1767   xfree (relptr);
1768
1769   log_info(_("%d Admin PIN attempts remaining before card"
1770              " is permanently locked\n"), remaining);
1771
1772   if (remaining < 3)
1773     {
1774       /* TRANSLATORS: Do not translate the "|A|" prefix but keep it at
1775          the start of the string.  Use %%0A to force a linefeed.  */
1776       prompt = xtryasprintf (_("|A|Please enter the Admin PIN%%0A"
1777                                "[remaining attempts: %d]"), remaining);
1778     }
1779   else
1780     prompt = xtrystrdup (_("|A|Please enter the Admin PIN"));
1781
1782   if (!prompt)
1783     return gpg_error_from_syserror ();
1784
1785   *r_prompt = prompt;
1786   return 0;
1787 }
1788
1789
1790 /* Verify CHV3 if required. */
1791 static gpg_error_t
1792 verify_chv3 (app_t app,
1793              gpg_error_t (*pincb)(void*, const char *, char **),
1794              void *pincb_arg)
1795 {
1796   int rc = 0;
1797
1798 #if GNUPG_MAJOR_VERSION != 1
1799   if (!opt.allow_admin)
1800     {
1801       log_info (_("access to admin commands is not configured\n"));
1802       return gpg_error (GPG_ERR_EACCES);
1803     }
1804 #endif
1805
1806   if (!app->did_chv3)
1807     {
1808       pininfo_t pininfo;
1809       int minlen = 8;
1810       char *prompt;
1811
1812       memset (&pininfo, 0, sizeof pininfo);
1813       pininfo.fixedlen = -1;
1814       pininfo.minlen = minlen;
1815
1816       rc = build_enter_admin_pin_prompt (app, &prompt);
1817       if (rc)
1818         return rc;
1819
1820       if (!opt.disable_pinpad
1821           && !iso7816_check_pinpad (app->slot, ISO7816_VERIFY, &pininfo)
1822           && !check_pinpad_request (app, &pininfo, 1))
1823         {
1824           /* The reader supports the verify command through the pinpad. */
1825           rc = pincb (pincb_arg, prompt, NULL);
1826           xfree (prompt);
1827           prompt = NULL;
1828           if (rc)
1829             {
1830               log_info (_("PIN callback returned error: %s\n"),
1831                         gpg_strerror (rc));
1832               return rc;
1833             }
1834           rc = iso7816_verify_kp (app->slot, 0x83, &pininfo);
1835           /* Dismiss the prompt. */
1836           pincb (pincb_arg, NULL, NULL);
1837         }
1838       else
1839         {
1840           char *pinvalue;
1841
1842           rc = pincb (pincb_arg, prompt, &pinvalue);
1843           xfree (prompt);
1844           prompt = NULL;
1845           if (rc)
1846             {
1847               log_info (_("PIN callback returned error: %s\n"),
1848                         gpg_strerror (rc));
1849               return rc;
1850             }
1851
1852           if (strlen (pinvalue) < minlen)
1853             {
1854               log_error (_("PIN for CHV%d is too short;"
1855                            " minimum length is %d\n"), 3, minlen);
1856               xfree (pinvalue);
1857               return gpg_error (GPG_ERR_BAD_PIN);
1858             }
1859
1860           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1861           xfree (pinvalue);
1862         }
1863
1864       if (rc)
1865         {
1866           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1867           flush_cache_after_error (app);
1868           return rc;
1869         }
1870       app->did_chv3 = 1;
1871     }
1872   return rc;
1873 }
1874
1875
1876 /* Handle the SETATTR operation. All arguments are already basically
1877    checked. */
1878 static gpg_error_t
1879 do_setattr (app_t app, const char *name,
1880             gpg_error_t (*pincb)(void*, const char *, char **),
1881             void *pincb_arg,
1882             const unsigned char *value, size_t valuelen)
1883 {
1884   gpg_error_t rc;
1885   int idx;
1886   static struct {
1887     const char *name;
1888     int tag;
1889     int need_chv;
1890     int special;
1891     unsigned int need_v2:1;
1892   } table[] = {
1893     { "DISP-NAME",    0x005B, 3 },
1894     { "LOGIN-DATA",   0x005E, 3, 2 },
1895     { "DISP-LANG",    0x5F2D, 3 },
1896     { "DISP-SEX",     0x5F35, 3 },
1897     { "PUBKEY-URL",   0x5F50, 3 },
1898     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1899     { "CA-FPR-1",     0x00CA, 3 },
1900     { "CA-FPR-2",     0x00CB, 3 },
1901     { "CA-FPR-3",     0x00CC, 3 },
1902     { "PRIVATE-DO-1", 0x0101, 2 },
1903     { "PRIVATE-DO-2", 0x0102, 3 },
1904     { "PRIVATE-DO-3", 0x0103, 2 },
1905     { "PRIVATE-DO-4", 0x0104, 3 },
1906     { "CERT-3",       0x7F21, 3, 0, 1 },
1907     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
1908     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
1909     { "KEY-ATTR",     0,      0, 3, 1 },
1910     { NULL, 0 }
1911   };
1912   int exmode;
1913
1914   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1915     ;
1916   if (!table[idx].name)
1917     return gpg_error (GPG_ERR_INV_NAME);
1918   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
1919     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
1920
1921   if (table[idx].special == 3)
1922     return change_keyattr_from_string (app, pincb, pincb_arg, value, valuelen);
1923
1924   switch (table[idx].need_chv)
1925     {
1926     case 2:
1927       rc = verify_chv2 (app, pincb, pincb_arg);
1928       break;
1929     case 3:
1930       rc = verify_chv3 (app, pincb, pincb_arg);
1931       break;
1932     default:
1933       rc = 0;
1934     }
1935   if (rc)
1936     return rc;
1937
1938   /* Flush the cache before writing it, so that the next get operation
1939      will reread the data from the card and thus get synced in case of
1940      errors (e.g. data truncated by the card). */
1941   flush_cache_item (app, table[idx].tag);
1942
1943   if (app->app_local->cardcap.ext_lc_le && valuelen > 254)
1944     exmode = 1;    /* Use extended length w/o a limit.  */
1945   else if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
1946     exmode = -254; /* Command chaining with max. 254 bytes.  */
1947   else
1948     exmode = 0;
1949   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
1950   if (rc)
1951     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1952
1953   if (table[idx].special == 1)
1954     app->force_chv1 = (valuelen && *value == 0);
1955   else if (table[idx].special == 2)
1956     parse_login_data (app);
1957
1958   return rc;
1959 }
1960
1961
1962 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
1963    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
1964    PINCB and PINCB_ARG are the usual arguments for the pinentry
1965    callback.  */
1966 static gpg_error_t
1967 do_writecert (app_t app, ctrl_t ctrl,
1968               const char *certidstr,
1969               gpg_error_t (*pincb)(void*, const char *, char **),
1970               void *pincb_arg,
1971               const unsigned char *certdata, size_t certdatalen)
1972 {
1973   (void)ctrl;
1974 #if GNUPG_MAJOR_VERSION > 1
1975   if (strcmp (certidstr, "OPENPGP.3"))
1976     return gpg_error (GPG_ERR_INV_ID);
1977   if (!certdata || !certdatalen)
1978     return gpg_error (GPG_ERR_INV_ARG);
1979   if (!app->app_local->extcap.is_v2)
1980     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1981   if (certdatalen > app->app_local->extcap.max_certlen_3)
1982     return gpg_error (GPG_ERR_TOO_LARGE);
1983   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1984 #else
1985   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1986 #endif
1987 }
1988
1989
1990
1991 /* Handle the PASSWD command.  The following combinations are
1992    possible:
1993
1994     Flags  CHVNO Vers.  Description
1995     RESET    1   1      Verify CHV3 and set a new CHV1 and CHV2
1996     RESET    1   2      Verify PW3 and set a new PW1.
1997     RESET    2   1      Verify CHV3 and set a new CHV1 and CHV2.
1998     RESET    2   2      Verify PW3 and set a new Reset Code.
1999     RESET    3   any    Returns GPG_ERR_INV_ID.
2000      -       1   1      Verify CHV2 and set a new CHV1 and CHV2.
2001      -       1   2      Verify PW1 and set a new PW1.
2002      -       2   1      Verify CHV2 and set a new CHV1 and CHV2.
2003      -       2   2      Verify Reset Code and set a new PW1.
2004      -       3   any    Verify CHV3/PW3 and set a new CHV3/PW3.
2005  */
2006 static gpg_error_t
2007 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr,
2008                unsigned int flags,
2009                gpg_error_t (*pincb)(void*, const char *, char **),
2010                void *pincb_arg)
2011 {
2012   int rc = 0;
2013   int chvno = atoi (chvnostr);
2014   char *resetcode = NULL;
2015   char *oldpinvalue = NULL;
2016   char *pinvalue = NULL;
2017   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
2018   int set_resetcode = 0;
2019   pininfo_t pininfo;
2020   int use_pinpad = 0;
2021   int minlen = 6;
2022
2023   (void)ctrl;
2024   memset (&pininfo, 0, sizeof pininfo);
2025   pininfo.fixedlen = -1;
2026   pininfo.minlen = minlen;
2027
2028   if (reset_mode && chvno == 3)
2029     {
2030       rc = gpg_error (GPG_ERR_INV_ID);
2031       goto leave;
2032     }
2033
2034   if (!app->app_local->extcap.is_v2)
2035     {
2036       /* Version 1 cards.  */
2037
2038       if (reset_mode || chvno == 3)
2039         {
2040           /* We always require that the PIN is entered. */
2041           app->did_chv3 = 0;
2042           rc = verify_chv3 (app, pincb, pincb_arg);
2043           if (rc)
2044             goto leave;
2045         }
2046       else if (chvno == 1 || chvno == 2)
2047         {
2048           /* On a v1.x card CHV1 and CVH2 should always have the same
2049              value, thus we enforce it here.  */
2050           int save_force = app->force_chv1;
2051
2052           app->force_chv1 = 0;
2053           app->did_chv1 = 0;
2054           app->did_chv2 = 0;
2055           rc = verify_chv2 (app, pincb, pincb_arg);
2056           app->force_chv1 = save_force;
2057           if (rc)
2058             goto leave;
2059         }
2060       else
2061         {
2062           rc = gpg_error (GPG_ERR_INV_ID);
2063           goto leave;
2064         }
2065     }
2066   else
2067     {
2068       /* Version 2 cards.  */
2069
2070       if (!opt.disable_pinpad
2071           && !iso7816_check_pinpad (app->slot,
2072                                     ISO7816_CHANGE_REFERENCE_DATA, &pininfo)
2073           && !check_pinpad_request (app, &pininfo, chvno == 3))
2074         use_pinpad = 1;
2075
2076       if (reset_mode)
2077         {
2078           /* To reset a PIN the Admin PIN is required. */
2079           use_pinpad = 0;
2080           app->did_chv3 = 0;
2081           rc = verify_chv3 (app, pincb, pincb_arg);
2082           if (rc)
2083             goto leave;
2084
2085           if (chvno == 2)
2086             set_resetcode = 1;
2087         }
2088       else if (chvno == 1 || chvno == 3)
2089         {
2090           if (!use_pinpad)
2091             {
2092               char *promptbuf = NULL;
2093               const char *prompt;
2094
2095               if (chvno == 3)
2096                 {
2097                   minlen = 8;
2098                   rc = build_enter_admin_pin_prompt (app, &promptbuf);
2099                   if (rc)
2100                     goto leave;
2101                   prompt = promptbuf;
2102                 }
2103               else
2104                 prompt = _("||Please enter the PIN");
2105               rc = pincb (pincb_arg, prompt, &oldpinvalue);
2106               xfree (promptbuf);
2107               promptbuf = NULL;
2108               if (rc)
2109                 {
2110                   log_info (_("PIN callback returned error: %s\n"),
2111                             gpg_strerror (rc));
2112                   goto leave;
2113                 }
2114
2115               if (strlen (oldpinvalue) < minlen)
2116                 {
2117                   log_info (_("PIN for CHV%d is too short;"
2118                               " minimum length is %d\n"), chvno, minlen);
2119                   rc = gpg_error (GPG_ERR_BAD_PIN);
2120                   goto leave;
2121                 }
2122             }
2123         }
2124       else if (chvno == 2)
2125         {
2126           /* There is no PW2 for v2 cards.  We use this condition to
2127              allow a PW reset using the Reset Code.  */
2128           void *relptr;
2129           unsigned char *value;
2130           size_t valuelen;
2131           int remaining;
2132
2133           use_pinpad = 0;
2134           minlen = 8;
2135           relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2136           if (!relptr || valuelen < 7)
2137             {
2138               log_error (_("error retrieving CHV status from card\n"));
2139               xfree (relptr);
2140               rc = gpg_error (GPG_ERR_CARD);
2141               goto leave;
2142             }
2143           remaining = value[5];
2144           xfree (relptr);
2145           if (!remaining)
2146             {
2147               log_error (_("Reset Code not or not anymore available\n"));
2148               rc = gpg_error (GPG_ERR_BAD_PIN);
2149               goto leave;
2150             }
2151
2152           rc = pincb (pincb_arg,
2153                       _("||Please enter the Reset Code for the card"),
2154                       &resetcode);
2155           if (rc)
2156             {
2157               log_info (_("PIN callback returned error: %s\n"),
2158                         gpg_strerror (rc));
2159               goto leave;
2160             }
2161           if (strlen (resetcode) < minlen)
2162             {
2163               log_info (_("Reset Code is too short; minimum length is %d\n"),
2164                         minlen);
2165               rc = gpg_error (GPG_ERR_BAD_PIN);
2166               goto leave;
2167             }
2168         }
2169       else
2170         {
2171           rc = gpg_error (GPG_ERR_INV_ID);
2172           goto leave;
2173         }
2174     }
2175
2176   if (chvno == 3)
2177     app->did_chv3 = 0;
2178   else
2179     app->did_chv1 = app->did_chv2 = 0;
2180
2181   if (!use_pinpad)
2182     {
2183       /* TRANSLATORS: Do not translate the "|*|" prefixes but
2184          keep it at the start of the string.  We need this elsewhere
2185          to get some infos on the string. */
2186       rc = pincb (pincb_arg, set_resetcode? _("|RN|New Reset Code") :
2187                   chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"),
2188                   &pinvalue);
2189       if (rc)
2190         {
2191           log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
2192           goto leave;
2193         }
2194     }
2195
2196
2197   if (resetcode)
2198     {
2199       char *buffer;
2200
2201       buffer = xtrymalloc (strlen (resetcode) + strlen (pinvalue) + 1);
2202       if (!buffer)
2203         rc = gpg_error_from_syserror ();
2204       else
2205         {
2206           strcpy (stpcpy (buffer, resetcode), pinvalue);
2207           rc = iso7816_reset_retry_counter_with_rc (app->slot, 0x81,
2208                                                     buffer, strlen (buffer));
2209           wipememory (buffer, strlen (buffer));
2210           xfree (buffer);
2211         }
2212     }
2213   else if (set_resetcode)
2214     {
2215       if (strlen (pinvalue) < 8)
2216         {
2217           log_error (_("Reset Code is too short; minimum length is %d\n"), 8);
2218           rc = gpg_error (GPG_ERR_BAD_PIN);
2219         }
2220       else
2221         rc = iso7816_put_data (app->slot, 0, 0xD3,
2222                                pinvalue, strlen (pinvalue));
2223     }
2224   else if (reset_mode)
2225     {
2226       rc = iso7816_reset_retry_counter (app->slot, 0x81,
2227                                         pinvalue, strlen (pinvalue));
2228       if (!rc && !app->app_local->extcap.is_v2)
2229         rc = iso7816_reset_retry_counter (app->slot, 0x82,
2230                                           pinvalue, strlen (pinvalue));
2231     }
2232   else if (!app->app_local->extcap.is_v2)
2233     {
2234       /* Version 1 cards.  */
2235       if (chvno == 1 || chvno == 2)
2236         {
2237           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
2238                                               pinvalue, strlen (pinvalue));
2239           if (!rc)
2240             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
2241                                                 pinvalue, strlen (pinvalue));
2242         }
2243       else /* CHVNO == 3 */
2244         {
2245           rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
2246                                               pinvalue, strlen (pinvalue));
2247         }
2248     }
2249   else
2250     {
2251       /* Version 2 cards.  */
2252       assert (chvno == 1 || chvno == 3);
2253
2254       if (use_pinpad)
2255         {
2256           rc = pincb (pincb_arg,
2257                       chvno == 3 ?
2258                       _("||Please enter the Admin PIN and New Admin PIN") :
2259                       _("||Please enter the PIN and New PIN"), NULL);
2260           if (rc)
2261             {
2262               log_info (_("PIN callback returned error: %s\n"),
2263                         gpg_strerror (rc));
2264               goto leave;
2265             }
2266           rc = iso7816_change_reference_data_kp (app->slot, 0x80 + chvno, 0,
2267                                                  &pininfo);
2268           /* Dismiss the prompt. */
2269           pincb (pincb_arg, NULL, NULL);
2270         }
2271       else
2272         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno,
2273                                             oldpinvalue, strlen (oldpinvalue),
2274                                             pinvalue, strlen (pinvalue));
2275     }
2276
2277   if (pinvalue)
2278     {
2279       wipememory (pinvalue, strlen (pinvalue));
2280       xfree (pinvalue);
2281     }
2282   if (rc)
2283     flush_cache_after_error (app);
2284
2285  leave:
2286   if (resetcode)
2287     {
2288       wipememory (resetcode, strlen (resetcode));
2289       xfree (resetcode);
2290     }
2291   if (oldpinvalue)
2292     {
2293       wipememory (oldpinvalue, strlen (oldpinvalue));
2294       xfree (oldpinvalue);
2295     }
2296   return rc;
2297 }
2298
2299
2300 /* Check whether a key already exists.  KEYIDX is the index of the key
2301    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
2302    error returned if the key already exists.  The flag GENERATING is
2303    only used to print correct messages. */
2304 static gpg_error_t
2305 does_key_exist (app_t app, int keyidx, int generating, int force)
2306 {
2307   const unsigned char *fpr;
2308   unsigned char *buffer;
2309   size_t buflen, n;
2310   int i;
2311
2312   assert (keyidx >=0 && keyidx <= 2);
2313
2314   if (iso7816_get_data (app->slot, 0, 0x006E, &buffer, &buflen))
2315     {
2316       log_error (_("error reading application data\n"));
2317       return gpg_error (GPG_ERR_GENERAL);
2318     }
2319   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2320   if (!fpr || n < 60)
2321     {
2322       log_error (_("error reading fingerprint DO\n"));
2323       xfree (buffer);
2324       return gpg_error (GPG_ERR_GENERAL);
2325     }
2326   fpr += 20*keyidx;
2327   for (i=0; i < 20 && !fpr[i]; i++)
2328     ;
2329   xfree (buffer);
2330   if (i!=20 && !force)
2331     {
2332       log_error (_("key already exists\n"));
2333       return gpg_error (GPG_ERR_EEXIST);
2334     }
2335   else if (i!=20)
2336     log_info (_("existing key will be replaced\n"));
2337   else if (generating)
2338     log_info (_("generating new key\n"));
2339   else
2340     log_info (_("writing new key\n"));
2341   return 0;
2342 }
2343
2344
2345 /* Create a TLV tag and value and store it at BUFFER.  Return the length
2346    of tag and length.  A LENGTH greater than 65535 is truncated. */
2347 static size_t
2348 add_tlv (unsigned char *buffer, unsigned int tag, size_t length)
2349 {
2350   unsigned char *p = buffer;
2351
2352   assert (tag <= 0xffff);
2353   if ( tag > 0xff )
2354     *p++ = tag >> 8;
2355   *p++ = tag;
2356   if (length < 128)
2357     *p++ = length;
2358   else if (length < 256)
2359     {
2360       *p++ = 0x81;
2361       *p++ = length;
2362     }
2363   else
2364     {
2365       if (length > 0xffff)
2366         length = 0xffff;
2367       *p++ = 0x82;
2368       *p++ = length >> 8;
2369       *p++ = length;
2370     }
2371
2372   return p - buffer;
2373 }
2374
2375
2376 /* Build the private key template as specified in the OpenPGP specs
2377    v2.0 section 4.3.3.7.  */
2378 static gpg_error_t
2379 build_privkey_template (app_t app, int keyno,
2380                         const unsigned char *rsa_n, size_t rsa_n_len,
2381                         const unsigned char *rsa_e, size_t rsa_e_len,
2382                         const unsigned char *rsa_p, size_t rsa_p_len,
2383                         const unsigned char *rsa_q, size_t rsa_q_len,
2384                         const unsigned char *rsa_u, size_t rsa_u_len,
2385                         const unsigned char *rsa_dp, size_t rsa_dp_len,
2386                         const unsigned char *rsa_dq, size_t rsa_dq_len,
2387                         unsigned char **result, size_t *resultlen)
2388 {
2389   size_t rsa_e_reqlen;
2390   unsigned char privkey[7*(1+3+3)];
2391   size_t privkey_len;
2392   unsigned char exthdr[2+2+3];
2393   size_t exthdr_len;
2394   unsigned char suffix[2+3];
2395   size_t suffix_len;
2396   unsigned char *tp;
2397   size_t datalen;
2398   unsigned char *template;
2399   size_t template_size;
2400
2401   *result = NULL;
2402   *resultlen = 0;
2403
2404   switch (app->app_local->keyattr[keyno].format)
2405     {
2406     case RSA_STD:
2407     case RSA_STD_N:
2408     case RSA_CRT:
2409     case RSA_CRT_N:
2410       break;
2411
2412     default:
2413       return gpg_error (GPG_ERR_INV_VALUE);
2414     }
2415
2416   /* Get the required length for E. Rounded up to the nearest byte  */
2417   rsa_e_reqlen = (app->app_local->keyattr[keyno].e_bits + 7) / 8;
2418   assert (rsa_e_len <= rsa_e_reqlen);
2419
2420   /* Build the 7f48 cardholder private key template.  */
2421   datalen = 0;
2422   tp = privkey;
2423
2424   tp += add_tlv (tp, 0x91, rsa_e_reqlen);
2425   datalen += rsa_e_reqlen;
2426
2427   tp += add_tlv (tp, 0x92, rsa_p_len);
2428   datalen += rsa_p_len;
2429
2430   tp += add_tlv (tp, 0x93, rsa_q_len);
2431   datalen += rsa_q_len;
2432
2433   if (app->app_local->keyattr[keyno].format == RSA_CRT
2434       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2435     {
2436       tp += add_tlv (tp, 0x94, rsa_u_len);
2437       datalen += rsa_u_len;
2438       tp += add_tlv (tp, 0x95, rsa_dp_len);
2439       datalen += rsa_dp_len;
2440       tp += add_tlv (tp, 0x96, rsa_dq_len);
2441       datalen += rsa_dq_len;
2442     }
2443
2444   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2445       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2446     {
2447       tp += add_tlv (tp, 0x97, rsa_n_len);
2448       datalen += rsa_n_len;
2449     }
2450   privkey_len = tp - privkey;
2451
2452   /* Build the extended header list without the private key template.  */
2453   tp = exthdr;
2454   *tp++ = keyno ==0 ? 0xb6 : keyno == 1? 0xb8 : 0xa4;
2455   *tp++ = 0;
2456   tp += add_tlv (tp, 0x7f48, privkey_len);
2457   exthdr_len = tp - exthdr;
2458
2459   /* Build the 5f48 suffix of the data.  */
2460   tp = suffix;
2461   tp += add_tlv (tp, 0x5f48, datalen);
2462   suffix_len = tp - suffix;
2463
2464   /* Now concatenate everything.  */
2465   template_size = (1 + 3   /* 0x4d and len. */
2466                    + exthdr_len
2467                    + privkey_len
2468                    + suffix_len
2469                    + datalen);
2470   tp = template = xtrymalloc_secure (template_size);
2471   if (!template)
2472     return gpg_error_from_syserror ();
2473
2474   tp += add_tlv (tp, 0x4d, exthdr_len + privkey_len + suffix_len + datalen);
2475   memcpy (tp, exthdr, exthdr_len);
2476   tp += exthdr_len;
2477   memcpy (tp, privkey, privkey_len);
2478   tp += privkey_len;
2479   memcpy (tp, suffix, suffix_len);
2480   tp += suffix_len;
2481
2482   memcpy (tp, rsa_e, rsa_e_len);
2483   if (rsa_e_len < rsa_e_reqlen)
2484     {
2485       /* Right justify E. */
2486       memmove (tp + rsa_e_reqlen - rsa_e_len, tp, rsa_e_len);
2487       memset (tp, 0, rsa_e_reqlen - rsa_e_len);
2488     }
2489   tp += rsa_e_reqlen;
2490
2491   memcpy (tp, rsa_p, rsa_p_len);
2492   tp += rsa_p_len;
2493
2494   memcpy (tp, rsa_q, rsa_q_len);
2495   tp += rsa_q_len;
2496
2497   if (app->app_local->keyattr[keyno].format == RSA_CRT
2498       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2499     {
2500       memcpy (tp, rsa_u, rsa_u_len);
2501       tp += rsa_u_len;
2502       memcpy (tp, rsa_dp, rsa_dp_len);
2503       tp += rsa_dp_len;
2504       memcpy (tp, rsa_dq, rsa_dq_len);
2505       tp += rsa_dq_len;
2506     }
2507
2508   if (app->app_local->keyattr[keyno].format == RSA_STD_N
2509       || app->app_local->keyattr[keyno].format == RSA_CRT_N)
2510     {
2511       memcpy (tp, rsa_n, rsa_n_len);
2512       tp += rsa_n_len;
2513     }
2514
2515   /* Sanity check.  We don't know the exact length because we
2516      allocated 3 bytes for the first length header.  */
2517   assert (tp - template <= template_size);
2518
2519   *result = template;
2520   *resultlen = tp - template;
2521   return 0;
2522 }
2523
2524
2525 /* Helper for do_writekley to change the size of a key.  Not ethat
2526    this deletes the entire key without asking.  */
2527 static gpg_error_t
2528 change_keyattr (app_t app, int keyno, unsigned int nbits,
2529                 gpg_error_t (*pincb)(void*, const char *, char **),
2530                 void *pincb_arg)
2531 {
2532   gpg_error_t err;
2533   unsigned char *buffer;
2534   size_t buflen;
2535   void *relptr;
2536
2537   assert (keyno >=0 && keyno <= 2);
2538
2539   if (nbits > 4096)
2540     return gpg_error (GPG_ERR_TOO_LARGE);
2541
2542   /* Read the current attributes into a buffer.  */
2543   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
2544   if (!relptr)
2545     return gpg_error (GPG_ERR_CARD);
2546   if (buflen < 6 || buffer[0] != 1)
2547     {
2548       /* Attriutes too short or not an RSA key.  */
2549       xfree (relptr);
2550       return gpg_error (GPG_ERR_CARD);
2551     }
2552
2553   /* We only change n_bits and don't touch anything else.  Before we
2554      do so, we round up NBITS to a sensible way in the same way as
2555      gpg's key generation does it.  This may help to sort out problems
2556      with a few bits too short keys.  */
2557   nbits = ((nbits + 31) / 32) * 32;
2558   buffer[1] = (nbits >> 8);
2559   buffer[2] = nbits;
2560
2561   /* Prepare for storing the key.  */
2562   err = verify_chv3 (app, pincb, pincb_arg);
2563   if (err)
2564     {
2565       xfree (relptr);
2566       return err;
2567     }
2568
2569   /* Change the attribute.  */
2570   err = iso7816_put_data (app->slot, 0, 0xC1+keyno, buffer, buflen);
2571   xfree (relptr);
2572   if (err)
2573     log_error ("error changing size of key %d to %u bits\n", keyno+1, nbits);
2574   else
2575     log_info ("size of key %d changed to %u bits\n", keyno+1, nbits);
2576   flush_cache (app);
2577   parse_algorithm_attribute (app, keyno);
2578   app->did_chv1 = 0;
2579   app->did_chv2 = 0;
2580   app->did_chv3 = 0;
2581   return err;
2582 }
2583
2584
2585 /* Helper to process an setattr command for name KEY-ATTR.  It expects
2586    a string "--force <keyno> <algo> <nbits>" in (VALUE,VALUELEN).  */
2587 static gpg_error_t
2588 change_keyattr_from_string (app_t app,
2589                             gpg_error_t (*pincb)(void*, const char *, char **),
2590                             void *pincb_arg,
2591                             const void *value, size_t valuelen)
2592 {
2593   gpg_error_t err;
2594   char *string;
2595   int keyno, algo;
2596   unsigned int nbits;
2597
2598   /* VALUE is expected to be a string but not guaranteed to be
2599      terminated.  Thus copy it to an allocated buffer first. */
2600   string = xtrymalloc (valuelen+1);
2601   if (!string)
2602     return gpg_error_from_syserror ();
2603   memcpy (string, value, valuelen);
2604   string[valuelen] = 0;
2605
2606   /* Because this function deletes the key we require the string
2607      "--force" in the data to make clear that something serious might
2608      happen.  */
2609   if (sscanf (string, " --force %d %d %u", &keyno, &algo, &nbits) != 3)
2610     err = gpg_error (GPG_ERR_INV_DATA);
2611   else if (keyno < 1 || keyno > 3)
2612     err = gpg_error (GPG_ERR_INV_ID);
2613   else if (algo != 1)
2614     err = gpg_error (GPG_ERR_PUBKEY_ALGO); /* Not RSA.  */
2615   else if (nbits < 1024)
2616     err = gpg_error (GPG_ERR_TOO_SHORT);
2617   else
2618     err = change_keyattr (app, keyno-1, nbits, pincb, pincb_arg);
2619
2620   xfree (string);
2621   return err;
2622 }
2623
2624
2625 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
2626    canonical encoded S-expression with the secret key in KEYDATA and
2627    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
2628    usual keyid which for OpenPGP is the string "OPENPGP.n" with
2629    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
2630    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
2631    the pinentry callback.  */
2632 static gpg_error_t
2633 do_writekey (app_t app, ctrl_t ctrl,
2634              const char *keyid, unsigned int flags,
2635              gpg_error_t (*pincb)(void*, const char *, char **),
2636              void *pincb_arg,
2637              const unsigned char *keydata, size_t keydatalen)
2638 {
2639   gpg_error_t err;
2640   int force = (flags & 1);
2641   int keyno;
2642   const unsigned char *buf, *tok;
2643   size_t buflen, toklen;
2644   int depth, last_depth1, last_depth2;
2645   const unsigned char *rsa_n = NULL;
2646   const unsigned char *rsa_e = NULL;
2647   const unsigned char *rsa_p = NULL;
2648   const unsigned char *rsa_q = NULL;
2649   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
2650   unsigned int nbits;
2651   unsigned int maxbits;
2652   unsigned char *template = NULL;
2653   unsigned char *tp;
2654   size_t template_len;
2655   unsigned char fprbuf[20];
2656   u32 created_at = 0;
2657
2658   (void)ctrl;
2659
2660   if (!strcmp (keyid, "OPENPGP.1"))
2661     keyno = 0;
2662   else if (!strcmp (keyid, "OPENPGP.2"))
2663     keyno = 1;
2664   else if (!strcmp (keyid, "OPENPGP.3"))
2665     keyno = 2;
2666   else
2667     return gpg_error (GPG_ERR_INV_ID);
2668
2669   err = does_key_exist (app, keyno, 0, force);
2670   if (err)
2671     return err;
2672
2673
2674   /*
2675      Parse the S-expression
2676    */
2677   buf = keydata;
2678   buflen = keydatalen;
2679   depth = 0;
2680   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2681     goto leave;
2682   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2683     goto leave;
2684   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
2685     {
2686       if (!tok)
2687         ;
2688       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
2689         log_info ("protected-private-key passed to writekey\n");
2690       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
2691         log_info ("shadowed-private-key passed to writekey\n");
2692       err = gpg_error (GPG_ERR_BAD_SECKEY);
2693       goto leave;
2694     }
2695   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2696     goto leave;
2697   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2698     goto leave;
2699   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
2700     {
2701       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
2702       goto leave;
2703     }
2704   last_depth1 = depth;
2705   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2706          && depth && depth >= last_depth1)
2707     {
2708       if (tok)
2709         {
2710           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2711           goto leave;
2712         }
2713       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2714         goto leave;
2715       if (tok && toklen == 1)
2716         {
2717           const unsigned char **mpi;
2718           size_t *mpi_len;
2719
2720           switch (*tok)
2721             {
2722             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
2723             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
2724             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break;
2725             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break;
2726             default: mpi = NULL;  mpi_len = NULL; break;
2727             }
2728           if (mpi && *mpi)
2729             {
2730               err = gpg_error (GPG_ERR_DUP_VALUE);
2731               goto leave;
2732             }
2733           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2734             goto leave;
2735           if (tok && mpi)
2736             {
2737               /* Strip off leading zero bytes and save. */
2738               for (;toklen && !*tok; toklen--, tok++)
2739                 ;
2740               *mpi = tok;
2741               *mpi_len = toklen;
2742             }
2743         }
2744       /* Skip until end of list. */
2745       last_depth2 = depth;
2746       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2747              && depth && depth >= last_depth2)
2748         ;
2749       if (err)
2750         goto leave;
2751     }
2752   /* Parse other attributes. */
2753   last_depth1 = depth;
2754   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2755          && depth && depth >= last_depth1)
2756     {
2757       if (tok)
2758         {
2759           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2760           goto leave;
2761         }
2762       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2763         goto leave;
2764       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2765         {
2766           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2767             goto leave;
2768           if (tok)
2769             {
2770               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2771                    tok++, toklen--)
2772                 created_at = created_at*10 + (*tok - '0');
2773             }
2774         }
2775       /* Skip until end of list. */
2776       last_depth2 = depth;
2777       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2778              && depth && depth >= last_depth2)
2779         ;
2780       if (err)
2781         goto leave;
2782     }
2783
2784
2785   /* Check that we have all parameters and that they match the card
2786      description. */
2787   if (!created_at)
2788     {
2789       log_error (_("creation timestamp missing\n"));
2790       err = gpg_error (GPG_ERR_INV_VALUE);
2791       goto leave;
2792     }
2793
2794   maxbits = app->app_local->keyattr[keyno].n_bits;
2795   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2796   if (opt.verbose)
2797     log_info ("RSA modulus size is %u bits (%u bytes)\n",
2798               nbits, (unsigned int)rsa_n_len);
2799   if (nbits && nbits != maxbits
2800       && app->app_local->extcap.algo_attr_change)
2801     {
2802       /* Try to switch the key to a new length.  */
2803       err = change_keyattr (app, keyno, nbits, pincb, pincb_arg);
2804       if (!err)
2805         maxbits = app->app_local->keyattr[keyno].n_bits;
2806     }
2807   if (nbits != maxbits)
2808     {
2809       log_error (_("RSA modulus missing or not of size %d bits\n"),
2810                  (int)maxbits);
2811       err = gpg_error (GPG_ERR_BAD_SECKEY);
2812       goto leave;
2813     }
2814
2815   maxbits = app->app_local->keyattr[keyno].e_bits;
2816   if (maxbits > 32 && !app->app_local->extcap.is_v2)
2817     maxbits = 32; /* Our code for v1 does only support 32 bits.  */
2818   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2819   if (nbits < 2 || nbits > maxbits)
2820     {
2821       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2822                  (int)maxbits);
2823       err = gpg_error (GPG_ERR_BAD_SECKEY);
2824       goto leave;
2825     }
2826
2827   maxbits = app->app_local->keyattr[keyno].n_bits/2;
2828   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2829   if (nbits != maxbits)
2830     {
2831       log_error (_("RSA prime %s missing or not of size %d bits\n"),
2832                  "P", (int)maxbits);
2833       err = gpg_error (GPG_ERR_BAD_SECKEY);
2834       goto leave;
2835     }
2836   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2837   if (nbits != maxbits)
2838     {
2839       log_error (_("RSA prime %s missing or not of size %d bits\n"),
2840                  "Q", (int)maxbits);
2841       err = gpg_error (GPG_ERR_BAD_SECKEY);
2842       goto leave;
2843     }
2844
2845   /* We need to remove the cached public key.  */
2846   xfree (app->app_local->pk[keyno].key);
2847   app->app_local->pk[keyno].key = NULL;
2848   app->app_local->pk[keyno].keylen = 0;
2849   app->app_local->pk[keyno].read_done = 0;
2850
2851
2852   if (app->app_local->extcap.is_v2)
2853     {
2854       unsigned char *rsa_u, *rsa_dp, *rsa_dq;
2855       size_t rsa_u_len, rsa_dp_len, rsa_dq_len;
2856       gcry_mpi_t mpi_e, mpi_p, mpi_q;
2857       gcry_mpi_t mpi_u = gcry_mpi_snew (0);
2858       gcry_mpi_t mpi_dp = gcry_mpi_snew (0);
2859       gcry_mpi_t mpi_dq = gcry_mpi_snew (0);
2860       gcry_mpi_t mpi_tmp = gcry_mpi_snew (0);
2861       int exmode;
2862
2863       /* Calculate the u, dp and dq components needed by RSA_CRT cards */
2864       gcry_mpi_scan (&mpi_e, GCRYMPI_FMT_USG, rsa_e, rsa_e_len, NULL);
2865       gcry_mpi_scan (&mpi_p, GCRYMPI_FMT_USG, rsa_p, rsa_p_len, NULL);
2866       gcry_mpi_scan (&mpi_q, GCRYMPI_FMT_USG, rsa_q, rsa_q_len, NULL);
2867
2868       gcry_mpi_invm (mpi_u, mpi_q, mpi_p);
2869       gcry_mpi_sub_ui (mpi_tmp, mpi_p, 1);
2870       gcry_mpi_invm (mpi_dp, mpi_e, mpi_tmp);
2871       gcry_mpi_sub_ui (mpi_tmp, mpi_q, 1);
2872       gcry_mpi_invm (mpi_dq, mpi_e, mpi_tmp);
2873
2874       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_u, &rsa_u_len, mpi_u);
2875       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dp, &rsa_dp_len, mpi_dp);
2876       gcry_mpi_aprint (GCRYMPI_FMT_USG, &rsa_dq, &rsa_dq_len, mpi_dq);
2877
2878       gcry_mpi_release (mpi_e);
2879       gcry_mpi_release (mpi_p);
2880       gcry_mpi_release (mpi_q);
2881       gcry_mpi_release (mpi_u);
2882       gcry_mpi_release (mpi_dp);
2883       gcry_mpi_release (mpi_dq);
2884       gcry_mpi_release (mpi_tmp);
2885
2886       /* Build the private key template as described in section 4.3.3.7 of
2887          the OpenPGP card specs version 2.0.  */
2888       err = build_privkey_template (app, keyno,
2889                                     rsa_n, rsa_n_len,
2890                                     rsa_e, rsa_e_len,
2891                                     rsa_p, rsa_p_len,
2892                                     rsa_q, rsa_q_len,
2893                                     rsa_u, rsa_u_len,
2894                                     rsa_dp, rsa_dp_len,
2895                                     rsa_dq, rsa_dq_len,
2896                                     &template, &template_len);
2897       xfree(rsa_u);
2898       xfree(rsa_dp);
2899       xfree(rsa_dq);
2900
2901       if (err)
2902         goto leave;
2903
2904       /* Prepare for storing the key.  */
2905       err = verify_chv3 (app, pincb, pincb_arg);
2906       if (err)
2907         goto leave;
2908
2909       /* Store the key. */
2910       if (app->app_local->cardcap.ext_lc_le && template_len > 254)
2911         exmode = 1;    /* Use extended length w/o a limit.  */
2912       else if (app->app_local->cardcap.cmd_chaining && template_len > 254)
2913         exmode = -254;
2914       else
2915         exmode = 0;
2916       err = iso7816_put_data_odd (app->slot, exmode, 0x3fff,
2917                                   template, template_len);
2918     }
2919   else
2920     {
2921       /* Build the private key template as described in section 4.3.3.6 of
2922          the OpenPGP card specs version 1.1:
2923          0xC0   <length> public exponent
2924          0xC1   <length> prime p
2925          0xC2   <length> prime q
2926       */
2927       assert (rsa_e_len <= 4);
2928       template_len = (1 + 1 + 4
2929                       + 1 + 1 + rsa_p_len
2930                       + 1 + 1 + rsa_q_len);
2931       template = tp = xtrymalloc_secure (template_len);
2932       if (!template)
2933         {
2934           err = gpg_error_from_syserror ();
2935           goto leave;
2936         }
2937       *tp++ = 0xC0;
2938       *tp++ = 4;
2939       memcpy (tp, rsa_e, rsa_e_len);
2940       if (rsa_e_len < 4)
2941         {
2942           /* Right justify E. */
2943           memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2944           memset (tp, 0, 4-rsa_e_len);
2945         }
2946       tp += 4;
2947
2948       *tp++ = 0xC1;
2949       *tp++ = rsa_p_len;
2950       memcpy (tp, rsa_p, rsa_p_len);
2951       tp += rsa_p_len;
2952
2953       *tp++ = 0xC2;
2954       *tp++ = rsa_q_len;
2955       memcpy (tp, rsa_q, rsa_q_len);
2956       tp += rsa_q_len;
2957
2958       assert (tp - template == template_len);
2959
2960       /* Prepare for storing the key.  */
2961       err = verify_chv3 (app, pincb, pincb_arg);
2962       if (err)
2963         goto leave;
2964
2965       /* Store the key. */
2966       err = iso7816_put_data (app->slot, 0,
2967                               (app->card_version > 0x0007? 0xE0:0xE9)+keyno,
2968                               template, template_len);
2969     }
2970   if (err)
2971     {
2972       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2973       goto leave;
2974     }
2975
2976   err = store_fpr (app, keyno, created_at,
2977                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2978                   fprbuf, app->card_version);
2979   if (err)
2980     goto leave;
2981
2982
2983  leave:
2984   xfree (template);
2985   return err;
2986 }
2987
2988
2989 /* Handle the GENKEY command. */
2990 static gpg_error_t
2991 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2992            time_t createtime,
2993            gpg_error_t (*pincb)(void*, const char *, char **),
2994            void *pincb_arg)
2995 {
2996   int rc;
2997   char numbuf[30];
2998   unsigned char fprbuf[20];
2999   const unsigned char *keydata, *m, *e;
3000   unsigned char *buffer = NULL;
3001   size_t buflen, keydatalen, mlen, elen;
3002   time_t created_at;
3003   int keyno = atoi (keynostr);
3004   int force = (flags & 1);
3005   time_t start_at;
3006   int exmode;
3007   int le_value;
3008   unsigned int keybits;
3009
3010   if (keyno < 1 || keyno > 3)
3011     return gpg_error (GPG_ERR_INV_ID);
3012   keyno--;
3013
3014   /* We flush the cache to increase the traffic before a key
3015      generation.  This _might_ help a card to gather more entropy. */
3016   flush_cache (app);
3017
3018   /* Obviously we need to remove the cached public key.  */
3019   xfree (app->app_local->pk[keyno].key);
3020   app->app_local->pk[keyno].key = NULL;
3021   app->app_local->pk[keyno].keylen = 0;
3022   app->app_local->pk[keyno].read_done = 0;
3023
3024   /* Check whether a key already exists.  */
3025   rc = does_key_exist (app, keyno, 1, force);
3026   if (rc)
3027     return rc;
3028
3029   /* Because we send the key parameter back via status lines we need
3030      to put a limit on the max. allowed keysize.  2048 bit will
3031      already lead to a 527 byte long status line and thus a 4096 bit
3032      key would exceed the Assuan line length limit.  */
3033   keybits = app->app_local->keyattr[keyno].n_bits;
3034   if (keybits > 4096)
3035     return gpg_error (GPG_ERR_TOO_LARGE);
3036
3037   /* Prepare for key generation by verifying the Admin PIN.  */
3038   rc = verify_chv3 (app, pincb, pincb_arg);
3039   if (rc)
3040     goto leave;
3041
3042   /* Test whether we will need extended length mode.  (1900 is an
3043      arbitrary length which for sure fits into a short apdu.)  */
3044   if (app->app_local->cardcap.ext_lc_le && keybits > 1900)
3045     {
3046       exmode = 1;    /* Use extended length w/o a limit.  */
3047       le_value = app->app_local->extcap.max_rsp_data;
3048       /* No need to check le_value because it comes from a 16 bit
3049          value and thus can't create an overflow on a 32 bit
3050          system.  */
3051     }
3052   else
3053     {
3054       exmode = 0;
3055       le_value = 256; /* Use legacy value. */
3056     }
3057
3058   log_info (_("please wait while key is being generated ...\n"));
3059   start_at = time (NULL);
3060   rc = iso7816_generate_keypair
3061 /* # warning key generation temporary replaced by reading an existing key. */
3062 /*   rc = iso7816_read_public_key */
3063     (app->slot, exmode,
3064      (const unsigned char*)(keyno == 0? "\xB6" :
3065                             keyno == 1? "\xB8" : "\xA4"), 2,
3066      le_value,
3067      &buffer, &buflen);
3068   if (rc)
3069     {
3070       rc = gpg_error (GPG_ERR_CARD);
3071       log_error (_("generating key failed\n"));
3072       goto leave;
3073     }
3074   log_info (_("key generation completed (%d seconds)\n"),
3075             (int)(time (NULL) - start_at));
3076
3077   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
3078   if (!keydata)
3079     {
3080       rc = gpg_error (GPG_ERR_CARD);
3081       log_error (_("response does not contain the public key data\n"));
3082       goto leave;
3083     }
3084
3085   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
3086   if (!m)
3087     {
3088       rc = gpg_error (GPG_ERR_CARD);
3089       log_error (_("response does not contain the RSA modulus\n"));
3090       goto leave;
3091     }
3092   /* log_printhex ("RSA n:", m, mlen); */
3093   send_key_data (ctrl, "n", m, mlen);
3094
3095   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
3096   if (!e)
3097     {
3098       rc = gpg_error (GPG_ERR_CARD);
3099       log_error (_("response does not contain the RSA public exponent\n"));
3100       goto leave;
3101     }
3102   /* log_printhex ("RSA e:", e, elen); */
3103   send_key_data (ctrl, "e", e, elen);
3104
3105   created_at = createtime? createtime : gnupg_get_time ();
3106   sprintf (numbuf, "%lu", (unsigned long)created_at);
3107   send_status_info (ctrl, "KEY-CREATED-AT",
3108                     numbuf, (size_t)strlen(numbuf), NULL, 0);
3109
3110   rc = store_fpr (app, keyno, (u32)created_at,
3111                   m, mlen, e, elen, fprbuf, app->card_version);
3112   if (rc)
3113     goto leave;
3114   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
3115
3116
3117  leave:
3118   xfree (buffer);
3119   return rc;
3120 }
3121
3122
3123 static unsigned long
3124 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
3125 {
3126   unsigned long ul;
3127
3128   if (valuelen == 3 )
3129     ul = (value[0] << 16) | (value[1] << 8) | value[2];
3130   else
3131     {
3132       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
3133       ul = 0;
3134     }
3135   return ul;
3136 }
3137
3138 static unsigned long
3139 get_sig_counter (app_t app)
3140 {
3141   void *relptr;
3142   unsigned char *value;
3143   size_t valuelen;
3144   unsigned long ul;
3145
3146   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
3147   if (!relptr)
3148     return 0;
3149   ul = convert_sig_counter_value (value, valuelen);
3150   xfree (relptr);
3151   return ul;
3152 }
3153
3154 static gpg_error_t
3155 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
3156 {
3157   const unsigned char *fpr;
3158   unsigned char *buffer;
3159   size_t buflen, n;
3160   int rc, i;
3161
3162   assert (keyno >= 1 && keyno <= 3);
3163
3164   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0, 0);
3165   if (rc)
3166     {
3167       log_error (_("error reading application data\n"));
3168       return gpg_error (GPG_ERR_GENERAL);
3169     }
3170   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
3171   if (!fpr || n != 60)
3172     {
3173       xfree (buffer);
3174       log_error (_("error reading fingerprint DO\n"));
3175       return gpg_error (GPG_ERR_GENERAL);
3176     }
3177   fpr += (keyno-1)*20;
3178   for (i=0; i < 20; i++)
3179     if (sha1fpr[i] != fpr[i])
3180       {
3181         xfree (buffer);
3182         log_info (_("fingerprint on card does not match requested one\n"));
3183         return gpg_error (GPG_ERR_WRONG_SECKEY);
3184       }
3185   xfree (buffer);
3186   return 0;
3187 }
3188
3189
3190 /* If a fingerprint has been specified check it against the one on the
3191    card.  This allows for a meaningful error message in case the key
3192    on the card has been replaced but the shadow information known to
3193    gpg has not been updated.  If there is no fingerprint we assume
3194    that this is okay. */
3195 static gpg_error_t
3196 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
3197 {
3198   unsigned char tmp[20];
3199   const char *s;
3200   int n;
3201
3202   for (s=fpr, n=0; hexdigitp (s); s++, n++)
3203     ;
3204   if (n != 40)
3205     return gpg_error (GPG_ERR_INV_ID);
3206   else if (!*s)
3207     ; /* okay */
3208   else
3209     return gpg_error (GPG_ERR_INV_ID);
3210
3211   for (s=fpr, n=0; n < 20; s += 2, n++)
3212         tmp[n] = xtoi_2 (s);
3213   return compare_fingerprint (app, keyno, tmp);
3214 }
3215
3216
3217
3218 /* Compute a digital signature on INDATA which is expected to be the
3219    raw message digest. For this application the KEYIDSTR consists of
3220    the serialnumber and the fingerprint delimited by a slash.
3221
3222    Note that this function may return the error code
3223    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3224    not match the one required for the requested action (e.g. the
3225    serial number does not match).
3226
3227    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
3228    operation to the auth command.
3229 */
3230 static gpg_error_t
3231 do_sign (app_t app, const char *keyidstr, int hashalgo,
3232          gpg_error_t (*pincb)(void*, const char *, char **),
3233          void *pincb_arg,
3234          const void *indata, size_t indatalen,
3235          unsigned char **outdata, size_t *outdatalen )
3236 {
3237   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
3238     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
3239       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
3240   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
3241     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
3242       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
3243   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
3244     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
3245       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
3246       0x1C  };
3247   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
3248     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3249       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
3250       0x00, 0x04, 0x20  };
3251   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
3252     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3253       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
3254       0x00, 0x04, 0x30  };
3255   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
3256     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
3257       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
3258       0x00, 0x04, 0x40  };
3259   int rc;
3260   unsigned char data[19+64];
3261   size_t datalen;
3262   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
3263   const char *s;
3264   int n;
3265   const char *fpr = NULL;
3266   unsigned long sigcount;
3267   int use_auth = 0;
3268   int exmode, le_value;
3269
3270   if (!keyidstr || !*keyidstr)
3271     return gpg_error (GPG_ERR_INV_VALUE);
3272
3273   /* Strip off known prefixes.  */
3274 #define X(a,b,c,d) \
3275   if (hashalgo == GCRY_MD_ ## a                               \
3276       && (d)                                                  \
3277       && indatalen == sizeof b ## _prefix + (c)               \
3278       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
3279     {                                                         \
3280       indata = (const char*)indata + sizeof b ## _prefix;     \
3281       indatalen -= sizeof b ## _prefix;                       \
3282     }
3283
3284   if (indatalen == 20)
3285     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
3286   else X(SHA1,   sha1,   20, 1)
3287   else X(RMD160, rmd160, 20, 1)
3288   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
3289   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
3290   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
3291   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
3292   else if ((indatalen == 28 || indatalen == 32
3293             || indatalen == 48 || indatalen ==64)
3294            && app->app_local->extcap.is_v2)
3295     ;  /* Assume a plain SHA-3 digest has been given.  */
3296   else
3297     {
3298       log_error (_("card does not support digest algorithm %s\n"),
3299                  gcry_md_algo_name (hashalgo));
3300       /* Or the supplied digest length does not match an algorithm.  */
3301       return gpg_error (GPG_ERR_INV_VALUE);
3302     }
3303 #undef X
3304
3305   /* Check whether an OpenPGP card of any version has been requested. */
3306   if (!strcmp (keyidstr, "OPENPGP.1"))
3307     ;
3308   else if (!strcmp (keyidstr, "OPENPGP.3"))
3309     use_auth = 1;
3310   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3311     return gpg_error (GPG_ERR_INV_ID);
3312   else
3313     {
3314       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3315         ;
3316       if (n != 32)
3317         return gpg_error (GPG_ERR_INV_ID);
3318       else if (!*s)
3319         ; /* no fingerprint given: we allow this for now. */
3320       else if (*s == '/')
3321         fpr = s + 1;
3322       else
3323         return gpg_error (GPG_ERR_INV_ID);
3324
3325       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3326         tmp_sn[n] = xtoi_2 (s);
3327
3328       if (app->serialnolen != 16)
3329         return gpg_error (GPG_ERR_INV_CARD);
3330       if (memcmp (app->serialno, tmp_sn, 16))
3331         return gpg_error (GPG_ERR_WRONG_CARD);
3332     }
3333
3334   /* If a fingerprint has been specified check it against the one on
3335      the card.  This is allows for a meaningful error message in case
3336      the key on the card has been replaced but the shadow information
3337      known to gpg was not updated.  If there is no fingerprint, gpg
3338      will detect a bogus signature anyway due to the
3339      verify-after-signing feature. */
3340   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
3341   if (rc)
3342     return rc;
3343
3344   /* Concatenate prefix and digest.  */
3345 #define X(a,b,d) \
3346   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
3347     {                                                         \
3348       datalen = sizeof b ## _prefix + indatalen;              \
3349       assert (datalen <= sizeof data);                        \
3350       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
3351       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
3352     }
3353
3354   X(SHA1,   sha1,   1)
3355   else X(RMD160, rmd160, 1)
3356   else X(SHA224, sha224, app->app_local->extcap.is_v2)
3357   else X(SHA256, sha256, app->app_local->extcap.is_v2)
3358   else X(SHA384, sha384, app->app_local->extcap.is_v2)
3359   else X(SHA512, sha512, app->app_local->extcap.is_v2)
3360   else
3361     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
3362 #undef X
3363
3364   /* Redirect to the AUTH command if asked to. */
3365   if (use_auth)
3366     {
3367       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
3368                       data, datalen,
3369                       outdata, outdatalen);
3370     }
3371
3372   /* Show the number of signature done using this key.  */
3373   sigcount = get_sig_counter (app);
3374   log_info (_("signatures created so far: %lu\n"), sigcount);
3375
3376   /* Check CHV if needed.  */
3377   if (!app->did_chv1 || app->force_chv1 )
3378     {
3379       char *pinvalue;
3380
3381       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
3382       if (rc)
3383         return rc;
3384
3385       app->did_chv1 = 1;
3386
3387       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
3388          sync, thus we verify CHV2 here using the given PIN.  Cards
3389          with version2 to not have the need for a separate CHV2 and
3390          internally use just one.  Obviously we can't do that if the
3391          pinpad has been used. */
3392       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
3393         {
3394           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
3395           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
3396             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
3397           if (rc)
3398             {
3399               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
3400               xfree (pinvalue);
3401               flush_cache_after_error (app);
3402               return rc;
3403             }
3404           app->did_chv2 = 1;
3405         }
3406       xfree (pinvalue);
3407     }
3408
3409
3410   if (app->app_local->cardcap.ext_lc_le)
3411     {
3412       exmode = 1;    /* Use extended length.  */
3413       le_value = app->app_local->extcap.max_rsp_data;
3414     }
3415   else
3416     {
3417       exmode = 0;
3418       le_value = 0;
3419     }
3420   rc = iso7816_compute_ds (app->slot, exmode, data, datalen, le_value,
3421                            outdata, outdatalen);
3422   return rc;
3423 }
3424
3425 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
3426    on INDATA which is expected to be the raw message digest. For this
3427    application the KEYIDSTR consists of the serialnumber and the
3428    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
3429    be given.
3430
3431    Note that this function may return the error code
3432    GPG_ERR_WRONG_CARD to indicate that the card currently present does
3433    not match the one required for the requested action (e.g. the
3434    serial number does not match). */
3435 static gpg_error_t
3436 do_auth (app_t app, const char *keyidstr,
3437          gpg_error_t (*pincb)(void*, const char *, char **),
3438          void *pincb_arg,
3439          const void *indata, size_t indatalen,
3440          unsigned char **outdata, size_t *outdatalen )
3441 {
3442   int rc;
3443   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
3444   const char *s;
3445   int n;
3446   const char *fpr = NULL;
3447
3448   if (!keyidstr || !*keyidstr)
3449     return gpg_error (GPG_ERR_INV_VALUE);
3450   if (indatalen > 101) /* For a 2048 bit key. */
3451     return gpg_error (GPG_ERR_INV_VALUE);
3452
3453   /* Check whether an OpenPGP card of any version has been requested. */
3454   if (!strcmp (keyidstr, "OPENPGP.3"))
3455     ;
3456   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3457     return gpg_error (GPG_ERR_INV_ID);
3458   else
3459     {
3460       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3461         ;
3462       if (n != 32)
3463         return gpg_error (GPG_ERR_INV_ID);
3464       else if (!*s)
3465         ; /* no fingerprint given: we allow this for now. */
3466       else if (*s == '/')
3467         fpr = s + 1;
3468       else
3469         return gpg_error (GPG_ERR_INV_ID);
3470
3471       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3472         tmp_sn[n] = xtoi_2 (s);
3473
3474       if (app->serialnolen != 16)
3475         return gpg_error (GPG_ERR_INV_CARD);
3476       if (memcmp (app->serialno, tmp_sn, 16))
3477         return gpg_error (GPG_ERR_WRONG_CARD);
3478     }
3479
3480   /* If a fingerprint has been specified check it against the one on
3481      the card.  This is allows for a meaningful error message in case
3482      the key on the card has been replaced but the shadow information
3483      known to gpg was not updated.  If there is no fingerprint, gpg
3484      will detect a bogus signature anyway due to the
3485      verify-after-signing feature. */
3486   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
3487   if (rc)
3488     return rc;
3489
3490   rc = verify_chv2 (app, pincb, pincb_arg);
3491   if (!rc)
3492     {
3493       int exmode, le_value;
3494
3495       if (app->app_local->cardcap.ext_lc_le)
3496         {
3497           exmode = 1;    /* Use extended length.  */
3498           le_value = app->app_local->extcap.max_rsp_data;
3499         }
3500       else
3501         {
3502           exmode = 0;
3503           le_value = 0;
3504         }
3505       rc = iso7816_internal_authenticate (app->slot, exmode,
3506                                           indata, indatalen, le_value,
3507                                           outdata, outdatalen);
3508     }
3509   return rc;
3510 }
3511
3512
3513 static gpg_error_t
3514 do_decipher (app_t app, const char *keyidstr,
3515              gpg_error_t (*pincb)(void*, const char *, char **),
3516              void *pincb_arg,
3517              const void *indata, size_t indatalen,
3518              unsigned char **outdata, size_t *outdatalen )
3519 {
3520   int rc;
3521   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
3522   const char *s;
3523   int n;
3524   const char *fpr = NULL;
3525   int exmode, le_value;
3526
3527   if (!keyidstr || !*keyidstr || !indatalen)
3528     return gpg_error (GPG_ERR_INV_VALUE);
3529
3530   /* Check whether an OpenPGP card of any version has been requested. */
3531   if (!strcmp (keyidstr, "OPENPGP.2"))
3532     ;
3533   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
3534     return gpg_error (GPG_ERR_INV_ID);
3535   else
3536     {
3537       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
3538         ;
3539       if (n != 32)
3540         return gpg_error (GPG_ERR_INV_ID);
3541       else if (!*s)
3542         ; /* no fingerprint given: we allow this for now. */
3543       else if (*s == '/')
3544         fpr = s + 1;
3545       else
3546         return gpg_error (GPG_ERR_INV_ID);
3547
3548       for (s=keyidstr, n=0; n < 16; s += 2, n++)
3549         tmp_sn[n] = xtoi_2 (s);
3550
3551       if (app->serialnolen != 16)
3552         return gpg_error (GPG_ERR_INV_CARD);
3553       if (memcmp (app->serialno, tmp_sn, 16))
3554         return gpg_error (GPG_ERR_WRONG_CARD);
3555     }
3556