Improvements for 2k keys.
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  * Copyright (C) 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
18  *
19  * $Id$
20  */
21
22 #include <config.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <time.h>
29
30 #if GNUPG_MAJOR_VERSION == 1
31 /* This is used with GnuPG version < 1.9.  The code has been source
32    copied from the current GnuPG >= 1.9  and is maintained over
33    there. */
34 #include "options.h"
35 #include "errors.h"
36 #include "memory.h"
37 #include "util.h"
38 #include "cardglue.h"
39 #else /* GNUPG_MAJOR_VERSION != 1 */
40 #include "scdaemon.h"
41 #endif /* GNUPG_MAJOR_VERSION != 1 */
42
43 #include "i18n.h"
44 #include "iso7816.h"
45 #include "app-common.h"
46 #include "tlv.h"
47
48
49 static struct {
50   int tag;
51   int constructed;
52   int get_from;  /* Constructed DO with this DO or 0 for direct access. */
53   int binary;
54   int dont_cache;
55   int flush_on_error;
56   int get_immediate_in_v11; /* Enable a hack to bypass the cache of
57                                this data object if it is used in 1.1
58                                and later versions of the card.  This
59                                does not work with composite DO and is
60                                currently only useful for the CHV
61                                status bytes. */
62   char *desc;
63 } data_objects[] = {
64   { 0x005E, 0,    0, 1, 0, 0, 0, "Login Data" },
65   { 0x5F50, 0,    0, 0, 0, 0, 0, "URL" },
66   { 0x5F52, 0,    0, 1, 0, 0, 0, "Historical Bytes" },
67   { 0x0065, 1,    0, 1, 0, 0, 0, "Cardholder Related Data"},
68   { 0x005B, 0, 0x65, 0, 0, 0, 0, "Name" },
69   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, "Language preferences" },
70   { 0x5F35, 0, 0x65, 0, 0, 0, 0, "Sex" },
71   { 0x006E, 1,    0, 1, 0, 0, 0, "Application Related Data" },
72   { 0x004F, 0, 0x6E, 1, 0, 0, 0, "AID" },
73   { 0x0073, 1,    0, 1, 0, 0, 0, "Discretionary Data Objects" },
74   { 0x0047, 0, 0x6E, 1, 1, 0, 0, "Card Capabilities" },
75   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, "Extended Card Capabilities" },
76   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Signature" },
77   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Decryption" },
78   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Authentication" },
79   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, "CHV Status Bytes" },
80   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, "Fingerprints" },
81   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, "CA Fingerprints" },
82   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, "Generation time" },
83   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
84   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
85   { 0x0101, 0,    0, 0, 0, 0, 0, "Private DO 1"},
86   { 0x0102, 0,    0, 0, 0, 0, 0, "Private DO 2"},
87   { 0x0103, 0,    0, 0, 0, 0, 0, "Private DO 3"},
88   { 0x0104, 0,    0, 0, 0, 0, 0, "Private DO 4"},
89   { 0x7F21, 1,    0, 1, 0, 0, 0, "Cardholder certificate"},
90   { 0 }
91 };
92
93
94 /* One cache item for DOs.  */
95 struct cache_s {
96   struct cache_s *next;
97   int tag;
98   size_t length;
99   unsigned char data[1];
100 };
101
102
103 /* Object with application (i.e. OpenPGP card) specific data.  */
104 struct app_local_s {
105   /* A linked list with cached DOs.  */
106   struct cache_s *cache;
107   
108   /* Keep track of the public keys.  */
109   struct
110   {
111     int read_done;   /* True if we have at least tried to read them.  */
112     unsigned char *key; /* This is a malloced buffer with a canonical
113                            encoded S-expression encoding a public
114                            key. Might be NULL if key is not
115                            available.  */
116     size_t keylen;      /* The length of the above S-expression.  This
117                            is usullay only required for cross checks
118                            because the length of an S-expression is
119                            implicitly available.  */
120   } pk[3];
121
122   unsigned char status_indicator; /* The card status indicator.  */
123
124   /* Keep track of the ISO card capabilities.  */
125   struct
126   {
127     unsigned int cmd_chaining:1;  /* Command chaining is supported.  */
128     unsigned int ext_lc_le:1;     /* Extended Lc and Le are supported.  */
129   } cardcap;
130
131   /* Keep track of extended card capabilities.  */
132   struct 
133   {
134     unsigned int is_v2:1;  /* This is a v2.0 compatible card.  */
135     unsigned int get_challenge:1;
136     unsigned int key_import:1;
137     unsigned int change_force_chv:1;
138     unsigned int private_dos:1;
139     unsigned int sm_supported:1;  /* Secure Messaging is supported.  */
140     unsigned int sm_aes128:1;     /* Use AES-128 for SM.  */
141     unsigned int max_certlen_3:16;
142     unsigned int max_get_challenge:16; /* Maximum size for get_challenge.  */
143     unsigned int max_cmd_data:16;      /* Maximum data size for a command.  */
144     unsigned int max_rsp_data:16;      /* Maximum size of a response.  */
145   } extcap;
146
147   /* Flags used to control the application.  */
148   struct
149   {
150     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
151     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
152   } flags;
153 };
154
155
156
157 /***** Local prototypes  *****/
158 static unsigned long convert_sig_counter_value (const unsigned char *value,
159                                                 size_t valuelen);
160 static unsigned long get_sig_counter (app_t app);
161 static gpg_error_t do_auth (app_t app, const char *keyidstr,
162                             gpg_error_t (*pincb)(void*, const char *, char **),
163                             void *pincb_arg,
164                             const void *indata, size_t indatalen,
165                             unsigned char **outdata, size_t *outdatalen);
166
167
168
169
170 \f
171 /* Deconstructor. */
172 static void
173 do_deinit (app_t app)
174 {
175   if (app && app->app_local)
176     {
177       struct cache_s *c, *c2;
178       int i;
179
180       for (c = app->app_local->cache; c; c = c2)
181         {
182           c2 = c->next;
183           xfree (c);
184         }
185
186       for (i=0; i < DIM (app->app_local->pk); i++)
187         {
188           xfree (app->app_local->pk[i].key);
189           app->app_local->pk[i].read_done = 0;
190         }
191       xfree (app->app_local);
192       app->app_local = NULL;
193     }
194 }
195
196
197 /* Wrapper around iso7816_get_data which first tries to get the data
198    from the cache.  With GET_IMMEDIATE passed as true, the cache is
199    bypassed. */
200 static gpg_error_t
201 get_cached_data (app_t app, int tag, 
202                  unsigned char **result, size_t *resultlen,
203                  int get_immediate)
204 {
205   gpg_error_t err;
206   int i;
207   unsigned char *p;
208   size_t len;
209   struct cache_s *c;
210
211   *result = NULL;
212   *resultlen = 0;
213
214   if (!get_immediate)
215     {
216       for (c=app->app_local->cache; c; c = c->next)
217         if (c->tag == tag)
218           {
219             if(c->length)
220               {
221                 p = xtrymalloc (c->length);
222                 if (!p)
223                   return gpg_error (gpg_err_code_from_errno (errno));
224                 memcpy (p, c->data, c->length);
225                 *result = p;
226               }
227             
228             *resultlen = c->length;
229             
230             return 0;
231           }
232     }
233   
234   err = iso7816_get_data (app->slot, tag, &p, &len);
235   if (err)
236     return err;
237   *result = p;
238   *resultlen = len;
239
240   /* Check whether we should cache this object. */
241   if (get_immediate)
242     return 0;
243
244   for (i=0; data_objects[i].tag; i++)
245     if (data_objects[i].tag == tag)
246       {
247         if (data_objects[i].dont_cache)
248           return 0;
249         break;
250       }
251
252   /* Okay, cache it. */
253   for (c=app->app_local->cache; c; c = c->next)
254     assert (c->tag != tag);
255   
256   c = xtrymalloc (sizeof *c + len);
257   if (c)
258     {
259       memcpy (c->data, p, len);
260       c->length = len;
261       c->tag = tag;
262       c->next = app->app_local->cache;
263       app->app_local->cache = c;
264     }
265
266   return 0;
267 }
268
269 /* Remove DO at TAG from the cache. */
270 static void
271 flush_cache_item (app_t app, int tag)
272 {
273   struct cache_s *c, *cprev;
274   int i;
275
276   if (!app->app_local)
277     return;
278
279   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
280     if (c->tag == tag)
281       {
282         if (cprev)
283           cprev->next = c->next;
284         else
285           app->app_local->cache = c->next;
286         xfree (c);
287
288         for (c=app->app_local->cache; c ; c = c->next)
289           {
290             assert (c->tag != tag); /* Oops: duplicated entry. */
291           }
292         return;
293       }
294
295   /* Try again if we have an outer tag. */
296   for (i=0; data_objects[i].tag; i++)
297     if (data_objects[i].tag == tag && data_objects[i].get_from
298         && data_objects[i].get_from != tag)
299       flush_cache_item (app, data_objects[i].get_from);
300 }
301
302 /* Flush all entries from the cache which might be out of sync after
303    an error. */
304 static void
305 flush_cache_after_error (app_t app)
306 {
307   int i;
308
309   for (i=0; data_objects[i].tag; i++)
310     if (data_objects[i].flush_on_error)
311       flush_cache_item (app, data_objects[i].tag);
312 }
313
314
315 /* Flush the entire cache. */
316 static void
317 flush_cache (app_t app)
318 {
319   if (app && app->app_local)
320     {
321       struct cache_s *c, *c2;
322
323       for (c = app->app_local->cache; c; c = c2)
324         {
325           c2 = c->next;
326           xfree (c);
327         }
328       app->app_local->cache = NULL;
329     }
330 }
331
332
333 /* Get the DO identified by TAG from the card in SLOT and return a
334    buffer with its content in RESULT and NBYTES.  The return value is
335    NULL if not found or a pointer which must be used to release the
336    buffer holding value. */
337 static void *
338 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
339             int *r_rc)
340 {
341   int rc, i;
342   unsigned char *buffer;
343   size_t buflen;
344   unsigned char *value;
345   size_t valuelen;
346   int dummyrc;
347
348   if (!r_rc)
349     r_rc = &dummyrc;
350
351   *result = NULL;
352   *nbytes = 0;
353   *r_rc = 0;
354   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
355     ;
356
357   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
358     {
359       rc = iso7816_get_data (app->slot, tag, &buffer, &buflen);
360       if (rc)
361         {
362           *r_rc = rc;
363           return NULL;
364         }
365       *result = buffer;
366       *nbytes = buflen;
367       return buffer;
368     }
369
370   value = NULL;
371   rc = -1;
372   if (data_objects[i].tag && data_objects[i].get_from)
373     {
374       rc = get_cached_data (app, data_objects[i].get_from,
375                             &buffer, &buflen,
376                             (data_objects[i].dont_cache 
377                              || data_objects[i].get_immediate_in_v11));
378       if (!rc)
379         {
380           const unsigned char *s;
381
382           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
383           if (!s)
384             value = NULL; /* not found */
385           else if (valuelen > buflen - (s - buffer))
386             {
387               log_error ("warning: constructed DO too short\n");
388               value = NULL;
389               xfree (buffer); buffer = NULL;
390             }
391           else
392             value = buffer + (s - buffer);
393         }
394     }
395
396   if (!value) /* Not in a constructed DO, try simple. */
397     {
398       rc = get_cached_data (app, tag, &buffer, &buflen,
399                             (data_objects[i].dont_cache 
400                              || data_objects[i].get_immediate_in_v11));
401       if (!rc)
402         {
403           value = buffer;
404           valuelen = buflen;
405         }
406     }
407
408   if (!rc)
409     {
410       *nbytes = valuelen;
411       *result = value;
412       return buffer;
413     }
414   *r_rc = rc;
415   return NULL;
416 }
417
418
419 static void
420 dump_all_do (int slot)
421 {
422   int rc, i, j;
423   unsigned char *buffer;
424   size_t buflen;
425   
426   for (i=0; data_objects[i].tag; i++)
427     {
428       if (data_objects[i].get_from)
429         continue;
430
431       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
432       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
433         ;
434       else if (rc) 
435         log_info ("DO `%s' not available: %s\n",
436                   data_objects[i].desc, gpg_strerror (rc));
437       else
438         {
439           if (data_objects[i].binary)
440             {
441               log_info ("DO `%s': ", data_objects[i].desc);
442               log_printhex ("", buffer, buflen);
443             }
444           else
445             log_info ("DO `%s': `%.*s'\n",
446                       data_objects[i].desc,
447                       (int)buflen, buffer); /* FIXME: sanitize */
448
449           if (data_objects[i].constructed)
450             {
451               for (j=0; data_objects[j].tag; j++)
452                 {
453                   const unsigned char *value;
454                   size_t valuelen;
455                   
456                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
457                     continue;
458                   value = find_tlv_unchecked (buffer, buflen,
459                                               data_objects[j].tag, &valuelen);
460                   if (!value)
461                     ; /* not found */
462                   else if (valuelen > buflen - (value - buffer))
463                     log_error ("warning: constructed DO too short\n");
464                   else
465                     {
466                       if (data_objects[j].binary)
467                         {
468                           log_info ("DO `%s': ", data_objects[j].desc);
469                           if (valuelen > 200)
470                             log_info ("[%u]\n", (unsigned int)valuelen);
471                           else
472                             log_printhex ("", value, valuelen);
473                         }
474                       else
475                         log_info ("DO `%s': `%.*s'\n",
476                                   data_objects[j].desc,
477                                   (int)valuelen, value); /* FIXME: sanitize */
478                     }
479                 }
480             }
481         }
482       xfree (buffer); buffer = NULL;
483     }
484 }
485
486
487 /* Count the number of bits, assuming the A represents an unsigned big
488    integer of length LEN bytes. */
489 static unsigned int
490 count_bits (const unsigned char *a, size_t len)
491 {
492   unsigned int n = len * 8;
493   int i;
494
495   for (; len && !*a; len--, a++, n -=8)
496     ;
497   if (len)
498     {
499       for (i=7; i && !(*a & (1<<i)); i--)
500         n--;
501     }
502   return n;
503 }
504
505 /* GnuPG makes special use of the login-data DO, this function parses
506    the login data to store the flags for later use.  It may be called
507    at any time and should be called after changing the login-data DO.
508
509    Everything up to a LF is considered a mailbox or account name.  If
510    the first LF is followed by DC4 (0x14) control sequence are
511    expected up to the next LF.  Control sequences are separated by FS
512    (0x18) and consist of key=value pairs.  There is one key defined:
513
514     F=<flags>
515
516     Were FLAGS is a plain hexadecimal number representing flag values.
517     The lsb is here the rightmost bit.  Defined flags bits are:
518
519       Bit 0 = CHV1 and CHV2 are not syncronized
520       Bit 1 = CHV2 has been been set to the default PIN of "123456"
521               (this implies that bit 0 is also set).
522
523 */
524 static void
525 parse_login_data (app_t app)
526 {
527   unsigned char *buffer, *p;
528   size_t buflen, len;
529   void *relptr;
530
531   /* Set defaults.  */
532   app->app_local->flags.no_sync = 0;
533   app->app_local->flags.def_chv2 = 0;
534
535   /* Read the DO.  */
536   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
537   if (!relptr)
538     return; /* Ooops. */
539   for (; buflen; buflen--, buffer++)
540     if (*buffer == '\n')
541       break;
542   if (buflen < 2 || buffer[1] != '\x14')
543     return; /* No control sequences.  */
544   buflen--;
545   buffer++;
546   do
547     {
548       buflen--;
549       buffer++;
550       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
551         {
552           /* Flags control sequence found.  */
553           int lastdig = 0;
554
555           /* For now we are only interested in the last digit, so skip
556              any leading digits but bail out on invalid characters. */
557           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
558             lastdig = xtoi_1 (p);
559           if (len && !(*p == '\n' || *p == '\x18'))
560             goto next;  /* Invalid characters in field.  */
561           app->app_local->flags.no_sync = !!(lastdig & 1);
562           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
563         }
564     next:
565       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
566         if (*buffer == '\n')
567           buflen = 1; 
568     }
569   while (buflen);
570
571   xfree (relptr);
572 }
573
574 /* Note, that FPR must be at least 20 bytes. */
575 static gpg_error_t 
576 store_fpr (int slot, int keynumber, u32 timestamp,
577            const unsigned char *m, size_t mlen,
578            const unsigned char *e, size_t elen, 
579            unsigned char *fpr, unsigned int card_version)
580 {
581   unsigned int n, nbits;
582   unsigned char *buffer, *p;
583   int rc;
584   
585   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
586     ;
587   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
588     ;
589
590   n = 6 + 2 + mlen + 2 + elen;
591   p = buffer = xtrymalloc (3 + n);
592   if (!buffer)
593     return gpg_error_from_syserror ();
594   
595   *p++ = 0x99;     /* ctb */
596   *p++ = n >> 8;   /* 2 byte length header */
597   *p++ = n;
598   *p++ = 4;        /* key packet version */
599   *p++ = timestamp >> 24;
600   *p++ = timestamp >> 16;
601   *p++ = timestamp >>  8;
602   *p++ = timestamp;
603   *p++ = 1; /* RSA */
604   nbits = count_bits (m, mlen);
605   *p++ = nbits >> 8;
606   *p++ = nbits;
607   memcpy (p, m, mlen); p += mlen;
608   nbits = count_bits (e, elen);
609   *p++ = nbits >> 8;
610   *p++ = nbits;
611   memcpy (p, e, elen); p += elen;
612     
613   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
614
615   xfree (buffer);
616
617   rc = iso7816_put_data (slot, 0, 
618                          (card_version > 0x0007? 0xC7 : 0xC6)
619                          + keynumber, fpr, 20);
620   if (rc)
621     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
622
623   if (!rc && card_version > 0x0100)
624     {
625       unsigned char buf[4];
626
627       buf[0] = timestamp >> 24;
628       buf[1] = timestamp >> 16;
629       buf[2] = timestamp >>  8;
630       buf[3] = timestamp;
631
632       rc = iso7816_put_data (slot, 0, 0xCE + keynumber, buf, 4);
633       if (rc)
634         log_error (_("failed to store the creation date: %s\n"),
635                    gpg_strerror (rc));
636     }
637
638   return rc;
639 }
640
641        
642 static void
643 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
644                       int number, const unsigned char *fpr)
645 {                      
646   int i;
647   char buf[41];
648   char numbuf[25];
649
650   for (i=0; i < 20 && !fpr[i]; i++)
651     ;
652   if (i==20)
653     return; /* All zero. */
654   for (i=0; i< 20; i++)
655     sprintf (buf+2*i, "%02X", fpr[i]);
656   if (number == -1)
657     *numbuf = 0; /* Don't print the key number */
658   else
659     sprintf (numbuf, "%d", number);
660   send_status_info (ctrl, keyword,
661                     numbuf, (size_t)strlen(numbuf),
662                     buf, (size_t)strlen (buf), NULL, 0);
663 }
664
665 static void
666 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
667                           int number, const unsigned char *stamp)
668 {                      
669   char numbuf1[50], numbuf2[50];
670   unsigned long value;
671
672   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
673   if (!value)
674     return;
675   sprintf (numbuf1, "%d", number);
676   sprintf (numbuf2, "%lu", value);
677   send_status_info (ctrl, keyword,
678                     numbuf1, (size_t)strlen(numbuf1),
679                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
680 }
681
682 static void
683 send_key_data (ctrl_t ctrl, const char *name, 
684                const unsigned char *a, size_t alen)
685 {
686   char *p, *buf = xmalloc (alen*2+1);
687   
688   for (p=buf; alen; a++, alen--, p += 2)
689     sprintf (p, "%02X", *a);
690
691   send_status_info (ctrl, "KEY-DATA",
692                     name, (size_t)strlen(name), 
693                     buf, (size_t)strlen (buf),
694                     NULL, 0);
695   xfree (buf);
696 }
697
698 /* Implement the GETATTR command.  This is similar to the LEARN
699    command but returns just one value via the status interface. */
700 static gpg_error_t 
701 do_getattr (app_t app, ctrl_t ctrl, const char *name)
702 {
703   static struct {
704     const char *name;
705     int tag;
706     int special;
707   } table[] = {
708     { "DISP-NAME",    0x005B },
709     { "LOGIN-DATA",   0x005E },
710     { "DISP-LANG",    0x5F2D },
711     { "DISP-SEX",     0x5F35 },
712     { "PUBKEY-URL",   0x5F50 },
713     { "KEY-FPR",      0x00C5, 3 },
714     { "KEY-TIME",     0x00CD, 4 },
715     { "CA-FPR",       0x00C6, 3 },
716     { "CHV-STATUS",   0x00C4, 1 }, 
717     { "SIG-COUNTER",  0x0093, 2 },
718     { "SERIALNO",     0x004F, -1 },
719     { "AID",          0x004F },
720     { "EXTCAP",       0x0000, -2 },
721     { "PRIVATE-DO-1", 0x0101 },
722     { "PRIVATE-DO-2", 0x0102 },
723     { "PRIVATE-DO-3", 0x0103 },
724     { "PRIVATE-DO-4", 0x0104 },
725     { "$AUTHKEYID",   0x0000, -3 },
726     { "$DISPSERIALNO",0x0000, -4 },
727     { NULL, 0 }
728   };
729   int idx, i, rc;
730   void *relptr;
731   unsigned char *value;
732   size_t valuelen;
733
734   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
735     ;
736   if (!table[idx].name)
737     return gpg_error (GPG_ERR_INV_NAME); 
738   
739   if (table[idx].special == -1)
740     {
741       /* The serial number is very special.  We could have used the
742          AID DO to retrieve it, but we have it already in the app
743          context and the stamp argument is required anyway which we
744          can't by other means. The AID DO is available anyway but not
745          hex formatted. */
746       char *serial;
747       time_t stamp;
748       char tmp[50];
749
750       if (!app_get_serial_and_stamp (app, &serial, &stamp))
751         {
752           sprintf (tmp, "%lu", (unsigned long)stamp);
753           send_status_info (ctrl, "SERIALNO",
754                             serial, strlen (serial),
755                             tmp, strlen (tmp),
756                             NULL, 0);
757           xfree (serial);
758         }
759       return 0;
760     }
761   if (table[idx].special == -2)
762     {
763       char tmp[50];
764
765       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d mcl3=%u", 
766                app->app_local->extcap.get_challenge,
767                app->app_local->extcap.key_import,
768                app->app_local->extcap.change_force_chv,
769                app->app_local->extcap.private_dos,
770                app->app_local->extcap.max_certlen_3);
771       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
772       return 0;
773     }
774   if (table[idx].special == -3)
775     {
776       char const tmp[] = "OPENPGP.3";
777       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
778       return 0;
779     }
780   if (table[idx].special == -4)
781     {
782       char *serial;
783       time_t stamp;
784     
785       if (!app_get_serial_and_stamp (app, &serial, &stamp))
786         {
787           if (strlen (serial) > 16+12)
788             {
789               send_status_info (ctrl, table[idx].name, serial+16, 12, NULL, 0);
790               xfree (serial);
791               return 0;
792             }
793           xfree (serial);
794         }
795       return gpg_error (GPG_ERR_INV_NAME); 
796     }
797
798   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
799   if (relptr)
800     {
801       if (table[idx].special == 1)
802         {
803           char numbuf[7*23];
804           
805           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
806             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
807           send_status_info (ctrl, table[idx].name,
808                             numbuf, strlen (numbuf), NULL, 0);
809         }
810       else if (table[idx].special == 2)
811         {
812           char numbuf[50];
813
814           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
815           send_status_info (ctrl, table[idx].name,
816                             numbuf, strlen (numbuf), NULL, 0);
817         }
818       else if (table[idx].special == 3)
819         {
820           if (valuelen >= 60)
821             for (i=0; i < 3; i++)
822               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
823         }
824       else if (table[idx].special == 4)
825         {
826           if (valuelen >= 12)
827             for (i=0; i < 3; i++)
828               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
829         }
830       else
831         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
832
833       xfree (relptr);
834     }
835   return rc;
836 }
837
838 /* Retrieve the fingerprint from the card inserted in SLOT and write
839    the according hex representation to FPR.  Caller must have provide
840    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
841    error code. */
842 #if GNUPG_MAJOR_VERSION > 1
843 static gpg_error_t
844 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
845 {
846   gpg_error_t err = 0;
847   void *relptr;
848   unsigned char *value;
849   size_t valuelen;
850   int i;
851
852   assert (keyno >=0 && keyno <= 2);
853
854   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
855   if (relptr && valuelen >= 60)
856     {
857       for (i = 0; i < 20; i++)
858         sprintf (fpr + (i * 2), "%02X", value[(keyno*20)+i]);
859     }
860   else
861     err = gpg_error (GPG_ERR_NOT_FOUND);
862   xfree (relptr);
863   return err;
864 }
865 #endif /*GNUPG_MAJOR_VERSION > 1*/
866
867
868 /* Retrieve the public key material for the RSA key, whose fingerprint
869    is FPR, from gpg output, which can be read through the stream FP.
870    The RSA modulus will be stored at the address of M and MLEN, the
871    public exponent at E and ELEN.  Returns zero on success, an error
872    code on failure.  Caller must release the allocated buffers at M
873    and E if the function returns success.  */
874 #if GNUPG_MAJOR_VERSION > 1
875 static gpg_error_t
876 retrieve_key_material (FILE *fp, const char *hexkeyid,
877                        const unsigned char **m, size_t *mlen,
878                        const unsigned char **e, size_t *elen)
879 {
880   gcry_error_t err = 0;
881   char *line = NULL;    /* read_line() buffer. */
882   size_t line_size = 0; /* Helper for for read_line. */
883   int found_key = 0;    /* Helper to find a matching key. */
884   unsigned char *m_new = NULL;
885   unsigned char *e_new = NULL;
886   size_t m_new_n = 0;
887   size_t e_new_n = 0;
888
889   /* Loop over all records until we have found the subkey
890      corresponding to the fingerprint. Inm general the first record
891      should be the pub record, but we don't rely on that.  Given that
892      we only need to look at one key, it is sufficient to compare the
893      keyid so that we don't need to look at "fpr" records. */
894   for (;;)
895     {
896       char *p;
897       char *fields[6];
898       int nfields;
899       size_t max_length;
900       gcry_mpi_t mpi;
901       int i;
902
903       max_length = 4096;
904       i = read_line (fp, &line, &line_size, &max_length);
905       if (!i)
906         break; /* EOF. */
907       if (i < 0)
908         {
909           err = gpg_error_from_syserror ();
910           goto leave; /* Error. */
911         }
912       if (!max_length)
913         {
914           err = gpg_error (GPG_ERR_TRUNCATED);
915           goto leave;  /* Line truncated - we better stop processing.  */
916         }
917
918       /* Parse the line into fields. */
919       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
920         {
921           fields[nfields] = p;
922           p = strchr (p, ':');
923           if (p)
924             *(p++) = 0;
925         }
926       if (!nfields)
927         continue; /* No fields at all - skip line.  */
928
929       if (!found_key)
930         {
931           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
932                && nfields > 4 && !strcmp (fields[4], hexkeyid))
933             found_key = 1;
934           continue;
935         }
936       
937       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
938         break; /* Next key - stop.  */
939
940       if ( strcmp (fields[0], "pkd") )
941         continue; /* Not a key data record.  */
942       i = 0; /* Avoid erroneous compiler warning. */
943       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
944            || (!i && m_new) || (i && e_new))
945         {
946           err = gpg_error (GPG_ERR_GENERAL);
947           goto leave; /* Error: Invalid key data record or not an RSA key.  */
948         }
949       
950       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
951       if (err)
952         mpi = NULL;
953       else if (!i)
954         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
955       else
956         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
957       gcry_mpi_release (mpi);
958       if (err)
959         goto leave;
960     }
961   
962   if (m_new && e_new)
963     {
964       *m = m_new;
965       *mlen = m_new_n;
966       m_new = NULL;
967       *e = e_new;
968       *elen = e_new_n;
969       e_new = NULL;
970     }
971   else
972     err = gpg_error (GPG_ERR_GENERAL);
973
974  leave:
975   xfree (m_new);
976   xfree (e_new);
977   xfree (line);
978   return err;
979 }
980 #endif /*GNUPG_MAJOR_VERSION > 1*/
981
982
983 /* Get the public key for KEYNO and store it as an S-expresion with
984    the APP handle.  On error that field gets cleared.  If we already
985    know about the public key we will just return.  Note that this does
986    not mean a key is available; this is soley indicated by the
987    presence of the app->app_local->pk[KEYNO-1].key field.
988
989    Note that GnuPG 1.x does not need this and it would be too time
990    consuming to send it just for the fun of it. However, given that we
991    use the same code in gpg 1.4, we can't use the gcry S-expresion
992    here but need to open encode it. */
993 #if GNUPG_MAJOR_VERSION > 1
994 static gpg_error_t
995 get_public_key (app_t app, int keyno)
996 {
997   gpg_error_t err = 0;
998   unsigned char *buffer;
999   const unsigned char *keydata, *m, *e;
1000   size_t buflen, keydatalen, mlen, elen;
1001   unsigned char *mbuf = NULL;
1002   unsigned char *ebuf = NULL;
1003   char *keybuf = NULL;
1004   char *keybuf_p;
1005
1006   if (keyno < 1 || keyno > 3)
1007     return gpg_error (GPG_ERR_INV_ID);
1008   keyno--;
1009
1010   /* Already cached? */
1011   if (app->app_local->pk[keyno].read_done)
1012     return 0;
1013
1014   xfree (app->app_local->pk[keyno].key);
1015   app->app_local->pk[keyno].key = NULL;
1016   app->app_local->pk[keyno].keylen = 0;
1017
1018   m = e = NULL; /* (avoid cc warning) */
1019
1020   if (app->card_version > 0x0100)
1021     {
1022       /* We may simply read the public key out of these cards.  */
1023       err = iso7816_read_public_key 
1024         (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
1025                                            keyno == 1? "\xB8" : "\xA4"),
1026          2,  
1027          &buffer, &buflen);
1028       if (err)
1029         {
1030           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
1031           goto leave;
1032         }
1033
1034       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1035       if (!keydata)
1036         {
1037           err = gpg_error (GPG_ERR_CARD);
1038           log_error (_("response does not contain the public key data\n"));
1039           goto leave;
1040         }
1041  
1042       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1043       if (!m)
1044         {
1045           err = gpg_error (GPG_ERR_CARD);
1046           log_error (_("response does not contain the RSA modulus\n"));
1047           goto leave;
1048         }
1049       
1050
1051       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1052       if (!e)
1053         {
1054           err = gpg_error (GPG_ERR_CARD);
1055           log_error (_("response does not contain the RSA public exponent\n"));
1056           goto leave;
1057         }
1058
1059       /* Prepend numbers with a 0 if needed.  */
1060       if (mlen && (*m & 0x80))
1061         {
1062           mbuf = xtrymalloc ( mlen + 1);
1063           if (!mbuf)
1064             {
1065               err = gpg_error_from_syserror ();
1066               goto leave;
1067             }
1068           *mbuf = 0;
1069           memcpy (mbuf+1, m, mlen);
1070           mlen++;
1071           m = mbuf;
1072         }
1073       if (elen && (*e & 0x80))
1074         {
1075           ebuf = xtrymalloc ( elen + 1);
1076           if (!ebuf)
1077             {
1078               err = gpg_error_from_syserror ();
1079               goto leave;
1080             }
1081           *ebuf = 0;
1082           memcpy (ebuf+1, e, elen);
1083           elen++;
1084           e = ebuf;
1085         }
1086
1087     }
1088   else
1089     {
1090       /* Due to a design problem in v1.0 cards we can't get the public
1091          key out of these cards without doing a verify on CHV3.
1092          Clearly that is not an option and thus we try to locate the
1093          key using an external helper.
1094
1095          The helper we use here is gpg itself, which should know about
1096          the key in any case.  */
1097
1098       char fpr[41];
1099       char *hexkeyid;
1100       char *command = NULL;
1101       FILE *fp;
1102       int ret;
1103
1104       buffer = NULL; /* We don't need buffer.  */
1105
1106       err = retrieve_fpr_from_card (app, keyno, fpr);
1107       if (err)
1108         {
1109           log_error ("error while retrieving fpr from card: %s\n",
1110                      gpg_strerror (err));
1111           goto leave;
1112         }
1113       hexkeyid = fpr + 24;
1114
1115       ret = estream_asprintf (&command,
1116                               "gpg --list-keys --with-colons --with-key-data '%s'",
1117                               fpr);
1118       if (ret < 0)
1119         {
1120           err = gpg_error_from_syserror ();
1121           goto leave;
1122         }
1123
1124       fp = popen (command, "r");
1125       xfree (command);
1126       if (!fp)
1127         {
1128           err = gpg_error_from_syserror ();
1129           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1130           goto leave;
1131         }
1132
1133       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1134       fclose (fp);
1135       if (err)
1136         {
1137           log_error ("error while retrieving key material through pipe: %s\n",
1138                      gpg_strerror (err));
1139           goto leave;
1140         }
1141     }
1142
1143   /* Allocate a buffer to construct the S-expression.  */
1144   /* FIXME: We should provide a generalized S-expression creation
1145      mechanism. */
1146   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1147   if (!keybuf)
1148     {
1149       err = gpg_error_from_syserror ();
1150       goto leave;
1151     }
1152   
1153   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1154   keybuf_p = keybuf + strlen (keybuf);
1155   memcpy (keybuf_p, m, mlen);
1156   keybuf_p += mlen;
1157   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1158   keybuf_p += strlen (keybuf_p);
1159   memcpy (keybuf_p, e, elen);
1160   keybuf_p += elen;
1161   strcpy (keybuf_p, ")))");
1162   keybuf_p += strlen (keybuf_p);
1163   
1164   app->app_local->pk[keyno].key = (unsigned char*)keybuf;
1165   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1166
1167  leave:
1168   /* Set a flag to indicate that we tried to read the key.  */
1169   app->app_local->pk[keyno].read_done = 1;
1170
1171   xfree (buffer);
1172   xfree (mbuf);
1173   xfree (ebuf);
1174   return 0;
1175 }
1176 #endif /* GNUPG_MAJOR_VERSION > 1 */
1177
1178
1179
1180 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1181    This is used by the LEARN command. */
1182 static gpg_error_t
1183 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1184 {
1185   gpg_error_t err = 0;
1186   /* Note that GnuPG 1.x does not need this and it would be too time
1187      consuming to send it just for the fun of it. */
1188 #if GNUPG_MAJOR_VERSION > 1
1189   unsigned char grip[20];
1190   char gripstr[41];
1191   char idbuf[50];
1192   int i;
1193
1194   err = get_public_key (app, keyno);
1195   if (err)
1196     goto leave;
1197   
1198   assert (keyno >= 1 && keyno <= 3);
1199   if (!app->app_local->pk[keyno-1].key)
1200     goto leave; /* No such key - ignore. */
1201
1202   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1203                                  app->app_local->pk[keyno-1].keylen,
1204                                  grip);
1205   if (err)
1206     goto leave;
1207   
1208   for (i=0; i < 20; i++)
1209     sprintf (gripstr+i*2, "%02X", grip[i]);
1210
1211   sprintf (idbuf, "OPENPGP.%d", keyno);
1212   send_status_info (ctrl, "KEYPAIRINFO", 
1213                     gripstr, 40, 
1214                     idbuf, strlen (idbuf), 
1215                     NULL, (size_t)0);
1216
1217  leave:
1218 #endif /* GNUPG_MAJOR_VERSION > 1 */
1219
1220   return err; 
1221 }
1222
1223
1224 /* Handle the LEARN command for OpenPGP.  */
1225 static gpg_error_t
1226 do_learn_status (app_t app, ctrl_t ctrl)
1227 {
1228   do_getattr (app, ctrl, "EXTCAP");
1229   do_getattr (app, ctrl, "DISP-NAME");
1230   do_getattr (app, ctrl, "DISP-LANG");
1231   do_getattr (app, ctrl, "DISP-SEX");
1232   do_getattr (app, ctrl, "PUBKEY-URL");
1233   do_getattr (app, ctrl, "LOGIN-DATA");
1234   do_getattr (app, ctrl, "KEY-FPR");
1235   if (app->card_version > 0x0100)
1236     do_getattr (app, ctrl, "KEY-TIME");
1237   do_getattr (app, ctrl, "CA-FPR");
1238   do_getattr (app, ctrl, "CHV-STATUS");
1239   do_getattr (app, ctrl, "SIG-COUNTER");
1240   if (app->app_local->extcap.private_dos)
1241     {
1242       do_getattr (app, ctrl, "PRIVATE-DO-1");
1243       do_getattr (app, ctrl, "PRIVATE-DO-2");
1244       if (app->did_chv2)
1245         do_getattr (app, ctrl, "PRIVATE-DO-3");
1246       if (app->did_chv3)
1247         do_getattr (app, ctrl, "PRIVATE-DO-4");
1248     }
1249   send_keypair_info (app, ctrl, 1);
1250   send_keypair_info (app, ctrl, 2);
1251   send_keypair_info (app, ctrl, 3);
1252   /* Note: We do not send the Cardholder Certificate, because that is
1253      relativly long and for OpenPGP applications not really needed.  */
1254   return 0;
1255 }
1256
1257
1258 /* Handle the READKEY command for OpenPGP.  On success a canonical
1259    encoded S-expression with the public key will get stored at PK and
1260    its length (for assertions) at PKLEN; the caller must release that
1261    buffer. On error PK and PKLEN are not changed and an error code is
1262    returned.  */
1263 static gpg_error_t
1264 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1265 {
1266 #if GNUPG_MAJOR_VERSION > 1
1267   gpg_error_t err;
1268   int keyno;
1269   unsigned char *buf;
1270
1271   if (!strcmp (keyid, "OPENPGP.1"))
1272     keyno = 1;
1273   else if (!strcmp (keyid, "OPENPGP.2"))
1274     keyno = 2;
1275   else if (!strcmp (keyid, "OPENPGP.3"))
1276     keyno = 3;
1277   else
1278     return gpg_error (GPG_ERR_INV_ID);
1279
1280   err = get_public_key (app, keyno);
1281   if (err)
1282     return err;
1283
1284   buf = app->app_local->pk[keyno-1].key;
1285   if (!buf)
1286     return gpg_error (GPG_ERR_NO_PUBKEY);
1287   *pklen = app->app_local->pk[keyno-1].keylen;;
1288   *pk = xtrymalloc (*pklen);
1289   if (!*pk)
1290     {
1291       err = gpg_error_from_syserror ();
1292       *pklen = 0;
1293       return err;
1294     }
1295   memcpy (*pk, buf, *pklen);
1296   return 0;
1297 #else
1298   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1299 #endif
1300 }
1301
1302 /* Read the standard certificate of an OpenPGP v2 card.  It is
1303    returned in a freshly allocated buffer with that address stored at
1304    CERT and the length of the certificate stored at CERTLEN.  CERTID
1305    needs to be set to "OPENPGP.3".  */
1306 static gpg_error_t
1307 do_readcert (app_t app, const char *certid,
1308              unsigned char **cert, size_t *certlen)
1309 {
1310 #if GNUPG_MAJOR_VERSION > 1
1311   gpg_error_t err;
1312   unsigned char *buffer;
1313   size_t buflen;
1314   void *relptr;
1315
1316   *cert = NULL;
1317   *certlen = 0;
1318   if (strcmp (certid, "OPENPGP.3"))
1319     return gpg_error (GPG_ERR_INV_ID);
1320   if (!app->app_local->extcap.is_v2)
1321     return gpg_error (GPG_ERR_NOT_FOUND);
1322
1323   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1324   if (!relptr)
1325     return gpg_error (GPG_ERR_NOT_FOUND);
1326
1327   *cert = xtrymalloc (buflen);
1328   if (!*cert)
1329     err = gpg_error_from_syserror ();
1330   else
1331     {
1332       memcpy (*cert, buffer, buflen);
1333       *certlen = buflen;
1334       err  = 0;
1335     }
1336   xfree (relptr);
1337   return err;
1338 #else
1339   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1340 #endif
1341 }
1342
1343
1344 /* Verify a CHV either using using the pinentry or if possibile by
1345    using a keypad.  PINCB and PINCB_ARG describe the usual callback
1346    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1347    used with CHV1.  PINVALUE is the address of a pointer which will
1348    receive a newly allocated block with the actual PIN (this is useful
1349    in case that PIN shall be used for another verifiy operation).  The
1350    caller needs to free this value.  If the function returns with
1351    success and NULL is stored at PINVALUE, the caller should take this
1352    as an indication that the keypad has been used.
1353    */
1354 static gpg_error_t
1355 verify_a_chv (app_t app,
1356               gpg_error_t (*pincb)(void*, const char *, char **),
1357               void *pincb_arg,
1358               int chvno, unsigned long sigcount, char **pinvalue)
1359 {
1360   int rc = 0;
1361   char *prompt;
1362   iso7816_pininfo_t pininfo;
1363   int minlen = 6;
1364
1365   assert (chvno == 1 || chvno == 2);
1366
1367   *pinvalue = NULL;
1368
1369   if (chvno == 2 && app->app_local->flags.def_chv2)
1370     {
1371       /* Special case for def_chv2 mechanism. */
1372       if (opt.verbose)
1373         log_info (_("using default PIN as %s\n"), "CHV2");
1374       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1375       if (rc)
1376         {
1377           /* Verification of CHV2 with the default PIN failed,
1378              although the card pretends to have the default PIN set as
1379              CHV2.  We better disable the def_chv2 flag now. */
1380           log_info (_("failed to use default PIN as %s: %s"
1381                       " - disabling further default use\n"),
1382                     "CHV2", gpg_strerror (rc));
1383           app->app_local->flags.def_chv2 = 0;
1384         }
1385       return rc;
1386     }
1387
1388   memset (&pininfo, 0, sizeof pininfo);
1389   pininfo.mode = 1;
1390   pininfo.minlen = minlen;
1391   
1392   if (!opt.disable_keypad
1393       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1394     {
1395       /* The reader supports the verify command through the keypad. */
1396
1397       if (chvno == 1)
1398         {
1399 #define PROMPTSTRING  _("||Please enter your PIN at the reader's keypad%%0A" \
1400                         "[sigs done: %lu]")
1401           size_t promptsize = strlen (PROMPTSTRING) + 50;
1402
1403           prompt = xmalloc (promptsize);
1404           if (!prompt)
1405             return gpg_error_from_syserror ();
1406           snprintf (prompt, promptsize-1, PROMPTSTRING, sigcount);
1407           rc = pincb (pincb_arg, prompt, NULL); 
1408           xfree (prompt);
1409 #undef PROMPTSTRING
1410         }
1411       else
1412         rc = pincb (pincb_arg,
1413                     _("||Please enter your PIN at the reader's keypad"),
1414                     NULL);
1415       if (rc)
1416         {
1417           log_info (_("PIN callback returned error: %s\n"),
1418                     gpg_strerror (rc));
1419           return rc;
1420         }
1421       rc = iso7816_verify_kp (app->slot, 0x80+chvno, "", 0, &pininfo); 
1422       /* Dismiss the prompt. */
1423       pincb (pincb_arg, NULL, NULL);
1424
1425       assert (!*pinvalue);
1426     }
1427   else
1428     {
1429       /* The reader has no keypad or we don't want to use it. */
1430
1431       if (chvno == 1)
1432         {
1433 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1434           size_t promptsize = strlen (PROMPTSTRING) + 50;
1435
1436           prompt = xtrymalloc (promptsize);
1437           if (!prompt)
1438             return gpg_error_from_syserror ();
1439           snprintf (prompt, promptsize-1, PROMPTSTRING, sigcount);
1440           rc = pincb (pincb_arg, prompt, pinvalue); 
1441           xfree (prompt);
1442 #undef PROMPTSTRING
1443         }
1444       else
1445         rc = pincb (pincb_arg, _("||Please enter the PIN"), pinvalue); 
1446
1447       if (rc)
1448         {
1449           log_info (_("PIN callback returned error: %s\n"),
1450                     gpg_strerror (rc));
1451           return rc;
1452         }
1453       
1454       if (strlen (*pinvalue) < minlen)
1455         {
1456           log_error (_("PIN for CHV%d is too short;"
1457                        " minimum length is %d\n"), chvno, minlen);
1458           xfree (*pinvalue);
1459           *pinvalue = NULL;
1460           return gpg_error (GPG_ERR_BAD_PIN);
1461         }
1462
1463       rc = iso7816_verify (app->slot, 0x80+chvno,
1464                            *pinvalue, strlen (*pinvalue));
1465     }
1466   
1467   if (rc)
1468     {
1469       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1470       xfree (*pinvalue);
1471       *pinvalue = NULL;
1472       flush_cache_after_error (app);
1473     }
1474
1475   return rc;
1476 }
1477
1478
1479 /* Verify CHV2 if required.  Depending on the configuration of the
1480    card CHV1 will also be verified. */
1481 static gpg_error_t
1482 verify_chv2 (app_t app,
1483              gpg_error_t (*pincb)(void*, const char *, char **),
1484              void *pincb_arg)
1485 {
1486   int rc;
1487   char *pinvalue;
1488
1489   if (app->did_chv2) 
1490     return 0;  /* We already verified CHV2.  */
1491
1492   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1493   if (rc)
1494     return rc;
1495
1496   app->did_chv2 = 1;
1497   
1498   if (!app->did_chv1 && !app->force_chv1 && pinvalue 
1499       && !app->app_local->extcap.is_v2)
1500     {
1501       /* For convenience we verify CHV1 here too.  We do this only if
1502          the card is not configured to require a verification before
1503          each CHV1 controlled operation (force_chv1) and if we are not
1504          using the keypad (PINVALUE == NULL). */
1505       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1506       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1507         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1508       if (rc)
1509         {
1510           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1511           flush_cache_after_error (app);
1512         }
1513       else
1514         app->did_chv1 = 1;
1515     }
1516   xfree (pinvalue);
1517
1518   return rc;
1519 }
1520
1521
1522 /* Verify CHV3 if required. */
1523 static gpg_error_t
1524 verify_chv3 (app_t app,
1525              gpg_error_t (*pincb)(void*, const char *, char **),
1526              void *pincb_arg)
1527 {
1528   int rc = 0;
1529
1530 #if GNUPG_MAJOR_VERSION != 1
1531   if (!opt.allow_admin)
1532     {
1533       log_info (_("access to admin commands is not configured\n"));
1534       return gpg_error (GPG_ERR_EACCES);
1535     }
1536 #endif
1537       
1538   if (!app->did_chv3) 
1539     {
1540       void *relptr;
1541       unsigned char *value;
1542       size_t valuelen;
1543       iso7816_pininfo_t pininfo;
1544       int minlen = 8;
1545       int remaining;
1546
1547       memset (&pininfo, 0, sizeof pininfo);
1548       pininfo.mode = 1;
1549       pininfo.minlen = minlen;
1550
1551       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1552       if (!relptr || valuelen < 7)
1553         {
1554           log_error (_("error retrieving CHV status from card\n"));
1555           xfree (relptr);
1556           return gpg_error (GPG_ERR_CARD);
1557         }
1558       if (value[6] == 0)
1559         {
1560           log_info (_("card is permanently locked!\n"));
1561           xfree (relptr);
1562           return gpg_error (GPG_ERR_BAD_PIN);
1563         }
1564       remaining = value[6];
1565       xfree (relptr);
1566
1567       log_info(_("%d Admin PIN attempts remaining before card"
1568                  " is permanently locked\n"), remaining);
1569
1570       if (!opt.disable_keypad
1571           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1572         {
1573           /* The reader supports the verify command through the keypad. */
1574           
1575           if (remaining < 3)
1576             {
1577 #define PROMPTSTRING  _("|A|Please enter the Admin PIN" \
1578                         " at the reader's keypad%%0A"   \
1579                         "[remaining attempts: %d]")
1580               size_t promptsize = strlen (PROMPTSTRING) + 50;
1581               char *prompt;
1582               
1583               prompt = xmalloc (promptsize);
1584               if (!prompt)
1585                 return gpg_error_from_syserror ();
1586               snprintf (prompt, promptsize-1, PROMPTSTRING, remaining);
1587               rc = pincb (pincb_arg, prompt, NULL); 
1588               xfree (prompt);
1589 #undef PROMPTSTRING
1590             }
1591           else
1592             rc = pincb (pincb_arg, _("|A|Please enter the Admin PIN"
1593                                      " at the reader's keypad"),   NULL);
1594
1595           if (rc)
1596             {
1597               log_info (_("PIN callback returned error: %s\n"),
1598                         gpg_strerror (rc));
1599               return rc;
1600             }
1601           rc = iso7816_verify_kp (app->slot, 0x83, "", 0, &pininfo); 
1602           /* Dismiss the prompt. */
1603           pincb (pincb_arg, NULL, NULL);
1604         }
1605       else
1606         {
1607           char *pinvalue;
1608
1609           /* TRANSLATORS: Do not translate the "|A|" prefix but keep
1610              it at the start of the string.  We need this elsewhere to
1611              get some infos on the string. */
1612           rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1613           if (rc)
1614             {
1615               log_info (_("PIN callback returned error: %s\n"),
1616                         gpg_strerror (rc));
1617               return rc;
1618             }
1619           
1620           if (strlen (pinvalue) < minlen)
1621             {
1622               log_error (_("PIN for CHV%d is too short;"
1623                            " minimum length is %d\n"), 3, minlen);
1624               xfree (pinvalue);
1625               return gpg_error (GPG_ERR_BAD_PIN);
1626             }
1627           
1628           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1629           xfree (pinvalue);
1630         }
1631       
1632       if (rc)
1633         {
1634           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1635           flush_cache_after_error (app);
1636           return rc;
1637         }
1638     }
1639   return rc;
1640 }
1641
1642
1643 /* Handle the SETATTR operation. All arguments are already basically
1644    checked. */
1645 static gpg_error_t 
1646 do_setattr (app_t app, const char *name,
1647             gpg_error_t (*pincb)(void*, const char *, char **),
1648             void *pincb_arg,
1649             const unsigned char *value, size_t valuelen)
1650 {
1651   gpg_error_t rc;
1652   int idx;
1653   static struct {
1654     const char *name;
1655     int tag;
1656     int need_chv;
1657     int special;
1658     unsigned int need_v2:1;
1659   } table[] = {
1660     { "DISP-NAME",    0x005B, 3 },
1661     { "LOGIN-DATA",   0x005E, 3, 2 },
1662     { "DISP-LANG",    0x5F2D, 3 },
1663     { "DISP-SEX",     0x5F35, 3 },
1664     { "PUBKEY-URL",   0x5F50, 3 },
1665     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1666     { "CA-FPR-1",     0x00CA, 3 },
1667     { "CA-FPR-2",     0x00CB, 3 },
1668     { "CA-FPR-3",     0x00CC, 3 },
1669     { "PRIVATE-DO-1", 0x0101, 2 },
1670     { "PRIVATE-DO-2", 0x0102, 3 },
1671     { "PRIVATE-DO-3", 0x0103, 2 },
1672     { "PRIVATE-DO-4", 0x0104, 3 },
1673     { "CERT-3",       0x7F21, 3, 0, 1 },
1674     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
1675     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
1676     { "PW-RESET-CODE",0x00D3, 3, 0, 1 },
1677     { NULL, 0 }
1678   };
1679   int exmode;
1680
1681   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1682     ;
1683   if (!table[idx].name)
1684     return gpg_error (GPG_ERR_INV_NAME); 
1685   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
1686     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
1687
1688   switch (table[idx].need_chv)
1689     {
1690     case 2:
1691       rc = verify_chv2 (app, pincb, pincb_arg);
1692       break;
1693     case 3:
1694       rc = verify_chv3 (app, pincb, pincb_arg);
1695       break;
1696     default:
1697       rc = 0;
1698     }
1699   if (rc)
1700     return rc;
1701
1702   /* Flush the cache before writing it, so that the next get operation
1703      will reread the data from the card and thus get synced in case of
1704      errors (e.g. data truncated by the card). */
1705   flush_cache_item (app, table[idx].tag);
1706   /* For command chaining we use a value of 254 for this card.  */
1707   if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
1708     exmode = -254;
1709   else
1710     exmode = 0;
1711   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
1712   if (rc)
1713     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1714
1715   if (table[idx].special == 1)
1716     app->force_chv1 = (valuelen && *value == 0);
1717   else if (table[idx].special == 2)
1718     parse_login_data (app);
1719
1720   return rc;
1721 }
1722
1723
1724 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
1725    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
1726    PINCB and PINCB_ARG are the usual arguments for the pinentry
1727    callback.  */
1728 static gpg_error_t
1729 do_writecert (app_t app, ctrl_t ctrl,
1730               const char *certidstr, 
1731               gpg_error_t (*pincb)(void*, const char *, char **),
1732               void *pincb_arg,
1733               const unsigned char *certdata, size_t certdatalen)
1734 {
1735 #if GNUPG_MAJOR_VERSION > 1
1736   if (strcmp (certidstr, "OPENPGP.3"))
1737     return gpg_error (GPG_ERR_INV_ID);
1738   if (!certdata || !certdatalen)
1739     return gpg_error (GPG_ERR_INV_ARG);
1740   if (!app->app_local->extcap.is_v2)
1741     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1742   if (certdatalen > app->app_local->extcap.max_certlen_3)
1743     return gpg_error (GPG_ERR_TOO_LARGE);
1744   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1745 #else
1746   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1747 #endif
1748 }
1749
1750
1751
1752 /* Handle the PASSWD command. */
1753 static gpg_error_t 
1754 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, 
1755                unsigned int flags,
1756                gpg_error_t (*pincb)(void*, const char *, char **),
1757                void *pincb_arg)
1758 {
1759   int rc = 0;
1760   int chvno = atoi (chvnostr);
1761   char *pinvalue;
1762   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
1763
1764   if (reset_mode && chvno == 3)
1765     {
1766       rc = gpg_error (GPG_ERR_INV_ID);
1767       goto leave;
1768     }
1769   else if (reset_mode || chvno == 3)
1770     {
1771       /* we always require that the PIN is entered. */
1772       app->did_chv3 = 0;
1773       rc = verify_chv3 (app, pincb, pincb_arg);
1774       if (rc)
1775         goto leave;
1776     }
1777   else if (chvno == 1 || chvno == 2)
1778     {
1779       /* CHV1 and CVH2 should always have the same value, thus we
1780          enforce it here.  */
1781       int save_force = app->force_chv1;
1782
1783       app->force_chv1 = 0;
1784       app->did_chv1 = 0;
1785       app->did_chv2 = 0;
1786       rc = verify_chv2 (app, pincb, pincb_arg);
1787       app->force_chv1 = save_force;
1788       if (rc)
1789         goto leave;
1790     }
1791   else
1792     {
1793       rc = gpg_error (GPG_ERR_INV_ID);
1794       goto leave;
1795     }
1796
1797   if (chvno == 3)
1798     app->did_chv3 = 0;
1799   else
1800     app->did_chv1 = app->did_chv2 = 0;
1801
1802   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1803      keep it at the start of the string.  We need this elsewhere
1804      to get some infos on the string. */
1805   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1806               &pinvalue); 
1807   if (rc)
1808     {
1809       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1810       goto leave;
1811     }
1812
1813   if (reset_mode)
1814     {
1815       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1816                                         pinvalue, strlen (pinvalue));
1817       if (!rc)
1818         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1819                                           pinvalue, strlen (pinvalue));
1820     }
1821   else
1822     {
1823       if (chvno == 1 || chvno == 2)
1824         {
1825           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1826                                               pinvalue, strlen (pinvalue));
1827           if (!rc)
1828             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1829                                                 pinvalue, strlen (pinvalue));
1830         }
1831       else
1832         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1833                                             pinvalue, strlen (pinvalue));
1834     }
1835   xfree (pinvalue);
1836   if (rc)
1837     flush_cache_after_error (app);
1838
1839  leave:
1840   return rc;
1841 }
1842
1843
1844 /* Check whether a key already exists.  KEYIDX is the index of the key
1845    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1846    error returned if the key already exists. */
1847 static gpg_error_t
1848 does_key_exist (app_t app, int keyidx, int force)
1849 {
1850   const unsigned char *fpr;
1851   unsigned char *buffer;
1852   size_t buflen, n;
1853   int i;
1854
1855   assert (keyidx >=0 && keyidx <= 2);
1856
1857   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1858     {
1859       log_error (_("error reading application data\n"));
1860       return gpg_error (GPG_ERR_GENERAL);
1861     }
1862   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1863   if (!fpr || n < 60)
1864     {
1865       log_error (_("error reading fingerprint DO\n"));
1866       xfree (buffer);
1867       return gpg_error (GPG_ERR_GENERAL);
1868     }
1869   fpr += 20*keyidx;
1870   for (i=0; i < 20 && !fpr[i]; i++)
1871     ;
1872   xfree (buffer);
1873   if (i!=20 && !force)
1874     {
1875       log_error (_("key already exists\n"));
1876       return gpg_error (GPG_ERR_EEXIST);
1877     }
1878   else if (i!=20)
1879     log_info (_("existing key will be replaced\n"));
1880   else
1881     log_info (_("generating new key\n"));
1882   return 0;
1883 }
1884
1885
1886
1887 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
1888    canonical encoded S-expression with the secret key in KEYDATA and
1889    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
1890    usual keyid which for OpenPGP is the string "OPENPGP.n" with
1891    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
1892    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
1893    the pinentry callback.  */
1894 static gpg_error_t
1895 do_writekey (app_t app, ctrl_t ctrl,
1896              const char *keyid, unsigned int flags,
1897              gpg_error_t (*pincb)(void*, const char *, char **),
1898              void *pincb_arg,
1899              const unsigned char *keydata, size_t keydatalen)
1900 {
1901   gpg_error_t err;
1902   int force = (flags & 1);
1903   int keyno;
1904   const unsigned char *buf, *tok;
1905   size_t buflen, toklen;
1906   int depth, last_depth1, last_depth2;
1907   const unsigned char *rsa_n = NULL;
1908   const unsigned char *rsa_e = NULL;
1909   const unsigned char *rsa_p = NULL;
1910   const unsigned char *rsa_q = NULL;
1911   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
1912   unsigned int nbits;
1913   unsigned char *template = NULL;
1914   unsigned char *tp;
1915   size_t template_len;
1916   unsigned char fprbuf[20];
1917   u32 created_at = 0;
1918
1919   if (!strcmp (keyid, "OPENPGP.1"))
1920     keyno = 0;
1921   else if (!strcmp (keyid, "OPENPGP.2"))
1922     keyno = 1;
1923   else if (!strcmp (keyid, "OPENPGP.3"))
1924     keyno = 2;
1925   else
1926     return gpg_error (GPG_ERR_INV_ID);
1927   
1928   err = does_key_exist (app, keyno, force);
1929   if (err)
1930     return err;
1931
1932
1933   /* 
1934      Parse the S-expression
1935    */
1936   buf = keydata;
1937   buflen = keydatalen;
1938   depth = 0;
1939   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1940     goto leave;
1941   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1942     goto leave;
1943   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
1944     {
1945       if (!tok)
1946         ;
1947       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
1948         log_info ("protected-private-key passed to writekey\n");
1949       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
1950         log_info ("shadowed-private-key passed to writekey\n");
1951       err = gpg_error (GPG_ERR_BAD_SECKEY);
1952       goto leave;
1953     }
1954   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1955     goto leave;
1956   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1957     goto leave;
1958   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
1959     {
1960       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
1961       goto leave;
1962     }
1963   last_depth1 = depth;
1964   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1965          && depth && depth >= last_depth1)
1966     {
1967       if (tok)
1968         {
1969           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1970           goto leave;
1971         }
1972       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1973         goto leave;
1974       if (tok && toklen == 1)
1975         {
1976           const unsigned char **mpi;
1977           size_t *mpi_len;
1978
1979           switch (*tok)
1980             {
1981             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
1982             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
1983             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
1984             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
1985             default: mpi = NULL;  mpi_len = NULL; break;
1986             }
1987           if (mpi && *mpi)
1988             {
1989               err = gpg_error (GPG_ERR_DUP_VALUE);
1990               goto leave;
1991             }
1992           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1993             goto leave;
1994           if (tok && mpi)
1995             {
1996               /* Strip off leading zero bytes and save. */
1997               for (;toklen && !*tok; toklen--, tok++)
1998                 ;
1999               *mpi = tok;
2000               *mpi_len = toklen;
2001             }
2002         }
2003       /* Skip until end of list. */
2004       last_depth2 = depth;
2005       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2006              && depth && depth >= last_depth2)
2007         ;
2008       if (err)
2009         goto leave;
2010     }
2011   /* Parse other attributes. */
2012   last_depth1 = depth;
2013   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2014          && depth && depth >= last_depth1)
2015     {
2016       if (tok)
2017         {
2018           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2019           goto leave;
2020         }
2021       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2022         goto leave;
2023       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2024         {
2025           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2026             goto leave;
2027           if (tok)
2028             {
2029               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2030                    tok++, toklen--)
2031                 created_at = created_at*10 + (*tok - '0');
2032             }
2033         }
2034       /* Skip until end of list. */
2035       last_depth2 = depth;
2036       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2037              && depth && depth >= last_depth2)
2038         ;
2039       if (err)
2040         goto leave;
2041     }
2042
2043
2044   /* Check that we have all parameters and that they match the card
2045      description. */
2046   if (!created_at)
2047     {
2048       log_error (_("creation timestamp missing\n"));
2049       err = gpg_error (GPG_ERR_INV_VALUE);
2050       goto leave;
2051     }
2052   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2053   if (nbits != 1024)
2054     {
2055       log_error (_("RSA modulus missing or not of size %d bits\n"), 1024);
2056       err = gpg_error (GPG_ERR_BAD_SECKEY);
2057       goto leave;
2058     }
2059   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2060   if (nbits < 2 || nbits > 32)
2061     {
2062       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2063                  32);
2064       err = gpg_error (GPG_ERR_BAD_SECKEY);
2065       goto leave;
2066     }
2067   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2068   if (nbits != 512)
2069     {
2070       log_error (_("RSA prime %s missing or not of size %d bits\n"), "P", 512);
2071       err = gpg_error (GPG_ERR_BAD_SECKEY);
2072       goto leave;
2073     }
2074   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2075   if (nbits != 512)
2076     {
2077       log_error (_("RSA prime %s missing or not of size %d bits\n"), "Q", 512);
2078       err = gpg_error (GPG_ERR_BAD_SECKEY);
2079       goto leave;
2080     }
2081   
2082
2083   /* Build the private key template as described in section 4.3.3.6 of
2084      the OpenPGP card specs:
2085          0xC0   <length> public exponent
2086          0xC1   <length> prime p 
2087          0xC2   <length> prime q 
2088   */
2089   assert (rsa_e_len <= 4);
2090   template_len = (1 + 1 + 4
2091                   + 1 + 1 + rsa_p_len
2092                   + 1 + 1 + rsa_q_len);
2093   template = tp = xtrymalloc_secure (template_len);
2094   if (!template)
2095     {
2096       err = gpg_error_from_syserror ();
2097       goto leave;
2098     }
2099   *tp++ = 0xC0;
2100   *tp++ = 4;
2101   memcpy (tp, rsa_e, rsa_e_len);
2102   if (rsa_e_len < 4)
2103     {
2104       /* Right justify E. */
2105       memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2106       memset (tp, 0, 4-rsa_e_len);
2107     }                 
2108   tp += 4;
2109
2110   *tp++ = 0xC1;
2111   *tp++ = rsa_p_len;
2112   memcpy (tp, rsa_p, rsa_p_len);
2113   tp += rsa_p_len;
2114
2115   *tp++ = 0xC2;
2116   *tp++ = rsa_q_len;
2117   memcpy (tp, rsa_q, rsa_q_len);
2118   tp += rsa_q_len;
2119
2120   assert (tp - template == template_len);
2121
2122
2123   /* Obviously we need to remove the cached public key.  */
2124   xfree (app->app_local->pk[keyno].key);
2125   app->app_local->pk[keyno].key = NULL;
2126   app->app_local->pk[keyno].keylen = 0;
2127   app->app_local->pk[keyno].read_done = 0;
2128
2129   /* Prepare for storing the key.  */
2130   err = verify_chv3 (app, pincb, pincb_arg);
2131   if (err)
2132     goto leave;
2133
2134   /* Store the key. */
2135   err = iso7816_put_data (app->slot, 0,
2136                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
2137                          template, template_len);
2138   if (err)
2139     {
2140       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2141       goto leave;
2142     }
2143  
2144   err = store_fpr (app->slot, keyno, created_at,
2145                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2146                   fprbuf, app->card_version);
2147   if (err)
2148     goto leave;
2149
2150
2151  leave:
2152   xfree (template);
2153   return err;
2154 }
2155
2156
2157 /* Handle the GENKEY command. */
2158 static gpg_error_t 
2159 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2160            time_t createtime,
2161            gpg_error_t (*pincb)(void*, const char *, char **),
2162            void *pincb_arg)
2163 {
2164   int rc;
2165   char numbuf[30];
2166   unsigned char fprbuf[20];
2167   const unsigned char *keydata, *m, *e;
2168   unsigned char *buffer = NULL;
2169   size_t buflen, keydatalen, mlen, elen;
2170   time_t created_at;
2171   int keyno = atoi (keynostr);
2172   int force = (flags & 1);
2173   time_t start_at;
2174
2175   if (keyno < 1 || keyno > 3)
2176     return gpg_error (GPG_ERR_INV_ID);
2177   keyno--;
2178
2179   /* We flush the cache to increase the traffic before a key
2180      generation.  This _might_ help a card to gather more entropy. */
2181   flush_cache (app);
2182
2183   /* Obviously we need to remove the cached public key.  */
2184   xfree (app->app_local->pk[keyno].key);
2185   app->app_local->pk[keyno].key = NULL;
2186   app->app_local->pk[keyno].keylen = 0;
2187   app->app_local->pk[keyno].read_done = 0;
2188
2189   /* Check whether a key already exists.  */
2190   rc = does_key_exist (app, keyno, force);
2191   if (rc)
2192     return rc;
2193
2194   /* Prepare for key generation by verifying the Admin PIN.  */
2195   rc = verify_chv3 (app, pincb, pincb_arg);
2196   if (rc)
2197     goto leave;
2198    
2199 #if 1
2200   log_info (_("please wait while key is being generated ...\n"));
2201   start_at = time (NULL);
2202   rc = iso7816_generate_keypair 
2203 #else
2204 # warning key generation temporary replaced by reading an existing key.
2205   rc = iso7816_read_public_key
2206 #endif
2207     (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
2208                                        keyno == 1? "\xB8" : "\xA4"),
2209      2,
2210      &buffer, &buflen);
2211   if (rc)
2212     {
2213       rc = gpg_error (GPG_ERR_CARD);
2214       log_error (_("generating key failed\n"));
2215       goto leave;
2216     }
2217   log_info (_("key generation completed (%d seconds)\n"),
2218             (int)(time (NULL) - start_at));
2219   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2220   if (!keydata)
2221     {
2222       rc = gpg_error (GPG_ERR_CARD);
2223       log_error (_("response does not contain the public key data\n"));
2224       goto leave;
2225     }
2226  
2227   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2228   if (!m)
2229     {
2230       rc = gpg_error (GPG_ERR_CARD);
2231       log_error (_("response does not contain the RSA modulus\n"));
2232       goto leave;
2233     }
2234 /*    log_printhex ("RSA n:", m, mlen); */
2235   send_key_data (ctrl, "n", m, mlen);
2236
2237   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2238   if (!e)
2239     {
2240       rc = gpg_error (GPG_ERR_CARD);
2241       log_error (_("response does not contain the RSA public exponent\n"));
2242       goto leave;
2243     }
2244 /*    log_printhex ("RSA e:", e, elen); */
2245   send_key_data (ctrl, "e", e, elen);
2246
2247   created_at = createtime? createtime : gnupg_get_time ();
2248   sprintf (numbuf, "%lu", (unsigned long)created_at);
2249   send_status_info (ctrl, "KEY-CREATED-AT",
2250                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2251
2252   rc = store_fpr (app->slot, keyno, (u32)created_at,
2253                   m, mlen, e, elen, fprbuf, app->card_version);
2254   if (rc)
2255     goto leave;
2256   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2257
2258
2259  leave:
2260   xfree (buffer);
2261   return rc;
2262 }
2263
2264
2265 static unsigned long
2266 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2267 {
2268   unsigned long ul;
2269
2270   if (valuelen == 3 )
2271     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2272   else
2273     {
2274       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2275       ul = 0;
2276     }
2277   return ul;
2278 }
2279
2280 static unsigned long
2281 get_sig_counter (app_t app)
2282 {
2283   void *relptr;
2284   unsigned char *value;
2285   size_t valuelen;
2286   unsigned long ul;
2287
2288   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2289   if (!relptr)
2290     return 0;
2291   ul = convert_sig_counter_value (value, valuelen);
2292   xfree (relptr);
2293   return ul;
2294 }
2295
2296 static gpg_error_t
2297 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2298 {
2299   const unsigned char *fpr;
2300   unsigned char *buffer;
2301   size_t buflen, n;
2302   int rc, i;
2303   
2304   assert (keyno >= 1 && keyno <= 3);
2305
2306   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2307   if (rc)
2308     {
2309       log_error (_("error reading application data\n"));
2310       return gpg_error (GPG_ERR_GENERAL);
2311     }
2312   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2313   if (!fpr || n != 60)
2314     {
2315       xfree (buffer);
2316       log_error (_("error reading fingerprint DO\n"));
2317       return gpg_error (GPG_ERR_GENERAL);
2318     }
2319   fpr += (keyno-1)*20;
2320   for (i=0; i < 20; i++)
2321     if (sha1fpr[i] != fpr[i])
2322       {
2323         xfree (buffer);
2324         log_info (_("fingerprint on card does not match requested one\n"));
2325         return gpg_error (GPG_ERR_WRONG_SECKEY);
2326       }
2327   xfree (buffer);
2328   return 0;
2329 }
2330
2331
2332   /* If a fingerprint has been specified check it against the one on
2333      the card.  This is allows for a meaningful error message in case
2334      the key on the card has been replaced but the shadow information
2335      known to gpg was not updated.  If there is no fingerprint we
2336      assume that this is okay. */
2337 static gpg_error_t
2338 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2339 {
2340   unsigned char tmp[20];
2341   const char *s;
2342   int n;
2343
2344   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2345     ;
2346   if (n != 40)
2347     return gpg_error (GPG_ERR_INV_ID);
2348   else if (!*s)
2349     ; /* okay */
2350   else
2351     return gpg_error (GPG_ERR_INV_ID);
2352
2353   for (s=fpr, n=0; n < 20; s += 2, n++)
2354         tmp[n] = xtoi_2 (s);
2355   return compare_fingerprint (app, keyno, tmp);
2356 }
2357
2358
2359
2360 /* Compute a digital signature on INDATA which is expected to be the
2361    raw message digest. For this application the KEYIDSTR consists of
2362    the serialnumber and the fingerprint delimited by a slash.
2363
2364    Note that this function may return the error code
2365    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2366    not match the one required for the requested action (e.g. the
2367    serial number does not match). 
2368    
2369    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2370    operation to the auth command.
2371 */
2372 static gpg_error_t 
2373 do_sign (app_t app, const char *keyidstr, int hashalgo,
2374          gpg_error_t (*pincb)(void*, const char *, char **),
2375          void *pincb_arg,
2376          const void *indata, size_t indatalen,
2377          unsigned char **outdata, size_t *outdatalen )
2378 {
2379   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2380     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2381       0x02, 0x01, 0x05, 0x00, 0x04, 0x14  };
2382   static unsigned char sha1_prefix[15] =   /* (1.3.14.3.2.26) */
2383     { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2384       0x02, 0x1a, 0x05, 0x00, 0x04, 0x14  };
2385   static unsigned char sha224_prefix[19] = /* (2.16.840.1.101.3.4.2.4) */
2386     { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
2387       0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
2388       0x1C  };
2389   static unsigned char sha256_prefix[19] = /* (2.16.840.1.101.3.4.2.1) */
2390     { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2391       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
2392       0x00, 0x04, 0x20  };
2393   static unsigned char sha384_prefix[19] = /* (2.16.840.1.101.3.4.2.2) */
2394     { 0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2395       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
2396       0x00, 0x04, 0x30  };
2397   static unsigned char sha512_prefix[19] = /* (2.16.840.1.101.3.4.2.3) */
2398     { 0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
2399       0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
2400       0x00, 0x04, 0x40  };
2401   int rc;
2402   unsigned char data[19+64];
2403   size_t datalen;
2404   unsigned char tmp_sn[20]; /* Actually 16 bytes but also for the fpr. */
2405   const char *s;
2406   int n;
2407   const char *fpr = NULL;
2408   unsigned long sigcount;
2409   int use_auth = 0;
2410
2411   if (!keyidstr || !*keyidstr)
2412     return gpg_error (GPG_ERR_INV_VALUE);
2413
2414   /* Strip off known prefixes.  */
2415 #define X(a,b,c,d) \
2416   if (hashalgo == GCRY_MD_ ## a                               \
2417       && (d)                                                  \
2418       && indatalen == sizeof b ## _prefix + (c)               \
2419       && !memcmp (indata, b ## _prefix, sizeof b ## _prefix)) \
2420     {                                                         \
2421       indata = (const char*)indata + sizeof b ## _prefix;     \
2422       indatalen -= sizeof b ## _prefix;                       \
2423     }                                                         
2424
2425   if (indatalen == 20)
2426     ;  /* Assume a plain SHA-1 or RMD160 digest has been given.  */
2427   else X(SHA1,   sha1,   20, 1)
2428   else X(RMD160, rmd160, 20, 1)
2429   else X(SHA224, sha224, 28, app->app_local->extcap.is_v2)
2430   else X(SHA256, sha256, 32, app->app_local->extcap.is_v2)
2431   else X(SHA384, sha384, 48, app->app_local->extcap.is_v2)
2432   else X(SHA512, sha512, 64, app->app_local->extcap.is_v2)
2433   else if ((indatalen == 28 || indatalen == 32 
2434             || indatalen == 48 || indatalen ==64)
2435            && app->app_local->extcap.is_v2)
2436     ;  /* Assume a plain SHA-3 digest has been given.  */
2437   else
2438     {
2439       log_error (_("card does not support digest algorithm %s\n"),
2440                  gcry_md_algo_name (hashalgo));
2441       /* Or the supplied digest length does not match an algorithm.  */
2442       return gpg_error (GPG_ERR_INV_VALUE);
2443     }
2444 #undef X
2445
2446   /* Check whether an OpenPGP card of any version has been requested. */
2447   if (!strcmp (keyidstr, "OPENPGP.1"))
2448     ;
2449   else if (!strcmp (keyidstr, "OPENPGP.3"))
2450     use_auth = 1;
2451   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2452     return gpg_error (GPG_ERR_INV_ID);
2453   else
2454     {
2455       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2456         ;
2457       if (n != 32)
2458         return gpg_error (GPG_ERR_INV_ID);
2459       else if (!*s)
2460         ; /* no fingerprint given: we allow this for now. */
2461       else if (*s == '/')
2462         fpr = s + 1; 
2463       else
2464         return gpg_error (GPG_ERR_INV_ID);
2465
2466       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2467         tmp_sn[n] = xtoi_2 (s);
2468
2469       if (app->serialnolen != 16)
2470         return gpg_error (GPG_ERR_INV_CARD);
2471       if (memcmp (app->serialno, tmp_sn, 16))
2472         return gpg_error (GPG_ERR_WRONG_CARD);
2473     }
2474
2475   /* If a fingerprint has been specified check it against the one on
2476      the card.  This is allows for a meaningful error message in case
2477      the key on the card has been replaced but the shadow information
2478      known to gpg was not updated.  If there is no fingerprint, gpg
2479      will detect a bogus signature anyway due to the
2480      verify-after-signing feature. */
2481   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2482   if (rc)
2483     return rc;
2484
2485   /* Concatenate prefix and digest.  */
2486 #define X(a,b,d) \
2487   if (hashalgo == GCRY_MD_ ## a && (d) )                      \
2488     {                                                         \
2489       datalen = sizeof b ## _prefix + indatalen;              \
2490       assert (datalen <= sizeof data);                        \
2491       memcpy (data, b ## _prefix, sizeof b ## _prefix);       \
2492       memcpy (data + sizeof b ## _prefix, indata, indatalen); \
2493     }                                                         
2494
2495   X(SHA1,   sha1,   1)
2496   else X(RMD160, rmd160, 1)
2497   else X(SHA224, sha224, app->app_local->extcap.is_v2)
2498   else X(SHA256, sha256, app->app_local->extcap.is_v2)
2499   else X(SHA384, sha384, app->app_local->extcap.is_v2)
2500   else X(SHA512, sha512, app->app_local->extcap.is_v2)
2501   else 
2502     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2503 #undef X
2504
2505   /* Redirect to the AUTH command if asked to. */
2506   if (use_auth)
2507     {
2508       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
2509                       data, datalen,
2510                       outdata, outdatalen);
2511     }
2512
2513   /* Show the number of signature done using this key.  */
2514   sigcount = get_sig_counter (app);
2515   log_info (_("signatures created so far: %lu\n"), sigcount);
2516
2517   /* Check CHV if needed.  */
2518   if (!app->did_chv1 || app->force_chv1 ) 
2519     {
2520       char *pinvalue;
2521
2522       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
2523       if (rc)
2524         return rc;
2525
2526       app->did_chv1 = 1;
2527
2528       /* For cards with versions < 2 we want to keep CHV1 and CHV2 in
2529          sync, thus we verify CHV2 here using the given PIN.  Cards
2530          with version2 to not have the need for a separate CHV2 and
2531          internally use just one.  Obviously we can't do that if the
2532          keypad has been used. */
2533       if (!app->did_chv2 && pinvalue && !app->app_local->extcap.is_v2)
2534         {
2535           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2536           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2537             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2538           if (rc)
2539             {
2540               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2541               xfree (pinvalue);
2542               flush_cache_after_error (app);
2543               return rc;
2544             }
2545           app->did_chv2 = 1;
2546         }
2547       xfree (pinvalue);
2548     }
2549
2550   rc = iso7816_compute_ds (app->slot, data, datalen, outdata, outdatalen);
2551   return rc;
2552 }
2553
2554 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2555    on INDATA which is expected to be the raw message digest. For this
2556    application the KEYIDSTR consists of the serialnumber and the
2557    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2558    be given.
2559
2560    Note that this function may return the error code
2561    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2562    not match the one required for the requested action (e.g. the
2563    serial number does not match). */
2564 static gpg_error_t 
2565 do_auth (app_t app, const char *keyidstr,
2566          gpg_error_t (*pincb)(void*, const char *, char **),
2567          void *pincb_arg,
2568          const void *indata, size_t indatalen,
2569          unsigned char **outdata, size_t *outdatalen )
2570 {
2571   int rc;
2572   unsigned char tmp_sn[20]; /* Actually 16 but we use it also for the fpr. */
2573   const char *s;
2574   int n;
2575   const char *fpr = NULL;
2576
2577   if (!keyidstr || !*keyidstr)
2578     return gpg_error (GPG_ERR_INV_VALUE);
2579   if (indatalen > 101) /* For a 2048 bit key. */
2580     return gpg_error (GPG_ERR_INV_VALUE);
2581
2582   /* Check whether an OpenPGP card of any version has been requested. */
2583   if (!strcmp (keyidstr, "OPENPGP.3"))
2584     ;
2585   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2586     return gpg_error (GPG_ERR_INV_ID);
2587   else
2588     {
2589       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2590         ;
2591       if (n != 32)
2592         return gpg_error (GPG_ERR_INV_ID);
2593       else if (!*s)
2594         ; /* no fingerprint given: we allow this for now. */
2595       else if (*s == '/')
2596         fpr = s + 1; 
2597       else
2598         return gpg_error (GPG_ERR_INV_ID);
2599
2600       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2601         tmp_sn[n] = xtoi_2 (s);
2602       
2603       if (app->serialnolen != 16)
2604         return gpg_error (GPG_ERR_INV_CARD);
2605       if (memcmp (app->serialno, tmp_sn, 16))
2606         return gpg_error (GPG_ERR_WRONG_CARD);
2607     }
2608
2609   /* If a fingerprint has been specified check it against the one on
2610      the card.  This is allows for a meaningful error message in case
2611      the key on the card has been replaced but the shadow information
2612      known to gpg was not updated.  If there is no fingerprint, gpg
2613      will detect a bogus signature anyway due to the
2614      verify-after-signing feature. */
2615   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2616   if (rc)
2617     return rc;
2618
2619   rc = verify_chv2 (app, pincb, pincb_arg);
2620   if (!rc)
2621     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2622                                         outdata, outdatalen);
2623   return rc;
2624 }
2625
2626
2627 static gpg_error_t 
2628 do_decipher (app_t app, const char *keyidstr,
2629              gpg_error_t (*pincb)(void*, const char *, char **),
2630              void *pincb_arg,
2631              const void *indata, size_t indatalen,
2632              unsigned char **outdata, size_t *outdatalen )
2633 {
2634   int rc;
2635   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2636   const char *s;
2637   int n;
2638   const char *fpr = NULL;
2639
2640   if (!keyidstr || !*keyidstr || !indatalen)
2641     return gpg_error (GPG_ERR_INV_VALUE);
2642
2643   /* Check whether an OpenPGP card of any version has been requested. */
2644   if (!strcmp (keyidstr, "OPENPGP.2"))
2645     ;
2646   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2647     return gpg_error (GPG_ERR_INV_ID);
2648   else
2649     {
2650       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2651         ;
2652       if (n != 32)
2653         return gpg_error (GPG_ERR_INV_ID);
2654       else if (!*s)
2655         ; /* no fingerprint given: we allow this for now. */
2656       else if (*s == '/')
2657         fpr = s + 1; 
2658       else
2659         return gpg_error (GPG_ERR_INV_ID);
2660       
2661       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2662         tmp_sn[n] = xtoi_2 (s);
2663       
2664       if (app->serialnolen != 16)
2665         return gpg_error (GPG_ERR_INV_CARD);
2666       if (memcmp (app->serialno, tmp_sn, 16))
2667         return gpg_error (GPG_ERR_WRONG_CARD);
2668     }
2669
2670   /* If a fingerprint has been specified check it against the one on
2671      the card.  This is allows for a meaningful error message in case
2672      the key on the card has been replaced but the shadow information
2673      known to gpg was not updated.  If there is no fingerprint, the
2674      decryption will won't produce the right plaintext anyway. */
2675   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
2676   if (rc)
2677     return rc;
2678
2679   rc = verify_chv2 (app, pincb, pincb_arg);
2680   if (!rc)
2681     {
2682       size_t fixuplen;
2683
2684       /* We might encounter a couple of leading zeroes in the
2685          cryptogram.  Due to internal use of MPIs thease leading
2686          zeroes are stripped.  However the OpenPGP card expects
2687          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
2688          need to fix it up.  We do this for up to 16 leading zero
2689          bytes; a cryptogram with more than this is with a very high
2690          probability anyway broken.  */
2691       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
2692         fixuplen = 128 - indatalen;
2693       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
2694         fixuplen = 256 - indatalen;
2695       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
2696         fixuplen = 192 - indatalen;
2697       else
2698         fixuplen = 0;
2699       if (fixuplen)
2700         {
2701           unsigned char *fixbuf;
2702
2703           /* While we have to prepend stuff anyway, we can also
2704              include the padding byte here so that iso1816_decipher
2705              does not need to do yet another data mangling.  */
2706           fixuplen++;
2707           fixbuf = xtrymalloc (fixuplen + indatalen);
2708           if (!fixbuf)
2709             rc = gpg_error_from_syserror ();
2710           else
2711             {
2712               memset (fixbuf, 0, fixuplen);
2713               memcpy (fixbuf+fixuplen, indata, indatalen);
2714               rc = iso7816_decipher (app->slot, fixbuf, fixuplen+indatalen, -1,
2715                                      outdata, outdatalen);
2716               xfree (fixbuf);
2717             }
2718
2719         }
2720       else
2721         rc = iso7816_decipher (app->slot, indata, indatalen, 0,
2722                                outdata, outdatalen);
2723     }
2724   return rc;
2725 }
2726
2727
2728 /* Perform a simple verify operation for CHV1 and CHV2, so that
2729    further operations won't ask for CHV2 and it is possible to do a
2730    cheap check on the PIN: If there is something wrong with the PIN
2731    entry system, only the regular CHV will get blocked and not the
2732    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
2733    optional fingerprint part will be ignored.
2734
2735    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
2736    the "[CHV3]" being a literal string:  The Admin Pin is checked if
2737    and only if the retry counter is still at 3. */
2738 static gpg_error_t 
2739 do_check_pin (app_t app, const char *keyidstr,
2740               gpg_error_t (*pincb)(void*, const char *, char **),
2741               void *pincb_arg)
2742 {
2743   unsigned char tmp_sn[20]; 
2744   const char *s;
2745   int n;
2746   int admin_pin = 0;
2747
2748   if (!keyidstr || !*keyidstr)
2749     return gpg_error (GPG_ERR_INV_VALUE);
2750
2751   /* Check whether an OpenPGP card of any version has been requested. */
2752   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2753     return gpg_error (GPG_ERR_INV_ID);
2754   
2755   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2756     ;
2757   if (n != 32)
2758     return gpg_error (GPG_ERR_INV_ID);
2759   else if (!*s)
2760     ; /* No fingerprint given: we allow this for now. */
2761   else if (*s == '/')
2762     ; /* We ignore a fingerprint. */
2763   else if (!strcmp (s, "[CHV3]") )
2764     admin_pin = 1;
2765   else
2766     return gpg_error (GPG_ERR_INV_ID);
2767
2768   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2769     tmp_sn[n] = xtoi_2 (s);
2770
2771   if (app->serialnolen != 16)
2772     return gpg_error (GPG_ERR_INV_CARD);
2773   if (memcmp (app->serialno, tmp_sn, 16))
2774     return gpg_error (GPG_ERR_WRONG_CARD);
2775
2776   /* Yes, there is a race conditions: The user might pull the card
2777      right here and we won't notice that.  However this is not a
2778      problem and the check above is merely for a graceful failure
2779      between operations. */
2780
2781   if (admin_pin)
2782     {
2783       void *relptr;
2784       unsigned char *value;
2785       size_t valuelen;
2786       int count;
2787       
2788       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2789       if (!relptr || valuelen < 7)
2790         {
2791           log_error (_("error retrieving CHV status from card\n"));
2792           xfree (relptr);
2793           return gpg_error (GPG_ERR_CARD);
2794         }
2795       count = value[6];
2796       xfree (relptr);
2797
2798       if (!count)
2799         {
2800           log_info (_("card is permanently locked!\n"));
2801           return gpg_error (GPG_ERR_BAD_PIN);
2802         }
2803       else if (value[6] < 3)
2804         {
2805           log_info (_("verification of Admin PIN is currently prohibited "
2806                       "through this command\n"));
2807           return gpg_error (GPG_ERR_GENERAL);
2808         }
2809
2810       app->did_chv3 = 0; /* Force verification.  */
2811       return verify_chv3 (app, pincb, pincb_arg);
2812     }
2813   else
2814     return verify_chv2 (app, pincb, pincb_arg);
2815 }
2816
2817
2818 /* Show information about card capabilities.  */
2819 static void
2820 show_caps (struct app_local_s *s)
2821 {
2822   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
2823   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
2824   if (s->extcap.get_challenge)
2825     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
2826   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
2827   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
2828   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
2829   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
2830   if (s->extcap.sm_supported)
2831     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
2832   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
2833   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
2834   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
2835   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
2836   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
2837   log_info ("Status Indicator: %02X\n", s->status_indicator);
2838
2839   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
2840   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
2841 }
2842
2843
2844 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
2845    APPLOC.  */
2846 static void
2847 parse_historical (struct app_local_s *apploc, 
2848                   const unsigned char * buffer, size_t buflen)
2849 {
2850   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
2851   if (buflen < 4)
2852     {
2853       log_error ("warning: historical bytes are too short\n");
2854       return; /* Too short.  */
2855     }
2856   if (*buffer)
2857     {
2858       log_error ("warning: bad category indicator in historical bytes\n");
2859       return; 
2860     }
2861   
2862   /* Skip category indicator.  */
2863   buffer++;
2864   buflen--;
2865
2866   /* Get the status indicator.  */
2867   apploc->status_indicator = buffer[buflen-3];
2868   buflen -= 3;
2869
2870   /* Parse the compact TLV.  */
2871   while (buflen)
2872     {
2873       unsigned int tag = (*buffer & 0xf0) >> 4;
2874       unsigned int len = (*buffer & 0x0f);
2875       if (len+1 > buflen)
2876         {
2877           log_error ("warning: bad Compact-TLV in historical bytes\n");
2878           return; /* Error.  */
2879         }
2880       buffer++;
2881       buflen--;
2882       if (tag == 7 && len == 3)
2883         {
2884           /* Card capabilities.  */
2885           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
2886           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
2887         }
2888       buffer += len;
2889       buflen -= len;
2890     }
2891 }
2892
2893
2894 /* Read and parse the algorithm attributes for KEYNO.  KEYNO must be
2895    in the range 0..2.  */
2896 static void 
2897 parse_algorithm_attribute (app_t app, int keyno)
2898
2899   unsigned char *buffer;
2900   size_t buflen;
2901   void *relptr;
2902   const char const desc[3][5] = {"sign", "encr", "auth"};
2903
2904   assert (keyno >=0 && keyno <= 2);
2905
2906   relptr = get_one_do (app, 0xC1+keyno, &buffer, &buflen, NULL);
2907   if (!relptr)
2908     {
2909       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
2910       return;
2911     }
2912   if (buflen < 1)
2913     {
2914       log_error ("error reading DO 0x%02X\n", 0xc1+keyno);
2915       xfree (relptr);
2916       return;
2917     }
2918
2919   log_info ("Key-Attr-%s ..: ", desc[keyno]);
2920   if (*buffer == 1 && (buflen == 5 || buflen == 6))
2921     {
2922       log_printf ("RSA, n=%d, e=%d",
2923                   (buffer[1]<<8 | buffer[2]),
2924                   (buffer[3]<<8 | buffer[4]));
2925       if (buflen == 6)
2926         log_printf (", format=%s",
2927                     buffer[5] == 0? "std" :
2928                     buffer[5] == 1? "std+n" :
2929                     buffer[5] == 2? "crt" :
2930                     buffer[5] == 2? "crt+n" : "?");
2931       log_printf ("\n");
2932     }
2933   else
2934     log_printhex ("", buffer, buflen);
2935
2936   xfree (relptr);
2937 }
2938
2939 /* Select the OpenPGP application on the card in SLOT.  This function
2940    must be used before any other OpenPGP application functions. */
2941 gpg_error_t
2942 app_select_openpgp (app_t app)
2943 {
2944   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
2945   int slot = app->slot;
2946   int rc;
2947   unsigned char *buffer;
2948   size_t buflen;
2949   void *relptr;
2950   
2951   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
2952      special flag value. */
2953   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
2954   if (!rc)
2955     {
2956       unsigned int manufacturer;
2957
2958       app->apptype = "OPENPGP";
2959
2960       app->did_chv1 = 0;
2961       app->did_chv2 = 0;
2962       app->did_chv3 = 0;
2963       app->app_local = NULL;
2964
2965       /* The OpenPGP card returns the serial number as part of the
2966          AID; because we prefer to use OpenPGP serial numbers, we
2967          replace a possibly already set one from a EF.GDO with this
2968          one.  Note, that for current OpenPGP cards, no EF.GDO exists
2969          and thus it won't matter at all. */
2970       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
2971       if (rc)
2972         goto leave;
2973       if (opt.verbose)
2974         {
2975           log_info ("AID: ");
2976           log_printhex ("", buffer, buflen);
2977         }
2978
2979       app->card_version = buffer[6] << 8;
2980       app->card_version |= buffer[7];
2981       manufacturer = (buffer[8]<<8 | buffer[9]);
2982
2983       xfree (app->serialno);
2984       app->serialno = buffer;
2985       app->serialnolen = buflen;
2986       buffer = NULL;
2987       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2988       if (!app->app_local)
2989         {
2990           rc = gpg_error (gpg_err_code_from_errno (errno));
2991           goto leave;
2992         }
2993
2994       if (app->card_version >= 0x0200)
2995         app->app_local->extcap.is_v2 = 1;
2996
2997
2998       /* Read the historical bytes.  */
2999       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
3000       if (relptr)
3001         {
3002           if (opt.verbose)
3003             {
3004               log_info ("Historical Bytes: ");
3005               log_printhex ("", buffer, buflen);
3006             }
3007           parse_historical (app->app_local, buffer, buflen);
3008           xfree (relptr);
3009         }
3010
3011       /* Read the force-chv1 flag.  */
3012       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
3013       if (!relptr)
3014         {
3015           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3016                      "CHV Status Bytes");
3017           goto leave;
3018         }
3019       app->force_chv1 = (buflen && *buffer == 0);
3020       xfree (relptr);
3021
3022       /* Read the extended capabilities.  */
3023       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
3024       if (!relptr)
3025         {
3026           log_error (_("can't access %s - invalid OpenPGP card?\n"),
3027                      "Extended Capability Flags" );
3028           goto leave;
3029         }
3030       if (buflen)
3031         {
3032           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
3033           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
3034           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
3035           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
3036           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
3037         }
3038       if (buflen >= 10)
3039         {
3040           /* Available with v2 cards.  */
3041           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
3042           app->app_local->extcap.max_get_challenge 
3043                                                = (buffer[2] << 8 | buffer[3]);
3044           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
3045           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
3046           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
3047         }
3048       xfree (relptr);
3049
3050       /* Some of the first cards accidently don't set the
3051          CHANGE_FORCE_CHV bit but allow it anyway. */
3052       if (app->card_version <= 0x0100 && manufacturer == 1)
3053         app->app_local->extcap.change_force_chv = 1;
3054
3055       parse_login_data (app);
3056
3057       if (opt.verbose)
3058         show_caps (app->app_local);
3059
3060       if (opt.verbose)
3061         {
3062           parse_algorithm_attribute (app, 0);
3063           parse_algorithm_attribute (app, 1);
3064           parse_algorithm_attribute (app, 2);
3065         }
3066       
3067       if (opt.verbose > 1)
3068         dump_all_do (slot);
3069
3070       app->fnc.deinit = do_deinit;
3071       app->fnc.learn_status = do_learn_status;
3072       app->fnc.readcert = do_readcert;
3073       app->fnc.readkey = do_readkey;
3074       app->fnc.getattr = do_getattr;
3075       app->fnc.setattr = do_setattr;
3076       app->fnc.writecert = do_writecert;
3077       app->fnc.writekey = do_writekey;
3078       app->fnc.genkey = do_genkey;
3079       app->fnc.sign = do_sign;
3080       app->fnc.auth = do_auth;
3081       app->fnc.decipher = do_decipher;
3082       app->fnc.change_pin = do_change_pin;
3083       app->fnc.check_pin = do_check_pin;
3084    }
3085
3086 leave:
3087   if (rc)
3088     do_deinit (app);
3089   return rc;
3090 }
3091
3092
3093