Support the Certifciate DO of the v2 OpenPGP cards.
[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      corresponsing 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   return 0;
1253 }
1254
1255
1256 /* Handle the READKEY command for OpenPGP.  On success a canonical
1257    encoded S-expression with the public key will get stored at PK and
1258    its length (for assertions) at PKLEN; the caller must release that
1259    buffer. On error PK and PKLEN are not changed and an error code is
1260    returned.  */
1261 static gpg_error_t
1262 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1263 {
1264 #if GNUPG_MAJOR_VERSION > 1
1265   gpg_error_t err;
1266   int keyno;
1267   unsigned char *buf;
1268
1269   if (!strcmp (keyid, "OPENPGP.1"))
1270     keyno = 1;
1271   else if (!strcmp (keyid, "OPENPGP.2"))
1272     keyno = 2;
1273   else if (!strcmp (keyid, "OPENPGP.3"))
1274     keyno = 3;
1275   else
1276     return gpg_error (GPG_ERR_INV_ID);
1277
1278   err = get_public_key (app, keyno);
1279   if (err)
1280     return err;
1281
1282   buf = app->app_local->pk[keyno-1].key;
1283   if (!buf)
1284     return gpg_error (GPG_ERR_NO_PUBKEY);
1285   *pklen = app->app_local->pk[keyno-1].keylen;;
1286   *pk = xtrymalloc (*pklen);
1287   if (!*pk)
1288     {
1289       err = gpg_error_from_syserror ();
1290       *pklen = 0;
1291       return err;
1292     }
1293   memcpy (*pk, buf, *pklen);
1294   return 0;
1295 #else
1296   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1297 #endif
1298 }
1299
1300 /* Read the standard certificate of an OpenPGP v2 card.  It is
1301    returned in a freshly allocated buffer with that address stored at
1302    CERT and the length of the certificate stored at CERTLEN.  CERTID
1303    needs to be set to "OPENPGP.3".  */
1304 static gpg_error_t
1305 do_readcert (app_t app, const char *certid,
1306              unsigned char **cert, size_t *certlen)
1307 {
1308 #if GNUPG_MAJOR_VERSION > 1
1309   gpg_error_t err;
1310   unsigned char *buffer;
1311   size_t buflen;
1312   void *relptr;
1313
1314   *cert = NULL;
1315   *certlen = 0;
1316   if (strcmp (certid, "OPENPGP.3"))
1317     return gpg_error (GPG_ERR_INV_ID);
1318   if (!app->app_local->extcap.is_v2)
1319     return gpg_error (GPG_ERR_NOT_FOUND);
1320
1321   relptr = get_one_do (app, 0x7F21, &buffer, &buflen, NULL);
1322   if (!relptr)
1323     return gpg_error (GPG_ERR_NOT_FOUND);
1324
1325   *cert = xtrymalloc (buflen);
1326   if (!*cert)
1327     err = gpg_error_from_syserror ();
1328   else
1329     {
1330       memcpy (*cert, buffer, buflen);
1331       *certlen = buflen;
1332       err  = 0;
1333     }
1334   xfree (relptr);
1335   return err;
1336 #else
1337   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1338 #endif
1339 }
1340
1341
1342 /* Verify a CHV either using using the pinentry or if possibile by
1343    using a keypad.  PINCB and PINCB_ARG describe the usual callback
1344    for the pinentry.  CHVNO must be either 1 or 2. SIGCOUNT is only
1345    used with CHV1.  PINVALUE is the address of a pointer which will
1346    receive a newly allocated block with the actual PIN (this is useful
1347    in case that PIN shall be used for another verifiy operation).  The
1348    caller needs to free this value.  If the function returns with
1349    success and NULL is stored at PINVALUE, the caller should take this
1350    as an indication that the keypad has been used.
1351    */
1352 static gpg_error_t
1353 verify_a_chv (app_t app,
1354               gpg_error_t (*pincb)(void*, const char *, char **),
1355               void *pincb_arg,
1356               int chvno, unsigned long sigcount, char **pinvalue)
1357 {
1358   int rc = 0;
1359   char *prompt;
1360   iso7816_pininfo_t pininfo;
1361   int minlen = 6;
1362
1363   assert (chvno == 1 || chvno == 2);
1364
1365   *pinvalue = NULL;
1366
1367   if (chvno == 2 && app->app_local->flags.def_chv2)
1368     {
1369       /* Special case for def_chv2 mechanism. */
1370       if (opt.verbose)
1371         log_info (_("using default PIN as %s\n"), "CHV2");
1372       rc = iso7816_verify (app->slot, 0x82, "123456", 6);
1373       if (rc)
1374         {
1375           /* Verification of CHV2 with the default PIN failed,
1376              although the card pretends to have the default PIN set as
1377              CHV2.  We better disable the def_chv2 flag now. */
1378           log_info (_("failed to use default PIN as %s: %s"
1379                       " - disabling further default use\n"),
1380                     "CHV2", gpg_strerror (rc));
1381           app->app_local->flags.def_chv2 = 0;
1382         }
1383       return rc;
1384     }
1385
1386   memset (&pininfo, 0, sizeof pininfo);
1387   pininfo.mode = 1;
1388   pininfo.minlen = minlen;
1389   
1390   if (!opt.disable_keypad
1391       && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1392     {
1393       /* The reader supports the verify command through the keypad. */
1394
1395       if (chvno == 1)
1396         {
1397 #define PROMPTSTRING  _("||Please enter your PIN at the reader's keypad%%0A" \
1398                         "[sigs done: %lu]")
1399           size_t promptsize = strlen (PROMPTSTRING) + 50;
1400
1401           prompt = xmalloc (promptsize);
1402           if (!prompt)
1403             return gpg_error_from_syserror ();
1404           snprintf (prompt, promptsize-1, PROMPTSTRING, sigcount);
1405           rc = pincb (pincb_arg, prompt, NULL); 
1406           xfree (prompt);
1407 #undef PROMPTSTRING
1408         }
1409       else
1410         rc = pincb (pincb_arg,
1411                     _("||Please enter your PIN at the reader's keypad"),
1412                     NULL);
1413       if (rc)
1414         {
1415           log_info (_("PIN callback returned error: %s\n"),
1416                     gpg_strerror (rc));
1417           return rc;
1418         }
1419       rc = iso7816_verify_kp (app->slot, 0x80+chvno, "", 0, &pininfo); 
1420       /* Dismiss the prompt. */
1421       pincb (pincb_arg, NULL, NULL);
1422
1423       assert (!*pinvalue);
1424     }
1425   else
1426     {
1427       /* The reader has no keypad or we don't want to use it. */
1428
1429       if (chvno == 1)
1430         {
1431 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
1432           size_t promptsize = strlen (PROMPTSTRING) + 50;
1433
1434           prompt = xtrymalloc (promptsize);
1435           if (!prompt)
1436             return gpg_error_from_syserror ();
1437           snprintf (prompt, promptsize-1, PROMPTSTRING, sigcount);
1438           rc = pincb (pincb_arg, prompt, pinvalue); 
1439           xfree (prompt);
1440 #undef PROMPTSTRING
1441         }
1442       else
1443         rc = pincb (pincb_arg, _("||Please enter the PIN"), pinvalue); 
1444
1445       if (rc)
1446         {
1447           log_info (_("PIN callback returned error: %s\n"),
1448                     gpg_strerror (rc));
1449           return rc;
1450         }
1451       
1452       if (strlen (*pinvalue) < minlen)
1453         {
1454           log_error (_("PIN for CHV%d is too short;"
1455                        " minimum length is %d\n"), chvno, minlen);
1456           xfree (*pinvalue);
1457           *pinvalue = NULL;
1458           return gpg_error (GPG_ERR_BAD_PIN);
1459         }
1460
1461       rc = iso7816_verify (app->slot, 0x80+chvno,
1462                            *pinvalue, strlen (*pinvalue));
1463     }
1464   
1465   if (rc)
1466     {
1467       log_error (_("verify CHV%d failed: %s\n"), chvno, gpg_strerror (rc));
1468       xfree (*pinvalue);
1469       *pinvalue = NULL;
1470       flush_cache_after_error (app);
1471     }
1472
1473   return rc;
1474 }
1475
1476
1477 /* Verify CHV2 if required.  Depending on the configuration of the
1478    card CHV1 will also be verified. */
1479 static gpg_error_t
1480 verify_chv2 (app_t app,
1481              gpg_error_t (*pincb)(void*, const char *, char **),
1482              void *pincb_arg)
1483 {
1484   int rc;
1485   char *pinvalue;
1486
1487   if (app->did_chv2) 
1488     return 0;  /* We already verified CHV2.  */
1489
1490   rc = verify_a_chv (app, pincb, pincb_arg, 2, 0, &pinvalue);
1491   if (rc)
1492     return rc;
1493
1494   app->did_chv2 = 1;
1495   
1496   if (!app->did_chv1 && !app->force_chv1 && pinvalue)
1497     {
1498       /* For convenience we verify CHV1 here too.  We do this only if
1499          the card is not configured to require a verification before
1500          each CHV1 controlled operation (force_chv1) and if we are not
1501          using the keypad (PINVALUE == NULL). */
1502       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1503       if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1504         rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1505       if (rc)
1506         {
1507           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1508           flush_cache_after_error (app);
1509         }
1510       else
1511         app->did_chv1 = 1;
1512     }
1513   xfree (pinvalue);
1514
1515   return rc;
1516 }
1517
1518
1519 /* Verify CHV3 if required. */
1520 static gpg_error_t
1521 verify_chv3 (app_t app,
1522              gpg_error_t (*pincb)(void*, const char *, char **),
1523              void *pincb_arg)
1524 {
1525   int rc = 0;
1526
1527 #if GNUPG_MAJOR_VERSION != 1
1528   if (!opt.allow_admin)
1529     {
1530       log_info (_("access to admin commands is not configured\n"));
1531       return gpg_error (GPG_ERR_EACCES);
1532     }
1533 #endif
1534       
1535   if (!app->did_chv3) 
1536     {
1537       void *relptr;
1538       unsigned char *value;
1539       size_t valuelen;
1540       iso7816_pininfo_t pininfo;
1541       int minlen = 8;
1542       int remaining;
1543
1544       memset (&pininfo, 0, sizeof pininfo);
1545       pininfo.mode = 1;
1546       pininfo.minlen = minlen;
1547
1548       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1549       if (!relptr || valuelen < 7)
1550         {
1551           log_error (_("error retrieving CHV status from card\n"));
1552           xfree (relptr);
1553           return gpg_error (GPG_ERR_CARD);
1554         }
1555       if (value[6] == 0)
1556         {
1557           log_info (_("card is permanently locked!\n"));
1558           xfree (relptr);
1559           return gpg_error (GPG_ERR_BAD_PIN);
1560         }
1561       remaining = value[6];
1562       xfree (relptr);
1563
1564       log_info(_("%d Admin PIN attempts remaining before card"
1565                  " is permanently locked\n"), remaining);
1566
1567       if (!opt.disable_keypad
1568           && !iso7816_check_keypad (app->slot, ISO7816_VERIFY, &pininfo) )
1569         {
1570           /* The reader supports the verify command through the keypad. */
1571           
1572           if (remaining < 3)
1573             {
1574 #define PROMPTSTRING  _("|A|Please enter the Admin PIN" \
1575                         " at the reader's keypad%%0A"   \
1576                         "[remaining attempts: %d]")
1577               size_t promptsize = strlen (PROMPTSTRING) + 50;
1578               char *prompt;
1579               
1580               prompt = xmalloc (promptsize);
1581               if (!prompt)
1582                 return gpg_error_from_syserror ();
1583               snprintf (prompt, promptsize-1, PROMPTSTRING, remaining);
1584               rc = pincb (pincb_arg, prompt, NULL); 
1585               xfree (prompt);
1586 #undef PROMPTSTRING
1587             }
1588           else
1589             rc = pincb (pincb_arg, _("|A|Please enter the Admin PIN"
1590                                      " at the reader's keypad"),   NULL);
1591
1592           if (rc)
1593             {
1594               log_info (_("PIN callback returned error: %s\n"),
1595                         gpg_strerror (rc));
1596               return rc;
1597             }
1598           rc = iso7816_verify_kp (app->slot, 0x83, "", 0, &pininfo); 
1599           /* Dismiss the prompt. */
1600           pincb (pincb_arg, NULL, NULL);
1601         }
1602       else
1603         {
1604           char *pinvalue;
1605
1606           /* TRANSLATORS: Do not translate the "|A|" prefix but keep
1607              it at the start of the string.  We need this elsewhere to
1608              get some infos on the string. */
1609           rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1610           if (rc)
1611             {
1612               log_info (_("PIN callback returned error: %s\n"),
1613                         gpg_strerror (rc));
1614               return rc;
1615             }
1616           
1617           if (strlen (pinvalue) < minlen)
1618             {
1619               log_error (_("PIN for CHV%d is too short;"
1620                            " minimum length is %d\n"), 3, minlen);
1621               xfree (pinvalue);
1622               return gpg_error (GPG_ERR_BAD_PIN);
1623             }
1624           
1625           rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1626           xfree (pinvalue);
1627         }
1628       
1629       if (rc)
1630         {
1631           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1632           flush_cache_after_error (app);
1633           return rc;
1634         }
1635     }
1636   return rc;
1637 }
1638
1639
1640 /* Handle the SETATTR operation. All arguments are already basically
1641    checked. */
1642 static gpg_error_t 
1643 do_setattr (app_t app, const char *name,
1644             gpg_error_t (*pincb)(void*, const char *, char **),
1645             void *pincb_arg,
1646             const unsigned char *value, size_t valuelen)
1647 {
1648   gpg_error_t rc;
1649   int idx;
1650   static struct {
1651     const char *name;
1652     int tag;
1653     int need_chv;
1654     int special;
1655     unsigned int need_v2:1;
1656   } table[] = {
1657     { "DISP-NAME",    0x005B, 3 },
1658     { "LOGIN-DATA",   0x005E, 3, 2 },
1659     { "DISP-LANG",    0x5F2D, 3 },
1660     { "DISP-SEX",     0x5F35, 3 },
1661     { "PUBKEY-URL",   0x5F50, 3 },
1662     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1663     { "CA-FPR-1",     0x00CA, 3 },
1664     { "CA-FPR-2",     0x00CB, 3 },
1665     { "CA-FPR-3",     0x00CC, 3 },
1666     { "PRIVATE-DO-1", 0x0101, 2 },
1667     { "PRIVATE-DO-2", 0x0102, 3 },
1668     { "PRIVATE-DO-3", 0x0103, 2 },
1669     { "PRIVATE-DO-4", 0x0104, 3 },
1670     { "CERT-3",       0x7F21, 3, 0, 1 },
1671     { "SM-KEY-ENC",   0x00D1, 3, 0, 1 },
1672     { "SM-KEY-MAC",   0x00D2, 3, 0, 1 },
1673     { "PW-RESET-CODE",0x00D3, 3, 0, 1 },
1674     { NULL, 0 }
1675   };
1676   int exmode;
1677
1678   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1679     ;
1680   if (!table[idx].name)
1681     return gpg_error (GPG_ERR_INV_NAME); 
1682   if (table[idx].need_v2 && !app->app_local->extcap.is_v2)
1683     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Not yet supported.  */
1684
1685   switch (table[idx].need_chv)
1686     {
1687     case 2:
1688       rc = verify_chv2 (app, pincb, pincb_arg);
1689       break;
1690     case 3:
1691       rc = verify_chv3 (app, pincb, pincb_arg);
1692       break;
1693     default:
1694       rc = 0;
1695     }
1696   if (rc)
1697     return rc;
1698
1699   /* Flush the cache before writing it, so that the next get operation
1700      will reread the data from the card and thus get synced in case of
1701      errors (e.g. data truncated by the card). */
1702   flush_cache_item (app, table[idx].tag);
1703   /* For command chaining we use a value of 254 for this card.  */
1704   if (app->app_local->cardcap.cmd_chaining && valuelen > 254)
1705     exmode = -254;
1706   else
1707     exmode = 0;
1708   rc = iso7816_put_data (app->slot, exmode, table[idx].tag, value, valuelen);
1709   if (rc)
1710     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1711
1712   if (table[idx].special == 1)
1713     app->force_chv1 = (valuelen && *value == 0);
1714   else if (table[idx].special == 2)
1715     parse_login_data (app);
1716
1717   return rc;
1718 }
1719
1720
1721 /* Handle the WRITECERT command for OpenPGP.  This rites the standard
1722    certifciate to the card; CERTID needs to be set to "OPENPGP.3".
1723    PINCB and PINCB_ARG are the usual arguments for the pinentry
1724    callback.  */
1725 static gpg_error_t
1726 do_writecert (app_t app, ctrl_t ctrl,
1727               const char *certidstr, 
1728               gpg_error_t (*pincb)(void*, const char *, char **),
1729               void *pincb_arg,
1730               const unsigned char *certdata, size_t certdatalen)
1731 {
1732 #if GNUPG_MAJOR_VERSION > 1
1733   if (strcmp (certidstr, "OPENPGP.3"))
1734     return gpg_error (GPG_ERR_INV_ID);
1735   if (!certdata || !certdatalen)
1736     return gpg_error (GPG_ERR_INV_ARG);
1737   if (!app->app_local->extcap.is_v2)
1738     return gpg_error (GPG_ERR_NOT_SUPPORTED);
1739   if (certdatalen > app->app_local->extcap.max_certlen_3)
1740     return gpg_error (GPG_ERR_TOO_LARGE);
1741   return do_setattr (app, "CERT-3", pincb, pincb_arg, certdata, certdatalen);
1742 #else
1743   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1744 #endif
1745 }
1746
1747
1748
1749 /* Handle the PASSWD command. */
1750 static gpg_error_t 
1751 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, 
1752                unsigned int flags,
1753                gpg_error_t (*pincb)(void*, const char *, char **),
1754                void *pincb_arg)
1755 {
1756   int rc = 0;
1757   int chvno = atoi (chvnostr);
1758   char *pinvalue;
1759   int reset_mode = !!(flags & APP_CHANGE_FLAG_RESET);
1760
1761   if (reset_mode && chvno == 3)
1762     {
1763       rc = gpg_error (GPG_ERR_INV_ID);
1764       goto leave;
1765     }
1766   else if (reset_mode || chvno == 3)
1767     {
1768       /* we always require that the PIN is entered. */
1769       app->did_chv3 = 0;
1770       rc = verify_chv3 (app, pincb, pincb_arg);
1771       if (rc)
1772         goto leave;
1773     }
1774   else if (chvno == 1 || chvno == 2)
1775     {
1776       /* CHV1 and CVH2 should always have the same value, thus we
1777          enforce it here.  */
1778       int save_force = app->force_chv1;
1779
1780       app->force_chv1 = 0;
1781       app->did_chv1 = 0;
1782       app->did_chv2 = 0;
1783       rc = verify_chv2 (app, pincb, pincb_arg);
1784       app->force_chv1 = save_force;
1785       if (rc)
1786         goto leave;
1787     }
1788   else
1789     {
1790       rc = gpg_error (GPG_ERR_INV_ID);
1791       goto leave;
1792     }
1793
1794   if (chvno == 3)
1795     app->did_chv3 = 0;
1796   else
1797     app->did_chv1 = app->did_chv2 = 0;
1798
1799   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1800      keep it at the start of the string.  We need this elsewhere
1801      to get some infos on the string. */
1802   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1803               &pinvalue); 
1804   if (rc)
1805     {
1806       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1807       goto leave;
1808     }
1809
1810   if (reset_mode)
1811     {
1812       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1813                                         pinvalue, strlen (pinvalue));
1814       if (!rc)
1815         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1816                                           pinvalue, strlen (pinvalue));
1817     }
1818   else
1819     {
1820       if (chvno == 1 || chvno == 2)
1821         {
1822           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1823                                               pinvalue, strlen (pinvalue));
1824           if (!rc)
1825             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1826                                                 pinvalue, strlen (pinvalue));
1827         }
1828       else
1829         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1830                                             pinvalue, strlen (pinvalue));
1831     }
1832   xfree (pinvalue);
1833   if (rc)
1834     flush_cache_after_error (app);
1835
1836  leave:
1837   return rc;
1838 }
1839
1840
1841 /* Check whether a key already exists.  KEYIDX is the index of the key
1842    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1843    error returned if the key already exists. */
1844 static gpg_error_t
1845 does_key_exist (app_t app, int keyidx, int force)
1846 {
1847   const unsigned char *fpr;
1848   unsigned char *buffer;
1849   size_t buflen, n;
1850   int i;
1851
1852   assert (keyidx >=0 && keyidx <= 2);
1853
1854   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1855     {
1856       log_error (_("error reading application data\n"));
1857       return gpg_error (GPG_ERR_GENERAL);
1858     }
1859   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1860   if (!fpr || n < 60)
1861     {
1862       log_error (_("error reading fingerprint DO\n"));
1863       xfree (buffer);
1864       return gpg_error (GPG_ERR_GENERAL);
1865     }
1866   fpr += 20*keyidx;
1867   for (i=0; i < 20 && !fpr[i]; i++)
1868     ;
1869   xfree (buffer);
1870   if (i!=20 && !force)
1871     {
1872       log_error (_("key already exists\n"));
1873       return gpg_error (GPG_ERR_EEXIST);
1874     }
1875   else if (i!=20)
1876     log_info (_("existing key will be replaced\n"));
1877   else
1878     log_info (_("generating new key\n"));
1879   return 0;
1880 }
1881
1882
1883
1884 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
1885    canonical encoded S-expression with the secret key in KEYDATA and
1886    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
1887    usual keyid which for OpenPGP is the string "OPENPGP.n" with
1888    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
1889    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
1890    the pinentry callback.  */
1891 static gpg_error_t
1892 do_writekey (app_t app, ctrl_t ctrl,
1893              const char *keyid, unsigned int flags,
1894              gpg_error_t (*pincb)(void*, const char *, char **),
1895              void *pincb_arg,
1896              const unsigned char *keydata, size_t keydatalen)
1897 {
1898   gpg_error_t err;
1899   int force = (flags & 1);
1900   int keyno;
1901   const unsigned char *buf, *tok;
1902   size_t buflen, toklen;
1903   int depth, last_depth1, last_depth2;
1904   const unsigned char *rsa_n = NULL;
1905   const unsigned char *rsa_e = NULL;
1906   const unsigned char *rsa_p = NULL;
1907   const unsigned char *rsa_q = NULL;
1908   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
1909   unsigned int nbits;
1910   unsigned char *template = NULL;
1911   unsigned char *tp;
1912   size_t template_len;
1913   unsigned char fprbuf[20];
1914   u32 created_at = 0;
1915
1916   if (!strcmp (keyid, "OPENPGP.1"))
1917     keyno = 0;
1918   else if (!strcmp (keyid, "OPENPGP.2"))
1919     keyno = 1;
1920   else if (!strcmp (keyid, "OPENPGP.3"))
1921     keyno = 2;
1922   else
1923     return gpg_error (GPG_ERR_INV_ID);
1924   
1925   err = does_key_exist (app, keyno, force);
1926   if (err)
1927     return err;
1928
1929
1930   /* 
1931      Parse the S-expression
1932    */
1933   buf = keydata;
1934   buflen = keydatalen;
1935   depth = 0;
1936   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1937     goto leave;
1938   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1939     goto leave;
1940   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
1941     {
1942       if (!tok)
1943         ;
1944       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
1945         log_info ("protected-private-key passed to writekey\n");
1946       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
1947         log_info ("shadowed-private-key passed to writekey\n");
1948       err = gpg_error (GPG_ERR_BAD_SECKEY);
1949       goto leave;
1950     }
1951   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1952     goto leave;
1953   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1954     goto leave;
1955   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
1956     {
1957       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
1958       goto leave;
1959     }
1960   last_depth1 = depth;
1961   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1962          && depth && depth >= last_depth1)
1963     {
1964       if (tok)
1965         {
1966           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1967           goto leave;
1968         }
1969       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1970         goto leave;
1971       if (tok && toklen == 1)
1972         {
1973           const unsigned char **mpi;
1974           size_t *mpi_len;
1975
1976           switch (*tok)
1977             {
1978             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
1979             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
1980             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
1981             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
1982             default: mpi = NULL;  mpi_len = NULL; break;
1983             }
1984           if (mpi && *mpi)
1985             {
1986               err = gpg_error (GPG_ERR_DUP_VALUE);
1987               goto leave;
1988             }
1989           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1990             goto leave;
1991           if (tok && mpi)
1992             {
1993               /* Strip off leading zero bytes and save. */
1994               for (;toklen && !*tok; toklen--, tok++)
1995                 ;
1996               *mpi = tok;
1997               *mpi_len = toklen;
1998             }
1999         }
2000       /* Skip until end of list. */
2001       last_depth2 = depth;
2002       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2003              && depth && depth >= last_depth2)
2004         ;
2005       if (err)
2006         goto leave;
2007     }
2008   /* Parse other attributes. */
2009   last_depth1 = depth;
2010   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2011          && depth && depth >= last_depth1)
2012     {
2013       if (tok)
2014         {
2015           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
2016           goto leave;
2017         }
2018       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
2019         goto leave;
2020       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
2021         {
2022           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
2023             goto leave;
2024           if (tok)
2025             {
2026               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
2027                    tok++, toklen--)
2028                 created_at = created_at*10 + (*tok - '0');
2029             }
2030         }
2031       /* Skip until end of list. */
2032       last_depth2 = depth;
2033       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
2034              && depth && depth >= last_depth2)
2035         ;
2036       if (err)
2037         goto leave;
2038     }
2039
2040
2041   /* Check that we have all parameters and that they match the card
2042      description. */
2043   if (!created_at)
2044     {
2045       log_error (_("creation timestamp missing\n"));
2046       err = gpg_error (GPG_ERR_INV_VALUE);
2047       goto leave;
2048     }
2049   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
2050   if (nbits != 1024)
2051     {
2052       log_error (_("RSA modulus missing or not of size %d bits\n"), 1024);
2053       err = gpg_error (GPG_ERR_BAD_SECKEY);
2054       goto leave;
2055     }
2056   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
2057   if (nbits < 2 || nbits > 32)
2058     {
2059       log_error (_("RSA public exponent missing or larger than %d bits\n"),
2060                  32);
2061       err = gpg_error (GPG_ERR_BAD_SECKEY);
2062       goto leave;
2063     }
2064   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
2065   if (nbits != 512)
2066     {
2067       log_error (_("RSA prime %s missing or not of size %d bits\n"), "P", 512);
2068       err = gpg_error (GPG_ERR_BAD_SECKEY);
2069       goto leave;
2070     }
2071   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
2072   if (nbits != 512)
2073     {
2074       log_error (_("RSA prime %s missing or not of size %d bits\n"), "Q", 512);
2075       err = gpg_error (GPG_ERR_BAD_SECKEY);
2076       goto leave;
2077     }
2078   
2079
2080   /* Build the private key template as described in section 4.3.3.6 of
2081      the OpenPGP card specs:
2082          0xC0   <length> public exponent
2083          0xC1   <length> prime p 
2084          0xC2   <length> prime q 
2085   */
2086   assert (rsa_e_len <= 4);
2087   template_len = (1 + 1 + 4
2088                   + 1 + 1 + rsa_p_len
2089                   + 1 + 1 + rsa_q_len);
2090   template = tp = xtrymalloc_secure (template_len);
2091   if (!template)
2092     {
2093       err = gpg_error_from_syserror ();
2094       goto leave;
2095     }
2096   *tp++ = 0xC0;
2097   *tp++ = 4;
2098   memcpy (tp, rsa_e, rsa_e_len);
2099   if (rsa_e_len < 4)
2100     {
2101       /* Right justify E. */
2102       memmove (tp+4-rsa_e_len, tp, rsa_e_len);
2103       memset (tp, 0, 4-rsa_e_len);
2104     }                 
2105   tp += 4;
2106
2107   *tp++ = 0xC1;
2108   *tp++ = rsa_p_len;
2109   memcpy (tp, rsa_p, rsa_p_len);
2110   tp += rsa_p_len;
2111
2112   *tp++ = 0xC2;
2113   *tp++ = rsa_q_len;
2114   memcpy (tp, rsa_q, rsa_q_len);
2115   tp += rsa_q_len;
2116
2117   assert (tp - template == template_len);
2118
2119
2120   /* Obviously we need to remove the cached public key.  */
2121   xfree (app->app_local->pk[keyno].key);
2122   app->app_local->pk[keyno].key = NULL;
2123   app->app_local->pk[keyno].keylen = 0;
2124   app->app_local->pk[keyno].read_done = 0;
2125
2126   /* Prepare for storing the key.  */
2127   err = verify_chv3 (app, pincb, pincb_arg);
2128   if (err)
2129     goto leave;
2130
2131   /* Store the key. */
2132   err = iso7816_put_data (app->slot, 0,
2133                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
2134                          template, template_len);
2135   if (err)
2136     {
2137       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
2138       goto leave;
2139     }
2140  
2141   err = store_fpr (app->slot, keyno, created_at,
2142                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
2143                   fprbuf, app->card_version);
2144   if (err)
2145     goto leave;
2146
2147
2148  leave:
2149   xfree (template);
2150   return err;
2151 }
2152
2153
2154 /* Handle the GENKEY command. */
2155 static gpg_error_t 
2156 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
2157            time_t createtime,
2158            gpg_error_t (*pincb)(void*, const char *, char **),
2159            void *pincb_arg)
2160 {
2161   int rc;
2162   char numbuf[30];
2163   unsigned char fprbuf[20];
2164   const unsigned char *keydata, *m, *e;
2165   unsigned char *buffer = NULL;
2166   size_t buflen, keydatalen, mlen, elen;
2167   time_t created_at;
2168   int keyno = atoi (keynostr);
2169   int force = (flags & 1);
2170   time_t start_at;
2171
2172   if (keyno < 1 || keyno > 3)
2173     return gpg_error (GPG_ERR_INV_ID);
2174   keyno--;
2175
2176   /* We flush the cache to increase the traffic before a key
2177      generation.  This _might_ help a card to gather more entropy. */
2178   flush_cache (app);
2179
2180   /* Obviously we need to remove the cached public key.  */
2181   xfree (app->app_local->pk[keyno].key);
2182   app->app_local->pk[keyno].key = NULL;
2183   app->app_local->pk[keyno].keylen = 0;
2184   app->app_local->pk[keyno].read_done = 0;
2185
2186   /* Check whether a key already exists.  */
2187   rc = does_key_exist (app, keyno, force);
2188   if (rc)
2189     return rc;
2190
2191   /* Prepare for key generation by verifying the Admin PIN.  */
2192   rc = verify_chv3 (app, pincb, pincb_arg);
2193   if (rc)
2194     goto leave;
2195    
2196 #if 1
2197   log_info (_("please wait while key is being generated ...\n"));
2198   start_at = time (NULL);
2199   rc = iso7816_generate_keypair 
2200 #else
2201 # warning key generation temporary replaced by reading an existing key.
2202   rc = iso7816_read_public_key
2203 #endif
2204     (app->slot, (const unsigned char*)(keyno == 0? "\xB6" :
2205                                        keyno == 1? "\xB8" : "\xA4"),
2206      2,
2207      &buffer, &buflen);
2208   if (rc)
2209     {
2210       rc = gpg_error (GPG_ERR_CARD);
2211       log_error (_("generating key failed\n"));
2212       goto leave;
2213     }
2214   log_info (_("key generation completed (%d seconds)\n"),
2215             (int)(time (NULL) - start_at));
2216   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2217   if (!keydata)
2218     {
2219       rc = gpg_error (GPG_ERR_CARD);
2220       log_error (_("response does not contain the public key data\n"));
2221       goto leave;
2222     }
2223  
2224   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
2225   if (!m)
2226     {
2227       rc = gpg_error (GPG_ERR_CARD);
2228       log_error (_("response does not contain the RSA modulus\n"));
2229       goto leave;
2230     }
2231 /*    log_printhex ("RSA n:", m, mlen); */
2232   send_key_data (ctrl, "n", m, mlen);
2233
2234   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
2235   if (!e)
2236     {
2237       rc = gpg_error (GPG_ERR_CARD);
2238       log_error (_("response does not contain the RSA public exponent\n"));
2239       goto leave;
2240     }
2241 /*    log_printhex ("RSA e:", e, elen); */
2242   send_key_data (ctrl, "e", e, elen);
2243
2244   created_at = createtime? createtime : gnupg_get_time ();
2245   sprintf (numbuf, "%lu", (unsigned long)created_at);
2246   send_status_info (ctrl, "KEY-CREATED-AT",
2247                     numbuf, (size_t)strlen(numbuf), NULL, 0);
2248
2249   rc = store_fpr (app->slot, keyno, (u32)created_at,
2250                   m, mlen, e, elen, fprbuf, app->card_version);
2251   if (rc)
2252     goto leave;
2253   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
2254
2255
2256  leave:
2257   xfree (buffer);
2258   return rc;
2259 }
2260
2261
2262 static unsigned long
2263 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
2264 {
2265   unsigned long ul;
2266
2267   if (valuelen == 3 )
2268     ul = (value[0] << 16) | (value[1] << 8) | value[2];
2269   else
2270     {
2271       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
2272       ul = 0;
2273     }
2274   return ul;
2275 }
2276
2277 static unsigned long
2278 get_sig_counter (app_t app)
2279 {
2280   void *relptr;
2281   unsigned char *value;
2282   size_t valuelen;
2283   unsigned long ul;
2284
2285   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
2286   if (!relptr)
2287     return 0;
2288   ul = convert_sig_counter_value (value, valuelen);
2289   xfree (relptr);
2290   return ul;
2291 }
2292
2293 static gpg_error_t
2294 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
2295 {
2296   const unsigned char *fpr;
2297   unsigned char *buffer;
2298   size_t buflen, n;
2299   int rc, i;
2300   
2301   assert (keyno >= 1 && keyno <= 3);
2302
2303   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
2304   if (rc)
2305     {
2306       log_error (_("error reading application data\n"));
2307       return gpg_error (GPG_ERR_GENERAL);
2308     }
2309   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
2310   if (!fpr || n != 60)
2311     {
2312       xfree (buffer);
2313       log_error (_("error reading fingerprint DO\n"));
2314       return gpg_error (GPG_ERR_GENERAL);
2315     }
2316   fpr += (keyno-1)*20;
2317   for (i=0; i < 20; i++)
2318     if (sha1fpr[i] != fpr[i])
2319       {
2320         xfree (buffer);
2321         log_info (_("fingerprint on card does not match requested one\n"));
2322         return gpg_error (GPG_ERR_WRONG_SECKEY);
2323       }
2324   xfree (buffer);
2325   return 0;
2326 }
2327
2328
2329   /* If a fingerprint has been specified check it against the one on
2330      the card.  This is allows for a meaningful error message in case
2331      the key on the card has been replaced but the shadow information
2332      known to gpg was not updated.  If there is no fingerprint we
2333      assume that this is okay. */
2334 static gpg_error_t
2335 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2336 {
2337   unsigned char tmp[20];
2338   const char *s;
2339   int n;
2340
2341   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2342     ;
2343   if (n != 40)
2344     return gpg_error (GPG_ERR_INV_ID);
2345   else if (!*s)
2346     ; /* okay */
2347   else
2348     return gpg_error (GPG_ERR_INV_ID);
2349
2350   for (s=fpr, n=0; n < 20; s += 2, n++)
2351         tmp[n] = xtoi_2 (s);
2352   return compare_fingerprint (app, keyno, tmp);
2353 }
2354
2355
2356
2357 /* Compute a digital signature on INDATA which is expected to be the
2358    raw message digest. For this application the KEYIDSTR consists of
2359    the serialnumber and the fingerprint delimited by a slash.
2360
2361    Note that this function may return the error code
2362    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2363    not match the one required for the requested action (e.g. the
2364    serial number does not match). 
2365    
2366    As a special feature a KEYIDSTR of "OPENPGP.3" redirects the
2367    operation to the auth command.
2368 */
2369 static gpg_error_t 
2370 do_sign (app_t app, const char *keyidstr, int hashalgo,
2371          gpg_error_t (*pincb)(void*, const char *, char **),
2372          void *pincb_arg,
2373          const void *indata, size_t indatalen,
2374          unsigned char **outdata, size_t *outdatalen )
2375 {
2376   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
2377   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2378     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
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   int rc;
2383   unsigned char data[35];
2384   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2385   const char *s;
2386   int n;
2387   const char *fpr = NULL;
2388   unsigned long sigcount;
2389   int use_auth = 0;
2390
2391   if (!keyidstr || !*keyidstr)
2392     return gpg_error (GPG_ERR_INV_VALUE);
2393   if (indatalen == 20)
2394     ;
2395   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_SHA1
2396            && !memcmp (indata, sha1_prefix, 15))
2397     {
2398       indata = (const char*)indata + 15;
2399       indatalen -= 15;
2400     }
2401   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_RMD160
2402            && !memcmp (indata, rmd160_prefix, 15))
2403     {
2404       indata = (const char*)indata + 15;
2405       indatalen -= 15;
2406     }
2407   else
2408     {
2409       log_error (_("card does not support digest algorithm %s\n"),
2410                  gcry_md_algo_name (hashalgo));
2411       return gpg_error (GPG_ERR_INV_VALUE);
2412     }
2413
2414   /* Check whether an OpenPGP card of any version has been requested. */
2415   if (!strcmp (keyidstr, "OPENPGP.1"))
2416     ;
2417   else if (!strcmp (keyidstr, "OPENPGP.3"))
2418     use_auth = 1;
2419   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2420     return gpg_error (GPG_ERR_INV_ID);
2421   else
2422     {
2423       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2424         ;
2425       if (n != 32)
2426         return gpg_error (GPG_ERR_INV_ID);
2427       else if (!*s)
2428         ; /* no fingerprint given: we allow this for now. */
2429       else if (*s == '/')
2430         fpr = s + 1; 
2431       else
2432         return gpg_error (GPG_ERR_INV_ID);
2433
2434       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2435         tmp_sn[n] = xtoi_2 (s);
2436
2437       if (app->serialnolen != 16)
2438         return gpg_error (GPG_ERR_INV_CARD);
2439       if (memcmp (app->serialno, tmp_sn, 16))
2440         return gpg_error (GPG_ERR_WRONG_CARD);
2441     }
2442
2443   /* If a fingerprint has been specified check it against the one on
2444      the card.  This is allows for a meaningful error message in case
2445      the key on the card has been replaced but the shadow information
2446      known to gpg was not updated.  If there is no fingerprint, gpg
2447      will detect a bogus signature anyway due to the
2448      verify-after-signing feature. */
2449   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2450   if (rc)
2451     return rc;
2452
2453   if (hashalgo == GCRY_MD_SHA1)
2454     memcpy (data, sha1_prefix, 15);
2455   else if (hashalgo == GCRY_MD_RMD160)
2456     memcpy (data, rmd160_prefix, 15);
2457   else 
2458     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2459   memcpy (data+15, indata, indatalen);
2460
2461   if (use_auth)
2462     {
2463       /* This is a hack to redirect to the internal authenticate command.  */
2464       return do_auth (app, "OPENPGP.3", pincb, pincb_arg,
2465                       data, 35,
2466                       outdata, outdatalen);
2467     }
2468
2469   sigcount = get_sig_counter (app);
2470   log_info (_("signatures created so far: %lu\n"), sigcount);
2471
2472   if (!app->did_chv1 || app->force_chv1 ) 
2473     {
2474       char *pinvalue;
2475
2476       rc = verify_a_chv (app, pincb, pincb_arg, 1, sigcount, &pinvalue);
2477       if (rc)
2478         return rc;
2479
2480       app->did_chv1 = 1;
2481
2482       if (!app->did_chv2 && pinvalue)
2483         {
2484           /* We should also verify CHV2.  Note, that we can't do that
2485              if the keypad has been used. */
2486           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2487           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2488             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2489           if (rc)
2490             {
2491               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2492               xfree (pinvalue);
2493               flush_cache_after_error (app);
2494               return rc;
2495             }
2496           app->did_chv2 = 1;
2497         }
2498       xfree (pinvalue);
2499     }
2500
2501   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
2502   return rc;
2503 }
2504
2505 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2506    on INDATA which is expected to be the raw message digest. For this
2507    application the KEYIDSTR consists of the serialnumber and the
2508    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2509    be given.
2510
2511    Note that this function may return the error code
2512    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2513    not match the one required for the requested action (e.g. the
2514    serial number does not match). */
2515 static gpg_error_t 
2516 do_auth (app_t app, const char *keyidstr,
2517          gpg_error_t (*pincb)(void*, const char *, char **),
2518          void *pincb_arg,
2519          const void *indata, size_t indatalen,
2520          unsigned char **outdata, size_t *outdatalen )
2521 {
2522   int rc;
2523   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2524   const char *s;
2525   int n;
2526   const char *fpr = NULL;
2527
2528   if (!keyidstr || !*keyidstr)
2529     return gpg_error (GPG_ERR_INV_VALUE);
2530   if (indatalen > 50) /* For a 1024 bit key. */
2531     return gpg_error (GPG_ERR_INV_VALUE);
2532
2533   /* Check whether an OpenPGP card of any version has been requested. */
2534   if (!strcmp (keyidstr, "OPENPGP.3"))
2535     ;
2536   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2537     return gpg_error (GPG_ERR_INV_ID);
2538   else
2539     {
2540       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2541         ;
2542       if (n != 32)
2543         return gpg_error (GPG_ERR_INV_ID);
2544       else if (!*s)
2545         ; /* no fingerprint given: we allow this for now. */
2546       else if (*s == '/')
2547         fpr = s + 1; 
2548       else
2549         return gpg_error (GPG_ERR_INV_ID);
2550
2551       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2552         tmp_sn[n] = xtoi_2 (s);
2553       
2554       if (app->serialnolen != 16)
2555         return gpg_error (GPG_ERR_INV_CARD);
2556       if (memcmp (app->serialno, tmp_sn, 16))
2557         return gpg_error (GPG_ERR_WRONG_CARD);
2558     }
2559
2560   /* If a fingerprint has been specified check it against the one on
2561      the card.  This is allows for a meaningful error message in case
2562      the key on the card has been replaced but the shadow information
2563      known to gpg was not updated.  If there is no fingerprint, gpg
2564      will detect a bogus signature anyway due to the
2565      verify-after-signing feature. */
2566   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2567   if (rc)
2568     return rc;
2569
2570   rc = verify_chv2 (app, pincb, pincb_arg);
2571   if (!rc)
2572     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2573                                         outdata, outdatalen);
2574   return rc;
2575 }
2576
2577
2578 static gpg_error_t 
2579 do_decipher (app_t app, const char *keyidstr,
2580              gpg_error_t (*pincb)(void*, const char *, char **),
2581              void *pincb_arg,
2582              const void *indata, size_t indatalen,
2583              unsigned char **outdata, size_t *outdatalen )
2584 {
2585   int rc;
2586   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2587   const char *s;
2588   int n;
2589   const char *fpr = NULL;
2590
2591   if (!keyidstr || !*keyidstr || !indatalen)
2592     return gpg_error (GPG_ERR_INV_VALUE);
2593
2594   /* Check whether an OpenPGP card of any version has been requested. */
2595   if (!strcmp (keyidstr, "OPENPGP.2"))
2596     ;
2597   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2598     return gpg_error (GPG_ERR_INV_ID);
2599   else
2600     {
2601       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2602         ;
2603       if (n != 32)
2604         return gpg_error (GPG_ERR_INV_ID);
2605       else if (!*s)
2606         ; /* no fingerprint given: we allow this for now. */
2607       else if (*s == '/')
2608         fpr = s + 1; 
2609       else
2610         return gpg_error (GPG_ERR_INV_ID);
2611       
2612       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2613         tmp_sn[n] = xtoi_2 (s);
2614       
2615       if (app->serialnolen != 16)
2616         return gpg_error (GPG_ERR_INV_CARD);
2617       if (memcmp (app->serialno, tmp_sn, 16))
2618         return gpg_error (GPG_ERR_WRONG_CARD);
2619     }
2620
2621   /* If a fingerprint has been specified check it against the one on
2622      the card.  This is allows for a meaningful error message in case
2623      the key on the card has been replaced but the shadow information
2624      known to gpg was not updated.  If there is no fingerprint, the
2625      decryption will won't produce the right plaintext anyway. */
2626   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
2627   if (rc)
2628     return rc;
2629
2630   rc = verify_chv2 (app, pincb, pincb_arg);
2631   if (!rc)
2632     {
2633       size_t fixuplen;
2634
2635       /* We might encounter a couple of leading zeroes in the
2636          cryptogram.  Due to internal use of MPIs thease leading
2637          zeroes are stripped.  However the OpenPGP card expects
2638          exactly 128 bytes for the cryptogram (for a 1k key).  Thus we
2639          need to fix it up.  We do this for up to 16 leading zero
2640          bytes; a cryptogram with more than this is with a very high
2641          probability anyway broken.  */
2642       if (indatalen >= (128-16) && indatalen < 128)      /* 1024 bit key.  */
2643         fixuplen = 128 - indatalen;
2644       else if (indatalen >= (256-16) && indatalen < 256) /* 2048 bit key.  */
2645         fixuplen = 256 - indatalen;
2646       else if (indatalen >= (192-16) && indatalen < 192) /* 1536 bit key.  */
2647         fixuplen = 192 - indatalen;
2648       else
2649         fixuplen = 0;
2650       if (fixuplen)
2651         {
2652           unsigned char *fixbuf;
2653
2654           /* While we have to prepend stuff anyway, we can also
2655              include the padding byte here so that iso1816_decipher
2656              does not need to do yet another data mangling.  */
2657           fixuplen++;
2658           fixbuf = xtrymalloc (fixuplen + indatalen);
2659           if (!fixbuf)
2660             rc = gpg_error_from_syserror ();
2661           else
2662             {
2663               memset (fixbuf, 0, fixuplen);
2664               memcpy (fixbuf+fixuplen, indata, indatalen);
2665               rc = iso7816_decipher (app->slot, fixbuf, fixuplen+indatalen, -1,
2666                                      outdata, outdatalen);
2667               xfree (fixbuf);
2668             }
2669
2670         }
2671       else
2672         rc = iso7816_decipher (app->slot, indata, indatalen, 0,
2673                                outdata, outdatalen);
2674     }
2675   return rc;
2676 }
2677
2678
2679 /* Perform a simple verify operation for CHV1 and CHV2, so that
2680    further operations won't ask for CHV2 and it is possible to do a
2681    cheap check on the PIN: If there is something wrong with the PIN
2682    entry system, only the regular CHV will get blocked and not the
2683    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
2684    optional fingerprint part will be ignored.
2685
2686    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
2687    the "[CHV3]" being a literal string:  The Admin Pin is checked if
2688    and only if the retry counter is still at 3. */
2689 static gpg_error_t 
2690 do_check_pin (app_t app, const char *keyidstr,
2691               gpg_error_t (*pincb)(void*, const char *, char **),
2692               void *pincb_arg)
2693 {
2694   unsigned char tmp_sn[20]; 
2695   const char *s;
2696   int n;
2697   int admin_pin = 0;
2698
2699   if (!keyidstr || !*keyidstr)
2700     return gpg_error (GPG_ERR_INV_VALUE);
2701
2702   /* Check whether an OpenPGP card of any version has been requested. */
2703   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2704     return gpg_error (GPG_ERR_INV_ID);
2705   
2706   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2707     ;
2708   if (n != 32)
2709     return gpg_error (GPG_ERR_INV_ID);
2710   else if (!*s)
2711     ; /* No fingerprint given: we allow this for now. */
2712   else if (*s == '/')
2713     ; /* We ignore a fingerprint. */
2714   else if (!strcmp (s, "[CHV3]") )
2715     admin_pin = 1;
2716   else
2717     return gpg_error (GPG_ERR_INV_ID);
2718
2719   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2720     tmp_sn[n] = xtoi_2 (s);
2721
2722   if (app->serialnolen != 16)
2723     return gpg_error (GPG_ERR_INV_CARD);
2724   if (memcmp (app->serialno, tmp_sn, 16))
2725     return gpg_error (GPG_ERR_WRONG_CARD);
2726
2727   /* Yes, there is a race conditions: The user might pull the card
2728      right here and we won't notice that.  However this is not a
2729      problem and the check above is merely for a graceful failure
2730      between operations. */
2731
2732   if (admin_pin)
2733     {
2734       void *relptr;
2735       unsigned char *value;
2736       size_t valuelen;
2737       int count;
2738       
2739       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2740       if (!relptr || valuelen < 7)
2741         {
2742           log_error (_("error retrieving CHV status from card\n"));
2743           xfree (relptr);
2744           return gpg_error (GPG_ERR_CARD);
2745         }
2746       count = value[6];
2747       xfree (relptr);
2748
2749       if (!count)
2750         {
2751           log_info (_("card is permanently locked!\n"));
2752           return gpg_error (GPG_ERR_BAD_PIN);
2753         }
2754       else if (value[6] < 3)
2755         {
2756           log_info (_("verification of Admin PIN is currently prohibited "
2757                       "through this command\n"));
2758           return gpg_error (GPG_ERR_GENERAL);
2759         }
2760
2761       app->did_chv3 = 0; /* Force verification.  */
2762       return verify_chv3 (app, pincb, pincb_arg);
2763     }
2764   else
2765     return verify_chv2 (app, pincb, pincb_arg);
2766 }
2767
2768
2769 /* Show information about card capabilities.  */
2770 static void
2771 show_caps (struct app_local_s *s)
2772 {
2773   log_info ("Version-2 ......: %s\n", s->extcap.is_v2? "yes":"no");
2774   log_info ("Get-Challenge ..: %s", s->extcap.get_challenge? "yes":"no");
2775   if (s->extcap.get_challenge)
2776     log_printf (" (%u bytes max)", s->extcap.max_get_challenge);
2777   log_info ("Key-Import .....: %s\n", s->extcap.key_import? "yes":"no");
2778   log_info ("Change-Force-PW1: %s\n", s->extcap.change_force_chv? "yes":"no");
2779   log_info ("Private-DOs ....: %s\n", s->extcap.private_dos? "yes":"no");
2780   log_info ("SM-Support .....: %s", s->extcap.sm_supported? "yes":"no");
2781   if (s->extcap.sm_supported)
2782     log_printf (" (%s)", s->extcap.sm_aes128? "AES-128":"3DES");
2783   log_info ("Max-Cert3-Len ..: %u\n", s->extcap.max_certlen_3);
2784   log_info ("Max-Cmd-Data ...: %u\n", s->extcap.max_cmd_data);
2785   log_info ("Max-Rsp-Data ...: %u\n", s->extcap.max_rsp_data);
2786   log_info ("Cmd-Chaining ...: %s\n", s->cardcap.cmd_chaining?"yes":"no");
2787   log_info ("Ext-Lc-Le ......: %s\n", s->cardcap.ext_lc_le?"yes":"no");
2788   log_info ("Status Indicator: %02X\n", s->status_indicator);
2789
2790   log_info ("GnuPG-No-Sync ..: %s\n",  s->flags.no_sync? "yes":"no");
2791   log_info ("GnuPG-Def-PW2 ..: %s\n",  s->flags.def_chv2? "yes":"no");
2792 }
2793
2794
2795 /* Parse the historical bytes in BUFFER of BUFLEN and store them in
2796    APPLOC.  */
2797 static void
2798 parse_historical (struct app_local_s *apploc, 
2799                   const unsigned char * buffer, size_t buflen)
2800 {
2801   /* Example buffer: 00 31 C5 73 C0 01 80 00 90 00  */
2802   if (buflen < 4)
2803     {
2804       log_error ("warning: historical bytes are too short\n");
2805       return; /* Too short.  */
2806     }
2807   if (*buffer)
2808     {
2809       log_error ("warning: bad category indicator in historical bytes\n");
2810       return; 
2811     }
2812   
2813   /* Skip category indicator.  */
2814   buffer++;
2815   buflen--;
2816
2817   /* Get the status indicator.  */
2818   apploc->status_indicator = buffer[buflen-3];
2819   buflen -= 3;
2820
2821   /* Parse the compact TLV.  */
2822   while (buflen)
2823     {
2824       unsigned int tag = (*buffer & 0xf0) >> 4;
2825       unsigned int len = (*buffer & 0x0f);
2826       if (len+1 > buflen)
2827         {
2828           log_error ("warning: bad Compact-TLV in historical bytes\n");
2829           return; /* Error.  */
2830         }
2831       buffer++;
2832       buflen--;
2833       if (tag == 7 && len == 3)
2834         {
2835           /* Card capabilities.  */
2836           apploc->cardcap.cmd_chaining = !!(buffer[2] & 0x80);
2837           apploc->cardcap.ext_lc_le    = !!(buffer[2] & 0x40);
2838         }
2839       buffer += len;
2840       buflen -= len;
2841     }
2842 }
2843
2844
2845 /* Select the OpenPGP application on the card in SLOT.  This function
2846    must be used before any other OpenPGP application functions. */
2847 gpg_error_t
2848 app_select_openpgp (app_t app)
2849 {
2850   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
2851   int slot = app->slot;
2852   int rc;
2853   unsigned char *buffer;
2854   size_t buflen;
2855   void *relptr;
2856   
2857   /* Note that the card can't cope with P2=0xCO, thus we need to pass a
2858      special flag value. */
2859   rc = iso7816_select_application (slot, aid, sizeof aid, 0x0001);
2860   if (!rc)
2861     {
2862       unsigned int manufacturer;
2863
2864       app->apptype = "OPENPGP";
2865
2866       app->did_chv1 = 0;
2867       app->did_chv2 = 0;
2868       app->did_chv3 = 0;
2869       app->app_local = NULL;
2870
2871       /* The OpenPGP card returns the serial number as part of the
2872          AID; because we prefer to use OpenPGP serial numbers, we
2873          replace a possibly already set one from a EF.GDO with this
2874          one.  Note, that for current OpenPGP cards, no EF.GDO exists
2875          and thus it won't matter at all. */
2876       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
2877       if (rc)
2878         goto leave;
2879       if (opt.verbose)
2880         {
2881           log_info ("AID: ");
2882           log_printhex ("", buffer, buflen);
2883         }
2884
2885       app->card_version = buffer[6] << 8;
2886       app->card_version |= buffer[7];
2887       manufacturer = (buffer[8]<<8 | buffer[9]);
2888
2889       xfree (app->serialno);
2890       app->serialno = buffer;
2891       app->serialnolen = buflen;
2892       buffer = NULL;
2893       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2894       if (!app->app_local)
2895         {
2896           rc = gpg_error (gpg_err_code_from_errno (errno));
2897           goto leave;
2898         }
2899
2900       if (app->card_version >= 0x0200)
2901         app->app_local->extcap.is_v2 = 1;
2902
2903
2904       /* Read the historical bytes.  */
2905       relptr = get_one_do (app, 0x5f52, &buffer, &buflen, NULL);
2906       if (relptr)
2907         {
2908           if (opt.verbose)
2909             {
2910               log_info ("Historical Bytes: ");
2911               log_printhex ("", buffer, buflen);
2912             }
2913           parse_historical (app->app_local, buffer, buflen);
2914           xfree (relptr);
2915         }
2916
2917
2918       /* Read the force-chv1 flag.  */
2919       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
2920       if (!relptr)
2921         {
2922           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2923                      "CHV Status Bytes");
2924           goto leave;
2925         }
2926       app->force_chv1 = (buflen && *buffer == 0);
2927       xfree (relptr);
2928
2929       /* Read the extended capabilities.  */
2930       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
2931       if (!relptr)
2932         {
2933           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2934                      "Extended Capability Flags" );
2935           goto leave;
2936         }
2937       if (buflen)
2938         {
2939           app->app_local->extcap.sm_supported     = !!(*buffer & 0x80);
2940           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
2941           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
2942           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
2943           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
2944         }
2945       if (buflen >= 10)
2946         {
2947           /* Available with v2 cards.  */
2948           app->app_local->extcap.sm_aes128     = (buffer[1] == 1);
2949           app->app_local->extcap.max_get_challenge 
2950                                                = (buffer[2] << 8 | buffer[3]);
2951           app->app_local->extcap.max_certlen_3 = (buffer[4] << 8 | buffer[5]);
2952           app->app_local->extcap.max_cmd_data  = (buffer[6] << 8 | buffer[7]);
2953           app->app_local->extcap.max_rsp_data  = (buffer[8] << 8 | buffer[9]);
2954         }
2955       xfree (relptr);
2956       
2957       /* Some of the first cards accidently don't set the
2958          CHANGE_FORCE_CHV bit but allow it anyway. */
2959       if (app->card_version <= 0x0100 && manufacturer == 1)
2960         app->app_local->extcap.change_force_chv = 1;
2961
2962       parse_login_data (app);
2963
2964       if (opt.verbose)
2965         show_caps (app->app_local);
2966
2967       if (opt.verbose > 1)
2968         dump_all_do (slot);
2969
2970       app->fnc.deinit = do_deinit;
2971       app->fnc.learn_status = do_learn_status;
2972       app->fnc.readcert = do_readcert;
2973       app->fnc.readkey = do_readkey;
2974       app->fnc.getattr = do_getattr;
2975       app->fnc.setattr = do_setattr;
2976       app->fnc.writecert = do_writecert;
2977       app->fnc.writekey = do_writekey;
2978       app->fnc.genkey = do_genkey;
2979       app->fnc.sign = do_sign;
2980       app->fnc.auth = do_auth;
2981       app->fnc.decipher = do_decipher;
2982       app->fnc.change_pin = do_change_pin;
2983       app->fnc.check_pin = do_check_pin;
2984    }
2985
2986 leave:
2987   if (rc)
2988     do_deinit (app);
2989   return rc;
2990 }
2991
2992
2993