Switched to GPLv3.
[gnupg.git] / g10 / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003, 2004, 2005 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   { 0x0065, 1,    0, 1, 0, 0, 0, "Cardholder Related Data"},
67   { 0x005B, 0, 0x65, 0, 0, 0, 0, "Name" },
68   { 0x5F2D, 0, 0x65, 0, 0, 0, 0, "Language preferences" },
69   { 0x5F35, 0, 0x65, 0, 0, 0, 0, "Sex" },
70   { 0x006E, 1,    0, 1, 0, 0, 0, "Application Related Data" },
71   { 0x004F, 0, 0x6E, 1, 0, 0, 0, "AID" },
72   { 0x0073, 1,    0, 1, 0, 0, 0, "Discretionary Data Objects" },
73   { 0x0047, 0, 0x6E, 1, 1, 0, 0, "Card Capabilities" },
74   { 0x00C0, 0, 0x6E, 1, 1, 0, 0, "Extended Card Capabilities" },
75   { 0x00C1, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Signature" },
76   { 0x00C2, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Decryption" },
77   { 0x00C3, 0, 0x6E, 1, 1, 0, 0, "Algorithm Attributes Authentication" },
78   { 0x00C4, 0, 0x6E, 1, 0, 1, 1, "CHV Status Bytes" },
79   { 0x00C5, 0, 0x6E, 1, 0, 0, 0, "Fingerprints" },
80   { 0x00C6, 0, 0x6E, 1, 0, 0, 0, "CA Fingerprints" },
81   { 0x00CD, 0, 0x6E, 1, 0, 0, 0, "Generation time" },
82   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
83   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
84   { 0x0101, 0,    0, 0, 0, 0, 0, "Private DO 1"},
85   { 0x0102, 0,    0, 0, 0, 0, 0, "Private DO 2"},
86   { 0x0103, 0,    0, 0, 0, 0, 0, "Private DO 3"},
87   { 0x0104, 0,    0, 0, 0, 0, 0, "Private DO 4"},
88   { 0 }
89 };
90
91
92 /* One cache item for DOs.  */
93 struct cache_s {
94   struct cache_s *next;
95   int tag;
96   size_t length;
97   unsigned char data[1];
98 };
99
100
101 /* Object with application (i.e. OpenPGP card) specific data.  */
102 struct app_local_s {
103   /* A linked list with cached DOs.  */
104   struct cache_s *cache;
105   
106   /* Keep track of the public keys.  */
107   struct
108   {
109     int read_done;   /* True if we have at least tried to read them.  */
110     unsigned char *key; /* This is a malloced buffer with a canonical
111                            encoded S-expression encoding a public
112                            key. Might be NULL if key is not
113                            available.  */
114     size_t keylen;      /* The length of the above S-expression.  Thsi
115                            is usullay only required for corss checks
116                            because the length of an S-expression is
117                            implicitly available.  */
118   } pk[3];
119
120   /* Keep track of card capabilities.  */
121   struct 
122   {
123     unsigned int get_challenge:1;
124     unsigned int key_import:1;
125     unsigned int change_force_chv:1;
126     unsigned int private_dos:1;
127   } extcap;
128
129   /* Flags used to control the application.  */
130   struct
131   {
132     unsigned int no_sync:1;   /* Do not sync CHV1 and CHV2 */
133     unsigned int def_chv2:1;  /* Use 123456 for CHV2.  */
134   } flags;
135 };
136
137
138
139 /***** Local prototypes  *****/
140 static unsigned long convert_sig_counter_value (const unsigned char *value,
141                                                 size_t valuelen);
142 static unsigned long get_sig_counter (app_t app);
143
144
145
146
147 \f
148 /* Deconstructor. */
149 static void
150 do_deinit (app_t app)
151 {
152   if (app && app->app_local)
153     {
154       struct cache_s *c, *c2;
155       int i;
156
157       for (c = app->app_local->cache; c; c = c2)
158         {
159           c2 = c->next;
160           xfree (c);
161         }
162
163       for (i=0; i < DIM (app->app_local->pk); i++)
164         {
165           xfree (app->app_local->pk[i].key);
166           app->app_local->pk[i].read_done = 0;
167         }
168       xfree (app->app_local);
169       app->app_local = NULL;
170     }
171 }
172
173
174 /* Wrapper around iso7816_get_data which first tries to get the data
175    from the cache.  With GET_IMMEDIATE passed as true, the cache is
176    bypassed. */
177 static gpg_error_t
178 get_cached_data (app_t app, int tag, 
179                  unsigned char **result, size_t *resultlen,
180                  int get_immediate)
181 {
182   gpg_error_t err;
183   int i;
184   unsigned char *p;
185   size_t len;
186   struct cache_s *c;
187
188   *result = NULL;
189   *resultlen = 0;
190
191   if (!get_immediate)
192     {
193       for (c=app->app_local->cache; c; c = c->next)
194         if (c->tag == tag)
195           {
196             if(c->length)
197               {
198                 p = xtrymalloc (c->length);
199                 if (!p)
200                   return gpg_error (gpg_err_code_from_errno (errno));
201                 memcpy (p, c->data, c->length);
202                 *result = p;
203               }
204             
205             *resultlen = c->length;
206             
207             return 0;
208           }
209     }
210   
211   err = iso7816_get_data (app->slot, tag, &p, &len);
212   if (err)
213     return err;
214   *result = p;
215   *resultlen = len;
216
217   /* Check whether we should cache this object. */
218   if (get_immediate)
219     return 0;
220
221   for (i=0; data_objects[i].tag; i++)
222     if (data_objects[i].tag == tag)
223       {
224         if (data_objects[i].dont_cache)
225           return 0;
226         break;
227       }
228
229   /* Okay, cache it. */
230   for (c=app->app_local->cache; c; c = c->next)
231     assert (c->tag != tag);
232   
233   c = xtrymalloc (sizeof *c + len);
234   if (c)
235     {
236       memcpy (c->data, p, len);
237       c->length = len;
238       c->tag = tag;
239       c->next = app->app_local->cache;
240       app->app_local->cache = c;
241     }
242
243   return 0;
244 }
245
246 /* Remove DO at TAG from the cache. */
247 static void
248 flush_cache_item (app_t app, int tag)
249 {
250   struct cache_s *c, *cprev;
251   int i;
252
253   if (!app->app_local)
254     return;
255
256   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
257     if (c->tag == tag)
258       {
259         if (cprev)
260           cprev->next = c->next;
261         else
262           app->app_local->cache = c->next;
263         xfree (c);
264
265         for (c=app->app_local->cache; c ; c = c->next)
266           {
267             assert (c->tag != tag); /* Oops: duplicated entry. */
268           }
269         return;
270       }
271
272   /* Try again if we have an outer tag. */
273   for (i=0; data_objects[i].tag; i++)
274     if (data_objects[i].tag == tag && data_objects[i].get_from
275         && data_objects[i].get_from != tag)
276       flush_cache_item (app, data_objects[i].get_from);
277 }
278
279 /* Flush all entries from the cache which might be out of sync after
280    an error. */
281 static void
282 flush_cache_after_error (app_t app)
283 {
284   int i;
285
286   for (i=0; data_objects[i].tag; i++)
287     if (data_objects[i].flush_on_error)
288       flush_cache_item (app, data_objects[i].tag);
289 }
290
291
292 /* Flush the entire cache. */
293 static void
294 flush_cache (app_t app)
295 {
296   if (app && app->app_local)
297     {
298       struct cache_s *c, *c2;
299
300       for (c = app->app_local->cache; c; c = c2)
301         {
302           c2 = c->next;
303           xfree (c);
304         }
305       app->app_local->cache = NULL;
306     }
307 }
308
309
310 /* Get the DO identified by TAG from the card in SLOT and return a
311    buffer with its content in RESULT and NBYTES.  The return value is
312    NULL if not found or a pointer which must be used to release the
313    buffer holding value. */
314 static void *
315 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes,
316             int *r_rc)
317 {
318   int rc, i;
319   unsigned char *buffer;
320   size_t buflen;
321   unsigned char *value;
322   size_t valuelen;
323   int dummyrc;
324
325   if (!r_rc)
326     r_rc = &dummyrc;
327
328   *result = NULL;
329   *nbytes = 0;
330   *r_rc = 0;
331   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
332     ;
333
334   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
335     {
336       rc = iso7816_get_data (app->slot, tag, &buffer, &buflen);
337       if (rc)
338         {
339           *r_rc = rc;
340           return NULL;
341         }
342       *result = buffer;
343       *nbytes = buflen;
344       return buffer;
345     }
346
347   value = NULL;
348   rc = -1;
349   if (data_objects[i].tag && data_objects[i].get_from)
350     {
351       rc = get_cached_data (app, data_objects[i].get_from,
352                             &buffer, &buflen,
353                             (data_objects[i].dont_cache 
354                              || data_objects[i].get_immediate_in_v11));
355       if (!rc)
356         {
357           const unsigned char *s;
358
359           s = find_tlv_unchecked (buffer, buflen, tag, &valuelen);
360           if (!s)
361             value = NULL; /* not found */
362           else if (valuelen > buflen - (s - buffer))
363             {
364               log_error ("warning: constructed DO too short\n");
365               value = NULL;
366               xfree (buffer); buffer = NULL;
367             }
368           else
369             value = buffer + (s - buffer);
370         }
371     }
372
373   if (!value) /* Not in a constructed DO, try simple. */
374     {
375       rc = get_cached_data (app, tag, &buffer, &buflen,
376                             (data_objects[i].dont_cache 
377                              || data_objects[i].get_immediate_in_v11));
378       if (!rc)
379         {
380           value = buffer;
381           valuelen = buflen;
382         }
383     }
384
385   if (!rc)
386     {
387       *nbytes = valuelen;
388       *result = value;
389       return buffer;
390     }
391   *r_rc = rc;
392   return NULL;
393 }
394
395
396 static void
397 dump_all_do (int slot)
398 {
399   int rc, i, j;
400   unsigned char *buffer;
401   size_t buflen;
402   
403   for (i=0; data_objects[i].tag; i++)
404     {
405       if (data_objects[i].get_from)
406         continue;
407
408       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
409       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
410         ;
411       else if (rc) 
412         log_info ("DO `%s' not available: %s\n",
413                   data_objects[i].desc, gpg_strerror (rc));
414       else
415         {
416           if (data_objects[i].binary)
417             {
418               log_info ("DO `%s': ", data_objects[i].desc);
419               log_printhex ("", buffer, buflen);
420             }
421           else
422             log_info ("DO `%s': `%.*s'\n",
423                       data_objects[i].desc,
424                       (int)buflen, buffer); /* FIXME: sanitize */
425
426           if (data_objects[i].constructed)
427             {
428               for (j=0; data_objects[j].tag; j++)
429                 {
430                   const unsigned char *value;
431                   size_t valuelen;
432                   
433                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
434                     continue;
435                   value = find_tlv_unchecked (buffer, buflen,
436                                               data_objects[j].tag, &valuelen);
437                   if (!value)
438                     ; /* not found */
439                   else if (valuelen > buflen - (value - buffer))
440                     log_error ("warning: constructed DO too short\n");
441                   else
442                     {
443                       if (data_objects[j].binary)
444                         {
445                           log_info ("DO `%s': ", data_objects[j].desc);
446                           log_printhex ("", value, valuelen);
447                         }
448                       else
449                         log_info ("DO `%s': `%.*s'\n",
450                                   data_objects[j].desc,
451                                   (int)valuelen, value); /* FIXME: sanitize */
452                     }
453                 }
454             }
455         }
456       xfree (buffer); buffer = NULL;
457     }
458 }
459
460
461 /* Count the number of bits, assuming the A represents an unsigned big
462    integer of length LEN bytes. */
463 static unsigned int
464 count_bits (const unsigned char *a, size_t len)
465 {
466   unsigned int n = len * 8;
467   int i;
468
469   for (; len && !*a; len--, a++, n -=8)
470     ;
471   if (len)
472     {
473       for (i=7; i && !(*a & (1<<i)); i--)
474         n--;
475     }
476   return n;
477 }
478
479 /* GnuPG makes special use of the login-data DO, this fucntion parses
480    the login data to store the flags for later use.  It may be called
481    at any time and should be called after changing the login-data DO.
482
483    Everything up to a LF is considered a mailbox or account name.  If
484    the first LF is followed by DC4 (0x14) control sequence are
485    expected up to the next LF.  Control sequences are separated by FS
486    (0x28) and consist of key=value pairs.  There is one key defined:
487
488     F=<flags>
489
490     Were FLAGS is a plain hexadecimal number representing flag values.
491     The lsb is here the rightmost bit.  Defined flags bits are:
492
493       Bit 0 = CHV1 and CHV2 are not syncronized
494       Bit 1 = CHV2 has been been set to the default PIN of "123456"
495               (this implies that bit 0 is also set).
496
497 */
498 static void
499 parse_login_data (app_t app)
500 {
501   unsigned char *buffer, *p;
502   size_t buflen, len;
503   void *relptr;
504
505   /* Set defaults.  */
506   app->app_local->flags.no_sync = 0;
507   app->app_local->flags.def_chv2 = 0;
508
509   /* Read the DO.  */
510   relptr = get_one_do (app, 0x005E, &buffer, &buflen, NULL);
511   if (!relptr)
512     return; /* Ooops. */
513   for (; buflen; buflen--, buffer++)
514     if (*buffer == '\n')
515       break;
516   if (buflen < 2 || buffer[1] != '\x14')
517     return; /* No control sequences.  */
518   buflen--;
519   buffer++;
520   do
521     {
522       buflen--;
523       buffer++;
524       if (buflen > 1 && *buffer == 'F' && buffer[1] == '=')
525         {
526           /* Flags control sequence found.  */
527           int lastdig = 0;
528
529           /* For now we are only interested in the last digit, so skip
530              any leading digits but bail out on invalid characters. */
531           for (p=buffer+2, len = buflen-2; len && hexdigitp (p); p++, len--)
532             lastdig = xtoi_1 (p);
533           if (len && !(*p == '\n' || *p == '\x18'))
534             goto next;  /* Invalid characters in field.  */
535           app->app_local->flags.no_sync = !!(lastdig & 1);
536           app->app_local->flags.def_chv2 = (lastdig & 3) == 3;
537         }
538     next:
539       for (; buflen && *buffer != '\x18'; buflen--, buffer++)
540         if (*buffer == '\n')
541           buflen = 1; 
542     }
543   while (buflen);
544
545   xfree (relptr);
546 }
547
548 /* Note, that FPR must be at least 20 bytes. */
549 static gpg_error_t 
550 store_fpr (int slot, int keynumber, u32 timestamp,
551            const unsigned char *m, size_t mlen,
552            const unsigned char *e, size_t elen, 
553            unsigned char *fpr, unsigned int card_version)
554 {
555   unsigned int n, nbits;
556   unsigned char *buffer, *p;
557   int rc;
558   
559   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
560     ;
561   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
562     ;
563
564   n = 6 + 2 + mlen + 2 + elen;
565   p = buffer = xtrymalloc (3 + n);
566   if (!buffer)
567     return gpg_error_from_errno (errno);
568   
569   *p++ = 0x99;     /* ctb */
570   *p++ = n >> 8;   /* 2 byte length header */
571   *p++ = n;
572   *p++ = 4;        /* key packet version */
573   *p++ = timestamp >> 24;
574   *p++ = timestamp >> 16;
575   *p++ = timestamp >>  8;
576   *p++ = timestamp;
577   *p++ = 1; /* RSA */
578   nbits = count_bits (m, mlen);
579   *p++ = nbits >> 8;
580   *p++ = nbits;
581   memcpy (p, m, mlen); p += mlen;
582   nbits = count_bits (e, elen);
583   *p++ = nbits >> 8;
584   *p++ = nbits;
585   memcpy (p, e, elen); p += elen;
586     
587   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
588
589   xfree (buffer);
590
591   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
592                                + keynumber, fpr, 20);
593   if (rc)
594     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
595
596   if (!rc && card_version > 0x0100)
597     {
598       unsigned char buf[4];
599
600       buf[0] = timestamp >> 24;
601       buf[1] = timestamp >> 16;
602       buf[2] = timestamp >>  8;
603       buf[3] = timestamp;
604
605       rc = iso7816_put_data (slot, 0xCE + keynumber, buf, 4);
606       if (rc)
607         log_error (_("failed to store the creation date: %s\n"),
608                    gpg_strerror (rc));
609     }
610
611   return rc;
612 }
613
614        
615 static void
616 send_fpr_if_not_null (ctrl_t ctrl, const char *keyword,
617                       int number, const unsigned char *fpr)
618 {                      
619   int i;
620   char buf[41];
621   char numbuf[25];
622
623   for (i=0; i < 20 && !fpr[i]; i++)
624     ;
625   if (i==20)
626     return; /* All zero. */
627   for (i=0; i< 20; i++)
628     sprintf (buf+2*i, "%02X", fpr[i]);
629   if (number == -1)
630     *numbuf = 0; /* Don't print the key number */
631   else
632     sprintf (numbuf, "%d", number);
633   send_status_info (ctrl, keyword,
634                     numbuf, (size_t)strlen(numbuf),
635                     buf, (size_t)strlen (buf), NULL, 0);
636 }
637
638 static void
639 send_fprtime_if_not_null (ctrl_t ctrl, const char *keyword,
640                           int number, const unsigned char *stamp)
641 {                      
642   char numbuf1[50], numbuf2[50];
643   unsigned long value;
644
645   value = (stamp[0] << 24) | (stamp[1]<<16) | (stamp[2]<<8) | stamp[3];
646   if (!value)
647     return;
648   sprintf (numbuf1, "%d", number);
649   sprintf (numbuf2, "%lu", value);
650   send_status_info (ctrl, keyword,
651                     numbuf1, (size_t)strlen(numbuf1),
652                     numbuf2, (size_t)strlen(numbuf2), NULL, 0);
653 }
654
655 static void
656 send_key_data (ctrl_t ctrl, const char *name, 
657                const unsigned char *a, size_t alen)
658 {
659   char *p, *buf = xmalloc (alen*2+1);
660   
661   for (p=buf; alen; a++, alen--, p += 2)
662     sprintf (p, "%02X", *a);
663
664   send_status_info (ctrl, "KEY-DATA",
665                     name, (size_t)strlen(name), 
666                     buf, (size_t)strlen (buf),
667                     NULL, 0);
668   xfree (buf);
669 }
670
671 /* Implement the GETATTR command.  This is similar to the LEARN
672    command but returns just one value via the status interface. */
673 static gpg_error_t 
674 do_getattr (app_t app, ctrl_t ctrl, const char *name)
675 {
676   static struct {
677     const char *name;
678     int tag;
679     int special;
680   } table[] = {
681     { "DISP-NAME",    0x005B },
682     { "LOGIN-DATA",   0x005E },
683     { "DISP-LANG",    0x5F2D },
684     { "DISP-SEX",     0x5F35 },
685     { "PUBKEY-URL",   0x5F50 },
686     { "KEY-FPR",      0x00C5, 3 },
687     { "KEY-TIME",     0x00CD, 4 },
688     { "CA-FPR",       0x00C6, 3 },
689     { "CHV-STATUS",   0x00C4, 1 }, 
690     { "SIG-COUNTER",  0x0093, 2 },
691     { "SERIALNO",     0x004F, -1 },
692     { "AID",          0x004F },
693     { "EXTCAP",       0x0000, -2 },
694     { "PRIVATE-DO-1", 0x0101 },
695     { "PRIVATE-DO-2", 0x0102 },
696     { "PRIVATE-DO-3", 0x0103 },
697     { "PRIVATE-DO-4", 0x0104 },
698     { NULL, 0 }
699   };
700   int idx, i, rc;
701   void *relptr;
702   unsigned char *value;
703   size_t valuelen;
704
705   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
706     ;
707   if (!table[idx].name)
708     return gpg_error (GPG_ERR_INV_NAME); 
709   
710   if (table[idx].special == -1)
711     {
712       /* The serial number is very special.  We could have used the
713          AID DO to retrieve it, but we have it already in the app
714          context and the stamp argument is required anyway which we
715          can't by other means. The AID DO is available anyway but not
716          hex formatted. */
717       char *serial;
718       time_t stamp;
719       char tmp[50];
720
721       if (!app_get_serial_and_stamp (app, &serial, &stamp))
722         {
723           sprintf (tmp, "%lu", (unsigned long)stamp);
724           send_status_info (ctrl, "SERIALNO",
725                             serial, strlen (serial),
726                             tmp, strlen (tmp),
727                             NULL, 0);
728           xfree (serial);
729         }
730       return 0;
731     }
732   if (table[idx].special == -2)
733     {
734       char tmp[50];
735
736       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d", 
737                app->app_local->extcap.get_challenge,
738                app->app_local->extcap.key_import,
739                app->app_local->extcap.change_force_chv,
740                app->app_local->extcap.private_dos);
741       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
742       return 0;
743     }
744
745   relptr = get_one_do (app, table[idx].tag, &value, &valuelen, &rc);
746   if (relptr)
747     {
748       if (table[idx].special == 1)
749         {
750           char numbuf[7*23];
751           
752           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
753             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
754           send_status_info (ctrl, table[idx].name,
755                             numbuf, strlen (numbuf), NULL, 0);
756         }
757       else if (table[idx].special == 2)
758         {
759           char numbuf[50];
760
761           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
762           send_status_info (ctrl, table[idx].name,
763                             numbuf, strlen (numbuf), NULL, 0);
764         }
765       else if (table[idx].special == 3)
766         {
767           if (valuelen >= 60)
768             for (i=0; i < 3; i++)
769               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
770         }
771       else if (table[idx].special == 4)
772         {
773           if (valuelen >= 12)
774             for (i=0; i < 3; i++)
775               send_fprtime_if_not_null (ctrl, table[idx].name, i+1, value+i*4);
776         }
777       else
778         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
779
780       xfree (relptr);
781     }
782   return rc;
783 }
784
785 /* Retrieve the fingerprint from the card inserted in SLOT and write
786    the according hex representation to FPR.  Caller must have provide
787    a buffer at FPR of least 41 bytes.  Returns 0 on success or an
788    error code. */
789 #if GNUPG_MAJOR_VERSION > 1
790 static gpg_error_t
791 retrieve_fpr_from_card (app_t app, int keyno, char *fpr)
792 {
793   gpg_error_t err = 0;
794   void *relptr;
795   unsigned char *value;
796   size_t valuelen;
797   int i;
798
799   assert (keyno >=0 && keyno <= 2);
800
801   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
802   if (relptr && valuelen >= 60)
803     {
804       for (i = 0; i < 20; i++)
805         sprintf (fpr + (i * 2), "%02X", value[(keyno*20)+i]);
806     }
807   else
808     err = gpg_error (GPG_ERR_NOT_FOUND);
809   xfree (relptr);
810   return err;
811 }
812 #endif /*GNUPG_MAJOR_VERSION > 1*/
813
814
815 /* Retrieve the public key material for the RSA key, whose fingerprint
816    is FPR, from gpg output, which can be read through the stream FP.
817    The RSA modulus will be stored at the address of M and MLEN, the
818    public exponent at E and ELEN.  Returns zero on success, an error
819    code on failure.  Caller must release the allocated buffers at M
820    and E if the function returns success.  */
821 #if GNUPG_MAJOR_VERSION > 1
822 static gpg_error_t
823 retrieve_key_material (FILE *fp, const char *hexkeyid,
824                        const unsigned char **m, size_t *mlen,
825                        const unsigned char **e, size_t *elen)
826 {
827   gcry_error_t err = 0;
828   char *line = NULL;    /* read_line() buffer. */
829   size_t line_size = 0; /* Helper for for read_line. */
830   int found_key = 0;    /* Helper to find a matching key. */
831   unsigned char *m_new = NULL;
832   unsigned char *e_new = NULL;
833   size_t m_new_n = 0;
834   size_t e_new_n = 0;
835
836   /* Loop over all records until we have found the subkey
837      corresponsing to the fingerprint. Inm general the first record
838      should be the pub record, but we don't rely on that.  Given that
839      we only need to look at one key, it is sufficient to compare the
840      keyid so that we don't need to look at "fpr" records. */
841   for (;;)
842     {
843       char *p;
844       char *fields[6];
845       int nfields;
846       size_t max_length;
847       gcry_mpi_t mpi;
848       int i;
849
850       max_length = 4096;
851       i = read_line (fp, &line, &line_size, &max_length);
852       if (!i)
853         break; /* EOF. */
854       if (i < 0)
855         {
856           err = gpg_error_from_errno (errno);
857           goto leave; /* Error. */
858         }
859       if (!max_length)
860         {
861           err = gpg_error (GPG_ERR_TRUNCATED);
862           goto leave;  /* Line truncated - we better stop processing.  */
863         }
864
865       /* Parse the line into fields. */
866       for (nfields=0, p=line; p && nfields < DIM (fields); nfields++)
867         {
868           fields[nfields] = p;
869           p = strchr (p, ':');
870           if (p)
871             *(p++) = 0;
872         }
873       if (!nfields)
874         continue; /* No fields at all - skip line.  */
875
876       if (!found_key)
877         {
878           if ( (!strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
879                && nfields > 4 && !strcmp (fields[4], hexkeyid))
880             found_key = 1;
881           continue;
882         }
883       
884       if ( !strcmp (fields[0], "sub") || !strcmp (fields[0], "pub") )
885         break; /* Next key - stop.  */
886
887       if ( strcmp (fields[0], "pkd") )
888         continue; /* Not a key data record.  */
889       i = 0; /* Avoid erroneous compiler warning. */
890       if ( nfields < 4 || (i = atoi (fields[1])) < 0 || i > 1
891            || (!i && m_new) || (i && e_new))
892         {
893           err = gpg_error (GPG_ERR_GENERAL);
894           goto leave; /* Error: Invalid key data record or not an RSA key.  */
895         }
896       
897       err = gcry_mpi_scan (&mpi, GCRYMPI_FMT_HEX, fields[3], 0, NULL);
898       if (err)
899         mpi = NULL;
900       else if (!i)
901         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &m_new, &m_new_n, mpi);
902       else
903         err = gcry_mpi_aprint (GCRYMPI_FMT_STD, &e_new, &e_new_n, mpi);
904       gcry_mpi_release (mpi);
905       if (err)
906         goto leave;
907     }
908   
909   if (m_new && e_new)
910     {
911       *m = m_new;
912       *mlen = m_new_n;
913       m_new = NULL;
914       *e = e_new;
915       *elen = e_new_n;
916       e_new = NULL;
917     }
918   else
919     err = gpg_error (GPG_ERR_GENERAL);
920
921  leave:
922   xfree (m_new);
923   xfree (e_new);
924   xfree (line);
925   return err;
926 }
927 #endif /*GNUPG_MAJOR_VERSION > 1*/
928
929
930 /* Get the public key for KEYNO and store it as an S-expresion with
931    the APP handle.  On error that field gets cleared.  If we already
932    know about the public key we will just return.  Note that this does
933    not mean a key is available; this is soley indicated by the
934    presence of the app->app_local->pk[KEYNO-1].key field.
935
936    Note that GnuPG 1.x does not need this and it would be too time
937    consuming to send it just for the fun of it. However, given that we
938    use the same code in gpg 1.4, we can't use the gcry S-expresion
939    here but need to open encode it. */
940 #if GNUPG_MAJOR_VERSION > 1
941 static gpg_error_t
942 get_public_key (app_t app, int keyno)
943 {
944   gpg_error_t err = 0;
945   unsigned char *buffer;
946   const unsigned char *keydata, *m, *e;
947   size_t buflen, keydatalen, mlen, elen;
948   unsigned char *mbuf = NULL;
949   unsigned char *ebuf = NULL;
950   unsigned char *keybuf = NULL;
951   unsigned char *keybuf_p;
952
953   if (keyno < 1 || keyno > 3)
954     return gpg_error (GPG_ERR_INV_ID);
955   keyno--;
956
957   /* Already cached? */
958   if (app->app_local->pk[keyno].read_done)
959     return 0;
960
961   xfree (app->app_local->pk[keyno].key);
962   app->app_local->pk[keyno].key = NULL;
963   app->app_local->pk[keyno].keylen = 0;
964
965   if (app->card_version > 0x0100)
966     {
967       /* We may simply read the public key out of these cards.  */
968       err = iso7816_read_public_key (app->slot, 
969                                     keyno == 0? "\xB6" :
970                                     keyno == 1? "\xB8" : "\xA4",
971                                     2,  
972                                     &buffer, &buflen);
973       if (err)
974         {
975           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
976           goto leave;
977         }
978
979       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
980       if (!keydata)
981         {
982           err = gpg_error (GPG_ERR_CARD);
983           log_error (_("response does not contain the public key data\n"));
984           goto leave;
985         }
986  
987       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
988       if (!m)
989         {
990           err = gpg_error (GPG_ERR_CARD);
991           log_error (_("response does not contain the RSA modulus\n"));
992           goto leave;
993         }
994       
995
996       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
997       if (!e)
998         {
999           err = gpg_error (GPG_ERR_CARD);
1000           log_error (_("response does not contain the RSA public exponent\n"));
1001           goto leave;
1002         }
1003
1004       /* Prepend numbers with a 0 if needed.  */
1005       if (mlen && (*m & 0x80))
1006         {
1007           mbuf = xtrymalloc ( mlen + 1);
1008           if (!mbuf)
1009             {
1010               err = gpg_error_from_errno (errno);
1011               goto leave;
1012             }
1013           *mbuf = 0;
1014           memcpy (mbuf+1, m, mlen);
1015           mlen++;
1016           m = mbuf;
1017         }
1018       if (elen && (*e & 0x80))
1019         {
1020           ebuf = xtrymalloc ( elen + 1);
1021           if (!ebuf)
1022             {
1023               err = gpg_error_from_errno (errno);
1024               goto leave;
1025             }
1026           *ebuf = 0;
1027           memcpy (ebuf+1, e, elen);
1028           elen++;
1029           e = ebuf;
1030         }
1031
1032     }
1033   else
1034     {
1035       /* Due to a design problem in v1.0 cards we can't get the public
1036          key out of these cards without doing a verify on CHV3.
1037          Clearly that is not an option and thus we try to locate the
1038          key using an external helper.
1039
1040          The helper we use here is gpg itself, which should know about
1041          the key in any case.  */
1042
1043       char fpr[41];
1044       char *hexkeyid;
1045       char *command = NULL;
1046       FILE *fp;
1047       int ret;
1048
1049       buffer = NULL; /* We don't need buffer.  */
1050
1051       err = retrieve_fpr_from_card (app, keyno, fpr);
1052       if (err)
1053         {
1054           log_error ("error while retrieving fpr from card: %s\n",
1055                      gpg_strerror (err));
1056           goto leave;
1057         }
1058       hexkeyid = fpr + 24;
1059
1060       ret = asprintf (&command,
1061                       "gpg --list-keys --with-colons --with-key-data '%s'",
1062                       fpr);
1063       if (ret < 0)
1064         {
1065           err = gpg_error_from_errno (errno);
1066           goto leave;
1067         }
1068
1069       fp = popen (command, "r");
1070       free (command);
1071       if (!fp)
1072         {
1073           err = gpg_error_from_errno (errno);
1074           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1075           goto leave;
1076         }
1077
1078       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1079       fclose (fp);
1080       if (err)
1081         {
1082           log_error ("error while retrieving key material through pipe: %s\n",
1083                      gpg_strerror (err));
1084           goto leave;
1085         }
1086     }
1087
1088   /* Allocate a buffer to construct the S-expression.  */
1089   /* FIXME: We should provide a generalized S-expression creation
1090      mechanism. */
1091   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1092   if (!keybuf)
1093     {
1094       err = gpg_error_from_errno (errno);
1095       goto leave;
1096     }
1097   
1098   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1099   keybuf_p = keybuf + strlen (keybuf);
1100   memcpy (keybuf_p, m, mlen);
1101   keybuf_p += mlen;
1102   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1103   keybuf_p += strlen (keybuf_p);
1104   memcpy (keybuf_p, e, elen);
1105   keybuf_p += elen;
1106   strcpy (keybuf_p, ")))");
1107   keybuf_p += strlen (keybuf_p);
1108   
1109   app->app_local->pk[keyno].key = keybuf;
1110   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1111
1112  leave:
1113   /* Set a flag to indicate that we tried to read the key.  */
1114   app->app_local->pk[keyno].read_done = 1;
1115
1116   xfree (buffer);
1117   xfree (mbuf);
1118   xfree (ebuf);
1119   return 0;
1120 }
1121 #endif /* GNUPG_MAJOR_VERSION > 1 */
1122
1123
1124
1125 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1126    This is used by the LEARN command. */
1127 static gpg_error_t
1128 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1129 {
1130   gpg_error_t err = 0;
1131   /* Note that GnuPG 1.x does not need this and it would be too time
1132      consuming to send it just for the fun of it. */
1133 #if GNUPG_MAJOR_VERSION > 1
1134   unsigned char grip[20];
1135   char gripstr[41];
1136   char idbuf[50];
1137   int i;
1138
1139   err = get_public_key (app, keyno);
1140   if (err)
1141     goto leave;
1142   
1143   assert (keyno >= 1 && keyno <= 3);
1144   if (!app->app_local->pk[keyno-1].key)
1145     goto leave; /* No such key - ignore. */
1146
1147   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1148                                  app->app_local->pk[keyno-1].keylen,
1149                                  grip);
1150   if (err)
1151     goto leave;
1152   
1153   for (i=0; i < 20; i++)
1154     sprintf (gripstr+i*2, "%02X", grip[i]);
1155
1156   sprintf (idbuf, "OPENPGP.%d", keyno);
1157   send_status_info (ctrl, "KEYPAIRINFO", 
1158                     gripstr, 40, 
1159                     idbuf, strlen (idbuf), 
1160                     NULL, (size_t)0);
1161
1162  leave:
1163 #endif /* GNUPG_MAJOR_VERSION > 1 */
1164
1165   return err; 
1166 }
1167
1168
1169 /* Handle the LEARN command for OpenPGP.  */
1170 static gpg_error_t
1171 do_learn_status (app_t app, ctrl_t ctrl)
1172 {
1173   do_getattr (app, ctrl, "EXTCAP");
1174   do_getattr (app, ctrl, "DISP-NAME");
1175   do_getattr (app, ctrl, "DISP-LANG");
1176   do_getattr (app, ctrl, "DISP-SEX");
1177   do_getattr (app, ctrl, "PUBKEY-URL");
1178   do_getattr (app, ctrl, "LOGIN-DATA");
1179   do_getattr (app, ctrl, "KEY-FPR");
1180   if (app->card_version > 0x0100)
1181     do_getattr (app, ctrl, "KEY-TIME");
1182   do_getattr (app, ctrl, "CA-FPR");
1183   do_getattr (app, ctrl, "CHV-STATUS");
1184   do_getattr (app, ctrl, "SIG-COUNTER");
1185   if (app->app_local->extcap.private_dos)
1186     {
1187       do_getattr (app, ctrl, "PRIVATE-DO-1");
1188       do_getattr (app, ctrl, "PRIVATE-DO-2");
1189       if (app->did_chv2)
1190         do_getattr (app, ctrl, "PRIVATE-DO-3");
1191       if (app->did_chv3)
1192         do_getattr (app, ctrl, "PRIVATE-DO-4");
1193     }
1194   send_keypair_info (app, ctrl, 1);
1195   send_keypair_info (app, ctrl, 2);
1196   send_keypair_info (app, ctrl, 3);
1197   return 0;
1198 }
1199
1200
1201 /* Handle the READKEY command for OpenPGP.  On success a canonical
1202    encoded S-expression with the public key will get stored at PK and
1203    its length (for assertions) at PKLEN; the caller must release that
1204    buffer. On error PK and PKLEN are not changed and an error code is
1205    returned.  */
1206 static gpg_error_t
1207 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1208 {
1209 #if GNUPG_MAJOR_VERSION > 1
1210   gpg_error_t err;
1211   int keyno;
1212   unsigned char *buf;
1213
1214   if (!strcmp (keyid, "OPENPGP.1"))
1215     keyno = 1;
1216   else if (!strcmp (keyid, "OPENPGP.2"))
1217     keyno = 2;
1218   else if (!strcmp (keyid, "OPENPGP.3"))
1219     keyno = 3;
1220   else
1221     return gpg_error (GPG_ERR_INV_ID);
1222
1223   err = get_public_key (app, keyno);
1224   if (err)
1225     return err;
1226
1227   buf = app->app_local->pk[keyno-1].key;
1228   if (!buf)
1229     return gpg_error (GPG_ERR_NO_PUBKEY);
1230   *pk = buf;
1231   *pklen = app->app_local->pk[keyno-1].keylen;;
1232   return 0;
1233 #else
1234   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1235 #endif
1236 }
1237
1238
1239
1240 /* Verify CHV2 if required.  Depending on the configuration of the
1241    card CHV1 will also be verified. */
1242 static gpg_error_t
1243 verify_chv2 (app_t app,
1244              gpg_error_t (*pincb)(void*, const char *, char **),
1245              void *pincb_arg)
1246 {
1247   int rc = 0;
1248
1249   if (!app->did_chv2) 
1250     {
1251       char *pinvalue;
1252
1253       rc = pincb (pincb_arg, "PIN", &pinvalue); 
1254       if (rc)
1255         {
1256           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1257           return rc;
1258         }
1259
1260       if (strlen (pinvalue) < 6)
1261         {
1262           log_error (_("PIN for CHV%d is too short;"
1263                        " minimum length is %d\n"), 2, 6);
1264           xfree (pinvalue);
1265           return gpg_error (GPG_ERR_BAD_PIN);
1266         }
1267
1268       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1269       if (rc)
1270         {
1271           log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1272           xfree (pinvalue);
1273           flush_cache_after_error (app);
1274           return rc;
1275         }
1276       app->did_chv2 = 1;
1277
1278       if (!app->did_chv1 && !app->force_chv1)
1279         {
1280           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1281           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1282             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1283           if (rc)
1284             {
1285               log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1286               xfree (pinvalue);
1287               flush_cache_after_error (app);
1288               return rc;
1289             }
1290           app->did_chv1 = 1;
1291         }
1292       xfree (pinvalue);
1293     }
1294   return rc;
1295 }
1296
1297 /* Verify CHV3 if required. */
1298 static gpg_error_t
1299 verify_chv3 (app_t app,
1300              gpg_error_t (*pincb)(void*, const char *, char **),
1301              void *pincb_arg)
1302 {
1303   int rc = 0;
1304
1305 #if GNUPG_MAJOR_VERSION != 1
1306   if (!opt.allow_admin)
1307     {
1308       log_info (_("access to admin commands is not configured\n"));
1309       return gpg_error (GPG_ERR_EACCES);
1310     }
1311 #endif
1312       
1313   if (!app->did_chv3) 
1314     {
1315       char *pinvalue;
1316       void *relptr;
1317       unsigned char *value;
1318       size_t valuelen;
1319
1320       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1321       if (!relptr || valuelen < 7)
1322         {
1323           log_error (_("error retrieving CHV status from card\n"));
1324           xfree (relptr);
1325           return gpg_error (GPG_ERR_CARD);
1326         }
1327       if (value[6] == 0)
1328         {
1329           log_info (_("card is permanently locked!\n"));
1330           xfree (relptr);
1331           return gpg_error (GPG_ERR_BAD_PIN);
1332         }
1333
1334       log_info(_("%d Admin PIN attempts remaining before card"
1335                  " is permanently locked\n"), value[6]);
1336       xfree (relptr);
1337
1338       /* TRANSLATORS: Do not translate the "|A|" prefix but
1339          keep it at the start of the string.  We need this elsewhere
1340          to get some infos on the string. */
1341       rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1342       if (rc)
1343         {
1344           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1345           return rc;
1346         }
1347
1348       if (strlen (pinvalue) < 8)
1349         {
1350           log_error (_("PIN for CHV%d is too short;"
1351                        " minimum length is %d\n"), 3, 8);
1352           xfree (pinvalue);
1353           return gpg_error (GPG_ERR_BAD_PIN);
1354         }
1355
1356       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1357       xfree (pinvalue);
1358       if (rc)
1359         {
1360           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1361           flush_cache_after_error (app);
1362           return rc;
1363         }
1364       app->did_chv3 = 1;
1365     }
1366   return rc;
1367 }
1368
1369
1370 /* Handle the SETATTR operation. All arguments are already basically
1371    checked. */
1372 static gpg_error_t 
1373 do_setattr (app_t app, const char *name,
1374             gpg_error_t (*pincb)(void*, const char *, char **),
1375             void *pincb_arg,
1376             const unsigned char *value, size_t valuelen)
1377 {
1378   gpg_error_t rc;
1379   int idx;
1380   static struct {
1381     const char *name;
1382     int tag;
1383     int need_chv;
1384     int special;
1385   } table[] = {
1386     { "DISP-NAME",    0x005B, 3 },
1387     { "LOGIN-DATA",   0x005E, 3, 2 },
1388     { "DISP-LANG",    0x5F2D, 3 },
1389     { "DISP-SEX",     0x5F35, 3 },
1390     { "PUBKEY-URL",   0x5F50, 3 },
1391     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1392     { "CA-FPR-1",     0x00CA, 3 },
1393     { "CA-FPR-2",     0x00CB, 3 },
1394     { "CA-FPR-3",     0x00CC, 3 },
1395     { "PRIVATE-DO-1", 0x0101, 2 },
1396     { "PRIVATE-DO-2", 0x0102, 3 },
1397     { "PRIVATE-DO-3", 0x0103, 2 },
1398     { "PRIVATE-DO-4", 0x0104, 3 },
1399     { NULL, 0 }
1400   };
1401
1402
1403   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1404     ;
1405   if (!table[idx].name)
1406     return gpg_error (GPG_ERR_INV_NAME); 
1407
1408   switch (table[idx].need_chv)
1409     {
1410     case 2:
1411       rc = verify_chv2 (app, pincb, pincb_arg);
1412       break;
1413     case 3:
1414       rc = verify_chv3 (app, pincb, pincb_arg);
1415       break;
1416     default:
1417       rc = 0;
1418     }
1419   if (rc)
1420     return rc;
1421
1422   /* Flush the cache before writing it, so that the next get operation
1423      will reread the data from the card and thus get synced in case of
1424      errors (e.g. data truncated by the card). */
1425   flush_cache_item (app, table[idx].tag);
1426   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
1427   if (rc)
1428     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1429
1430   if (table[idx].special == 1)
1431     app->force_chv1 = (valuelen && *value == 0);
1432   else if (table[idx].special == 2)
1433     parse_login_data (app);
1434
1435   return rc;
1436 }
1437
1438
1439 /* Handle the PASSWD command. */
1440 static gpg_error_t 
1441 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, int reset_mode,
1442                gpg_error_t (*pincb)(void*, const char *, char **),
1443                void *pincb_arg)
1444 {
1445   int rc = 0;
1446   int chvno = atoi (chvnostr);
1447   char *pinvalue;
1448
1449   if (reset_mode && chvno == 3)
1450     {
1451       rc = gpg_error (GPG_ERR_INV_ID);
1452       goto leave;
1453     }
1454   else if (reset_mode || chvno == 3)
1455     {
1456       /* we always require that the PIN is entered. */
1457       app->did_chv3 = 0;
1458       rc = verify_chv3 (app, pincb, pincb_arg);
1459       if (rc)
1460         goto leave;
1461     }
1462   else if (chvno == 1 || chvno == 2)
1463     {
1464       /* CHV1 and CVH2 should always have the same value, thus we
1465          enforce it here.  */
1466       int save_force = app->force_chv1;
1467
1468       app->force_chv1 = 0;
1469       app->did_chv1 = 0;
1470       app->did_chv2 = 0;
1471       rc = verify_chv2 (app, pincb, pincb_arg);
1472       app->force_chv1 = save_force;
1473       if (rc)
1474         goto leave;
1475     }
1476   else
1477     {
1478       rc = gpg_error (GPG_ERR_INV_ID);
1479       goto leave;
1480     }
1481
1482   if (chvno == 3)
1483     app->did_chv3 = 0;
1484   else
1485     app->did_chv1 = app->did_chv2 = 0;
1486
1487   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1488      keep it at the start of the string.  We need this elsewhere
1489      to get some infos on the string. */
1490   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1491               &pinvalue); 
1492   if (rc)
1493     {
1494       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1495       goto leave;
1496     }
1497
1498   if (reset_mode)
1499     {
1500       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1501                                         pinvalue, strlen (pinvalue));
1502       if (!rc)
1503         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1504                                           pinvalue, strlen (pinvalue));
1505     }
1506   else
1507     {
1508       if (chvno == 1 || chvno == 2)
1509         {
1510           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1511                                               pinvalue, strlen (pinvalue));
1512           if (!rc)
1513             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1514                                                 pinvalue, strlen (pinvalue));
1515         }
1516       else
1517         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1518                                             pinvalue, strlen (pinvalue));
1519     }
1520   xfree (pinvalue);
1521   if (rc)
1522     flush_cache_after_error (app);
1523
1524  leave:
1525   return rc;
1526 }
1527
1528
1529 /* Check whether a key already exists.  KEYIDX is the index of the key
1530    (0..2).  If FORCE is TRUE a diagnositic will be printed but no
1531    error returned if the key already exists. */
1532 static gpg_error_t
1533 does_key_exist (app_t app, int keyidx, int force)
1534 {
1535   const unsigned char *fpr;
1536   unsigned char *buffer;
1537   size_t buflen, n;
1538   int i;
1539
1540   assert (keyidx >=0 && keyidx <= 2);
1541
1542   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1543     {
1544       log_error (_("error reading application data\n"));
1545       return gpg_error (GPG_ERR_GENERAL);
1546     }
1547   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1548   if (!fpr || n < 60)
1549     {
1550       log_error (_("error reading fingerprint DO\n"));
1551       xfree (buffer);
1552       return gpg_error (GPG_ERR_GENERAL);
1553     }
1554   fpr += 20*keyidx;
1555   for (i=0; i < 20 && !fpr[i]; i++)
1556     ;
1557   xfree (buffer);
1558   if (i!=20 && !force)
1559     {
1560       log_error (_("key already exists\n"));
1561       return gpg_error (GPG_ERR_EEXIST);
1562     }
1563   else if (i!=20)
1564     log_info (_("existing key will be replaced\n"));
1565   else
1566     log_info (_("generating new key\n"));
1567   return 0;
1568 }
1569
1570
1571
1572 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
1573    canonical encoded S-expression with the secret key in KEYDATA and
1574    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
1575    usual keyid which for OpenPGP is the string "OPENPGP.n" with
1576    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
1577    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
1578    the pinentry callback.  */
1579 static gpg_error_t
1580 do_writekey (app_t app, ctrl_t ctrl,
1581              const char *keyid, unsigned int flags,
1582              gpg_error_t (*pincb)(void*, const char *, char **),
1583              void *pincb_arg,
1584              const unsigned char *keydata, size_t keydatalen)
1585 {
1586   gpg_error_t err;
1587   int force = (flags & 1);
1588   int keyno;
1589   const unsigned char *buf, *tok;
1590   size_t buflen, toklen;
1591   int depth, last_depth1, last_depth2;
1592   const unsigned char *rsa_n = NULL;
1593   const unsigned char *rsa_e = NULL;
1594   const unsigned char *rsa_p = NULL;
1595   const unsigned char *rsa_q = NULL;
1596   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
1597   unsigned int nbits;
1598   unsigned char *template = NULL;
1599   unsigned char *tp;
1600   size_t template_len;
1601   unsigned char fprbuf[20];
1602   u32 created_at = 0;
1603
1604   if (!strcmp (keyid, "OPENPGP.1"))
1605     keyno = 0;
1606   else if (!strcmp (keyid, "OPENPGP.2"))
1607     keyno = 1;
1608   else if (!strcmp (keyid, "OPENPGP.3"))
1609     keyno = 2;
1610   else
1611     return gpg_error (GPG_ERR_INV_ID);
1612   
1613   err = does_key_exist (app, keyno, force);
1614   if (err)
1615     return err;
1616
1617
1618   /* 
1619      Parse the S-expression
1620    */
1621   buf = keydata;
1622   buflen = keydatalen;
1623   depth = 0;
1624   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1625     goto leave;
1626   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1627     goto leave;
1628   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
1629     {
1630       if (!tok)
1631         ;
1632       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
1633         log_info ("protected-private-key passed to writekey\n");
1634       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
1635         log_info ("shadowed-private-key passed to writekey\n");
1636       err = gpg_error (GPG_ERR_BAD_SECKEY);
1637       goto leave;
1638     }
1639   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1640     goto leave;
1641   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1642     goto leave;
1643   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
1644     {
1645       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
1646       goto leave;
1647     }
1648   last_depth1 = depth;
1649   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1650          && depth && depth >= last_depth1)
1651     {
1652       if (tok)
1653         {
1654           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1655           goto leave;
1656         }
1657       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1658         goto leave;
1659       if (tok && toklen == 1)
1660         {
1661           const unsigned char **mpi;
1662           size_t *mpi_len;
1663
1664           switch (*tok)
1665             {
1666             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
1667             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
1668             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
1669             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
1670             default: mpi = NULL;  mpi_len = NULL; break;
1671             }
1672           if (mpi && *mpi)
1673             {
1674               err = gpg_error (GPG_ERR_DUP_VALUE);
1675               goto leave;
1676             }
1677           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1678             goto leave;
1679           if (tok && mpi)
1680             {
1681               /* Strip off leading zero bytes and save. */
1682               for (;toklen && !*tok; toklen--, tok++)
1683                 ;
1684               *mpi = tok;
1685               *mpi_len = toklen;
1686             }
1687         }
1688       /* Skip until end of list. */
1689       last_depth2 = depth;
1690       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1691              && depth && depth >= last_depth2)
1692         ;
1693       if (err)
1694         goto leave;
1695     }
1696   /* Parse other attributes. */
1697   last_depth1 = depth;
1698   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1699          && depth && depth >= last_depth1)
1700     {
1701       if (tok)
1702         {
1703           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1704           goto leave;
1705         }
1706       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1707         goto leave;
1708       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
1709         {
1710           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
1711             goto leave;
1712           if (tok)
1713             {
1714               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
1715                    tok++, toklen--)
1716                 created_at = created_at*10 + (*tok - '0');
1717             }
1718         }
1719       /* Skip until end of list. */
1720       last_depth2 = depth;
1721       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1722              && depth && depth >= last_depth2)
1723         ;
1724       if (err)
1725         goto leave;
1726     }
1727
1728
1729   /* Check that we have all parameters and that they match the card
1730      description. */
1731   if (!created_at)
1732     {
1733       log_error (_("creation timestamp missing\n"));
1734       err = gpg_error (GPG_ERR_INV_VALUE);
1735       goto leave;
1736     }
1737   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
1738   if (nbits != 1024)
1739     {
1740       log_error (_("RSA modulus missing or not of size %d bits\n"), 1024);
1741       err = gpg_error (GPG_ERR_BAD_SECKEY);
1742       goto leave;
1743     }
1744   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
1745   if (nbits < 2 || nbits > 32)
1746     {
1747       log_error (_("RSA public exponent missing or larger than %d bits\n"),
1748                  32);
1749       err = gpg_error (GPG_ERR_BAD_SECKEY);
1750       goto leave;
1751     }
1752   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
1753   if (nbits != 512)
1754     {
1755       log_error (_("RSA prime %s missing or not of size %d bits\n"), "P", 512);
1756       err = gpg_error (GPG_ERR_BAD_SECKEY);
1757       goto leave;
1758     }
1759   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
1760   if (nbits != 512)
1761     {
1762       log_error (_("RSA prime %s missing or not of size %d bits\n"), "Q", 512);
1763       err = gpg_error (GPG_ERR_BAD_SECKEY);
1764       goto leave;
1765     }
1766   
1767
1768   /* Build the private key template as described in section 4.3.3.6 of
1769      the OpenPGP card specs:
1770          0xC0   <length> public exponent
1771          0xC1   <length> prime p 
1772          0xC2   <length> prime q 
1773   */
1774   assert (rsa_e_len <= 4);
1775   template_len = (1 + 1 + 4
1776                   + 1 + 1 + rsa_p_len
1777                   + 1 + 1 + rsa_q_len);
1778   template = tp = xtrymalloc_secure (template_len);
1779   if (!template)
1780     {
1781       err = gpg_error_from_errno (errno);
1782       goto leave;
1783     }
1784   *tp++ = 0xC0;
1785   *tp++ = 4;
1786   memcpy (tp, rsa_e, rsa_e_len);
1787   if (rsa_e_len < 4)
1788     {
1789       /* Right justify E. */
1790       memmove (tp+4-rsa_e_len, tp, rsa_e_len);
1791       memset (tp, 0, 4-rsa_e_len);
1792     }                 
1793   tp += 4;
1794
1795   *tp++ = 0xC1;
1796   *tp++ = rsa_p_len;
1797   memcpy (tp, rsa_p, rsa_p_len);
1798   tp += rsa_p_len;
1799
1800   *tp++ = 0xC2;
1801   *tp++ = rsa_q_len;
1802   memcpy (tp, rsa_q, rsa_q_len);
1803   tp += rsa_q_len;
1804
1805   assert (tp - template == template_len);
1806
1807
1808   /* Obviously we need to remove the cached public key.  */
1809   xfree (app->app_local->pk[keyno].key);
1810   app->app_local->pk[keyno].key = NULL;
1811   app->app_local->pk[keyno].keylen = 0;
1812   app->app_local->pk[keyno].read_done = 0;
1813
1814   /* Prepare for storing the key.  */
1815   err = verify_chv3 (app, pincb, pincb_arg);
1816   if (err)
1817     goto leave;
1818
1819   /* Store the key. */
1820   err = iso7816_put_data (app->slot,
1821                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1822                          template, template_len);
1823   if (err)
1824     {
1825       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
1826       goto leave;
1827     }
1828  
1829   err = store_fpr (app->slot, keyno, created_at,
1830                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
1831                   fprbuf, app->card_version);
1832   if (err)
1833     goto leave;
1834
1835
1836  leave:
1837   xfree (template);
1838   return err;
1839 }
1840
1841
1842 /* Handle the GENKEY command. */
1843 static gpg_error_t 
1844 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
1845           gpg_error_t (*pincb)(void*, const char *, char **),
1846           void *pincb_arg)
1847 {
1848   int rc;
1849   char numbuf[30];
1850   unsigned char fprbuf[20];
1851   const unsigned char *keydata, *m, *e;
1852   unsigned char *buffer = NULL;
1853   size_t buflen, keydatalen, mlen, elen;
1854   time_t created_at;
1855   int keyno = atoi (keynostr);
1856   int force = (flags & 1);
1857   time_t start_at;
1858
1859   if (keyno < 1 || keyno > 3)
1860     return gpg_error (GPG_ERR_INV_ID);
1861   keyno--;
1862
1863   /* We flush the cache to increase the traffic before a key
1864      generation.  This _might_ help a card to gather more entropy. */
1865   flush_cache (app);
1866
1867   /* Obviously we need to remove the cached public key.  */
1868   xfree (app->app_local->pk[keyno].key);
1869   app->app_local->pk[keyno].key = NULL;
1870   app->app_local->pk[keyno].keylen = 0;
1871   app->app_local->pk[keyno].read_done = 0;
1872
1873   /* Check whether a key already exists.  */
1874   rc = does_key_exist (app, keyno, force);
1875   if (rc)
1876     return rc;
1877
1878   /* Prepare for key generation by verifying the ADmin PIN.  */
1879   rc = verify_chv3 (app, pincb, pincb_arg);
1880   if (rc)
1881     goto leave;
1882    
1883 #if 1
1884   log_info (_("please wait while key is being generated ...\n"));
1885   start_at = time (NULL);
1886   rc = iso7816_generate_keypair 
1887 #else
1888 #warning key generation temporary replaced by reading an existing key.
1889   rc = iso7816_read_public_key
1890 #endif
1891                               (app->slot, 
1892                                  keyno == 0? "\xB6" :
1893                                  keyno == 1? "\xB8" : "\xA4",
1894                                  2,
1895                                  &buffer, &buflen);
1896   if (rc)
1897     {
1898       rc = gpg_error (GPG_ERR_CARD);
1899       log_error (_("generating key failed\n"));
1900       goto leave;
1901     }
1902   log_info (_("key generation completed (%d seconds)\n"),
1903             (int)(time (NULL) - start_at));
1904   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1905   if (!keydata)
1906     {
1907       rc = gpg_error (GPG_ERR_CARD);
1908       log_error (_("response does not contain the public key data\n"));
1909       goto leave;
1910     }
1911  
1912   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1913   if (!m)
1914     {
1915       rc = gpg_error (GPG_ERR_CARD);
1916       log_error (_("response does not contain the RSA modulus\n"));
1917       goto leave;
1918     }
1919 /*    log_printhex ("RSA n:", m, mlen); */
1920   send_key_data (ctrl, "n", m, mlen);
1921
1922   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1923   if (!e)
1924     {
1925       rc = gpg_error (GPG_ERR_CARD);
1926       log_error (_("response does not contain the RSA public exponent\n"));
1927       goto leave;
1928     }
1929 /*    log_printhex ("RSA e:", e, elen); */
1930   send_key_data (ctrl, "e", e, elen);
1931
1932   created_at = gnupg_get_time ();
1933   sprintf (numbuf, "%lu", (unsigned long)created_at);
1934   send_status_info (ctrl, "KEY-CREATED-AT",
1935                     numbuf, (size_t)strlen(numbuf), NULL, 0);
1936
1937   rc = store_fpr (app->slot, keyno, (u32)created_at,
1938                   m, mlen, e, elen, fprbuf, app->card_version);
1939   if (rc)
1940     goto leave;
1941   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1942
1943
1944  leave:
1945   xfree (buffer);
1946   return rc;
1947 }
1948
1949
1950 static unsigned long
1951 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
1952 {
1953   unsigned long ul;
1954
1955   if (valuelen == 3 )
1956     ul = (value[0] << 16) | (value[1] << 8) | value[2];
1957   else
1958     {
1959       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
1960       ul = 0;
1961     }
1962   return ul;
1963 }
1964
1965 static unsigned long
1966 get_sig_counter (app_t app)
1967 {
1968   void *relptr;
1969   unsigned char *value;
1970   size_t valuelen;
1971   unsigned long ul;
1972
1973   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
1974   if (!relptr)
1975     return 0;
1976   ul = convert_sig_counter_value (value, valuelen);
1977   xfree (relptr);
1978   return ul;
1979 }
1980
1981 static gpg_error_t
1982 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
1983 {
1984   const unsigned char *fpr;
1985   unsigned char *buffer;
1986   size_t buflen, n;
1987   int rc, i;
1988   
1989   assert (keyno >= 1 && keyno <= 3);
1990
1991   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
1992   if (rc)
1993     {
1994       log_error (_("error reading application data\n"));
1995       return gpg_error (GPG_ERR_GENERAL);
1996     }
1997   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1998   if (!fpr || n != 60)
1999     {
2000       xfree (buffer);
2001       log_error (_("error reading fingerprint DO\n"));
2002       return gpg_error (GPG_ERR_GENERAL);
2003     }
2004   fpr += (keyno-1)*20;
2005   for (i=0; i < 20; i++)
2006     if (sha1fpr[i] != fpr[i])
2007       {
2008         xfree (buffer);
2009         return gpg_error (GPG_ERR_WRONG_SECKEY);
2010       }
2011   xfree (buffer);
2012   return 0;
2013 }
2014
2015
2016   /* If a fingerprint has been specified check it against the one on
2017      the card.  This is allows for a meaningful error message in case
2018      the key on the card has been replaced but the shadow information
2019      known to gpg was not updated.  If there is no fingerprint we
2020      assume that this is okay. */
2021 static gpg_error_t
2022 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2023 {
2024   unsigned char tmp[20];
2025   const char *s;
2026   int n;
2027
2028   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2029     ;
2030   if (n != 40)
2031     return gpg_error (GPG_ERR_INV_ID);
2032   else if (!*s)
2033     ; /* okay */
2034   else
2035     return gpg_error (GPG_ERR_INV_ID);
2036
2037   for (s=fpr, n=0; n < 20; s += 2, n++)
2038         tmp[n] = xtoi_2 (s);
2039   return compare_fingerprint (app, keyno, tmp);
2040 }
2041
2042
2043
2044 /* Compute a digital signature on INDATA which is expected to be the
2045    raw message digest. For this application the KEYIDSTR consists of
2046    the serialnumber and the fingerprint delimited by a slash.
2047
2048    Note that this fucntion may return the error code
2049    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2050    not match the one required for the requested action (e.g. the
2051    serial number does not match). */
2052 static gpg_error_t 
2053 do_sign (app_t app, const char *keyidstr, int hashalgo,
2054          gpg_error_t (*pincb)(void*, const char *, char **),
2055          void *pincb_arg,
2056          const void *indata, size_t indatalen,
2057          unsigned char **outdata, size_t *outdatalen )
2058 {
2059   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
2060   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2061     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
2062   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2063   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2064     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
2065   int rc;
2066   unsigned char data[35];
2067   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2068   const char *s;
2069   int n;
2070   const char *fpr = NULL;
2071   unsigned long sigcount;
2072
2073   if (!keyidstr || !*keyidstr)
2074     return gpg_error (GPG_ERR_INV_VALUE);
2075   if (indatalen == 20)
2076     ;
2077   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_SHA1
2078            && !memcmp (indata, sha1_prefix, 15))
2079     ;
2080   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_RMD160
2081            && !memcmp (indata, rmd160_prefix, 15))
2082     ;
2083   else
2084     {
2085       log_error(_("card does not support digest algorithm %s\n"),
2086                 digest_algo_to_string(hashalgo));
2087       return gpg_error (GPG_ERR_INV_VALUE);
2088     }
2089
2090   /* Check whether an OpenPGP card of any version has been requested. */
2091   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2092     return gpg_error (GPG_ERR_INV_ID);
2093   
2094   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2095     ;
2096   if (n != 32)
2097     return gpg_error (GPG_ERR_INV_ID);
2098   else if (!*s)
2099     ; /* no fingerprint given: we allow this for now. */
2100   else if (*s == '/')
2101     fpr = s + 1; 
2102   else
2103     return gpg_error (GPG_ERR_INV_ID);
2104
2105   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2106     tmp_sn[n] = xtoi_2 (s);
2107
2108   if (app->serialnolen != 16)
2109     return gpg_error (GPG_ERR_INV_CARD);
2110   if (memcmp (app->serialno, tmp_sn, 16))
2111     return gpg_error (GPG_ERR_WRONG_CARD);
2112
2113   /* If a fingerprint has been specified check it against the one on
2114      the card.  This is allows for a meaningful error message in case
2115      the key on the card has been replaced but the shadow information
2116      known to gpg was not updated.  If there is no fingerprint, gpg
2117      will detect a bogus signature anyway due to the
2118      verify-after-signing feature. */
2119   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2120   if (rc)
2121     return rc;
2122
2123   if (hashalgo == GCRY_MD_SHA1)
2124     memcpy (data, sha1_prefix, 15);
2125   else if (hashalgo == GCRY_MD_RMD160)
2126     memcpy (data, rmd160_prefix, 15);
2127   else 
2128     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2129   memcpy (data+15, indata, indatalen);
2130
2131   sigcount = get_sig_counter (app);
2132   log_info (_("signatures created so far: %lu\n"), sigcount);
2133
2134   if (!app->did_chv1 || app->force_chv1 ) 
2135     {
2136       char *pinvalue;
2137
2138       {
2139         char *prompt;
2140 #define PROMPTSTRING  _("||Please enter the PIN%%0A[sigs done: %lu]")
2141
2142         prompt = malloc (strlen (PROMPTSTRING) + 50);
2143         if (!prompt)
2144           return gpg_error_from_errno (errno);
2145         sprintf (prompt, PROMPTSTRING, sigcount);
2146         rc = pincb (pincb_arg, prompt, &pinvalue); 
2147         free (prompt);
2148 #undef PROMPTSTRING
2149       }
2150       if (rc)
2151         {
2152           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
2153           return rc;
2154         }
2155
2156       if (strlen (pinvalue) < 6)
2157         {
2158           log_error (_("PIN for CHV%d is too short;"
2159                        " minimum length is %d\n"), 1, 6);
2160           xfree (pinvalue);
2161           return gpg_error (GPG_ERR_BAD_PIN);
2162         }
2163
2164       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
2165       if (rc)
2166         {
2167           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2168           xfree (pinvalue);
2169           flush_cache_after_error (app);
2170           return rc;
2171         }
2172       app->did_chv1 = 1;
2173       if (!app->did_chv2)
2174         {
2175           /* We should also verify CHV2. */
2176           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2177           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2178             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2179           if (rc)
2180             {
2181               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2182               xfree (pinvalue);
2183               flush_cache_after_error (app);
2184               return rc;
2185             }
2186           app->did_chv2 = 1;
2187         }
2188       xfree (pinvalue);
2189     }
2190
2191   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
2192   return rc;
2193 }
2194
2195 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2196    on INDATA which is expected to be the raw message digest. For this
2197    application the KEYIDSTR consists of the serialnumber and the
2198    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2199    be given.
2200
2201    Note that this fucntion may return the error code
2202    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2203    not match the one required for the requested action (e.g. the
2204    serial number does not match). */
2205 static gpg_error_t 
2206 do_auth (app_t app, const char *keyidstr,
2207          gpg_error_t (*pincb)(void*, const char *, char **),
2208          void *pincb_arg,
2209          const void *indata, size_t indatalen,
2210          unsigned char **outdata, size_t *outdatalen )
2211 {
2212   int rc;
2213   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2214   const char *s;
2215   int n;
2216   const char *fpr = NULL;
2217
2218   if (!keyidstr || !*keyidstr)
2219     return gpg_error (GPG_ERR_INV_VALUE);
2220   if (indatalen > 50) /* For a 1024 bit key. */
2221     return gpg_error (GPG_ERR_INV_VALUE);
2222
2223   /* Check whether an OpenPGP card of any version has been requested. */
2224   if (!strcmp (keyidstr, "OPENPGP.3"))
2225     ;
2226   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2227     return gpg_error (GPG_ERR_INV_ID);
2228   else
2229     {
2230       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2231         ;
2232       if (n != 32)
2233         return gpg_error (GPG_ERR_INV_ID);
2234       else if (!*s)
2235         ; /* no fingerprint given: we allow this for now. */
2236       else if (*s == '/')
2237         fpr = s + 1; 
2238       else
2239         return gpg_error (GPG_ERR_INV_ID);
2240
2241       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2242         tmp_sn[n] = xtoi_2 (s);
2243       
2244       if (app->serialnolen != 16)
2245         return gpg_error (GPG_ERR_INV_CARD);
2246       if (memcmp (app->serialno, tmp_sn, 16))
2247         return gpg_error (GPG_ERR_WRONG_CARD);
2248     }
2249
2250   /* If a fingerprint has been specified check it against the one on
2251      the card.  This is allows for a meaningful error message in case
2252      the key on the card has been replaced but the shadow information
2253      known to gpg was not updated.  If there is no fingerprint, gpg
2254      will detect a bogus signature anyway due to the
2255      verify-after-signing feature. */
2256   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2257   if (rc)
2258     return rc;
2259
2260   rc = verify_chv2 (app, pincb, pincb_arg);
2261   if (!rc)
2262     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2263                                         outdata, outdatalen);
2264   return rc;
2265 }
2266
2267
2268 static gpg_error_t 
2269 do_decipher (app_t app, const char *keyidstr,
2270              gpg_error_t (*pincb)(void*, const char *, char **),
2271              void *pincb_arg,
2272              const void *indata, size_t indatalen,
2273              unsigned char **outdata, size_t *outdatalen )
2274 {
2275   int rc;
2276   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2277   const char *s;
2278   int n;
2279   const char *fpr = NULL;
2280
2281   if (!keyidstr || !*keyidstr || !indatalen)
2282     return gpg_error (GPG_ERR_INV_VALUE);
2283
2284   /* Check whether an OpenPGP card of any version has been requested. */
2285   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2286     return gpg_error (GPG_ERR_INV_ID);
2287   
2288   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2289     ;
2290   if (n != 32)
2291     return gpg_error (GPG_ERR_INV_ID);
2292   else if (!*s)
2293     ; /* no fingerprint given: we allow this for now. */
2294   else if (*s == '/')
2295     fpr = s + 1; 
2296   else
2297     return gpg_error (GPG_ERR_INV_ID);
2298
2299   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2300     tmp_sn[n] = xtoi_2 (s);
2301
2302   if (app->serialnolen != 16)
2303     return gpg_error (GPG_ERR_INV_CARD);
2304   if (memcmp (app->serialno, tmp_sn, 16))
2305     return gpg_error (GPG_ERR_WRONG_CARD);
2306
2307   /* If a fingerprint has been specified check it against the one on
2308      the card.  This is allows for a meaningful error message in case
2309      the key on the card has been replaced but the shadow information
2310      known to gpg was not updated.  If there is no fingerprint, the
2311      decryption will won't produce the right plaintext anyway. */
2312   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
2313   if (rc)
2314     return rc;
2315
2316   rc = verify_chv2 (app, pincb, pincb_arg);
2317   if (!rc)
2318     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
2319                            outdata, outdatalen);
2320   return rc;
2321 }
2322
2323
2324 /* Perform a simple verify operation for CHV1 and CHV2, so that
2325    further operations won't ask for CHV2 and it is possible to do a
2326    cheap check on the PIN: If there is something wrong with the PIN
2327    entry system, only the regular CHV will get blocked and not the
2328    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
2329    optional fingerprint part will be ignored.
2330
2331    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
2332    the "[CHV3]" being a literal string:  The Admin Pin is checked if
2333    and only if the retry counter is still at 3. */
2334 static gpg_error_t 
2335 do_check_pin (app_t app, const char *keyidstr,
2336               gpg_error_t (*pincb)(void*, const char *, char **),
2337               void *pincb_arg)
2338 {
2339   unsigned char tmp_sn[20]; 
2340   const char *s;
2341   int n;
2342   int admin_pin = 0;
2343
2344   if (!keyidstr || !*keyidstr)
2345     return gpg_error (GPG_ERR_INV_VALUE);
2346
2347   /* Check whether an OpenPGP card of any version has been requested. */
2348   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2349     return gpg_error (GPG_ERR_INV_ID);
2350   
2351   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2352     ;
2353   if (n != 32)
2354     return gpg_error (GPG_ERR_INV_ID);
2355   else if (!*s)
2356     ; /* No fingerprint given: we allow this for now. */
2357   else if (*s == '/')
2358     ; /* We ignore a fingerprint. */
2359   else if (!strcmp (s, "[CHV3]") )
2360     admin_pin = 1;
2361   else
2362     return gpg_error (GPG_ERR_INV_ID);
2363
2364   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2365     tmp_sn[n] = xtoi_2 (s);
2366
2367   if (app->serialnolen != 16)
2368     return gpg_error (GPG_ERR_INV_CARD);
2369   if (memcmp (app->serialno, tmp_sn, 16))
2370     return gpg_error (GPG_ERR_WRONG_CARD);
2371
2372   /* Yes, there is a race conditions: The user might pull the card
2373      right here and we won't notice that.  However this is not a
2374      problem and the check above is merely for a graceful failure
2375      between operations. */
2376
2377   if (admin_pin)
2378     {
2379       void *relptr;
2380       unsigned char *value;
2381       size_t valuelen;
2382       int count;
2383       
2384       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2385       if (!relptr || valuelen < 7)
2386         {
2387           log_error (_("error retrieving CHV status from card\n"));
2388           xfree (relptr);
2389           return gpg_error (GPG_ERR_CARD);
2390         }
2391       count = value[6];
2392       xfree (relptr);
2393
2394       if (!count)
2395         {
2396           log_info (_("card is permanently locked!\n"));
2397           return gpg_error (GPG_ERR_BAD_PIN);
2398         }
2399       else if (value[6] < 3)
2400         {
2401           log_info (_("verification of Admin PIN is currently prohibited "
2402                       "through this command\n"));
2403           return gpg_error (GPG_ERR_GENERAL);
2404         }
2405
2406       app->did_chv3 = 0; /* Force verification.  */
2407       return verify_chv3 (app, pincb, pincb_arg);
2408     }
2409   else
2410     return verify_chv2 (app, pincb, pincb_arg);
2411 }
2412
2413
2414
2415
2416 /* Select the OpenPGP application on the card in SLOT.  This function
2417    must be used before any other OpenPGP application functions. */
2418 gpg_error_t
2419 app_select_openpgp (app_t app)
2420 {
2421   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
2422   int slot = app->slot;
2423   int rc;
2424   unsigned char *buffer;
2425   size_t buflen;
2426   void *relptr;
2427   
2428   rc = iso7816_select_application (slot, aid, sizeof aid);
2429   if (!rc)
2430     {
2431       unsigned int manufacturer;
2432
2433       app->apptype = "OPENPGP";
2434
2435       app->did_chv1 = 0;
2436       app->did_chv2 = 0;
2437       app->did_chv3 = 0;
2438       app->app_local = NULL;
2439
2440       /* The OpenPGP card returns the serial number as part of the
2441          AID; because we prefer to use OpenPGP serial numbers, we
2442          replace a possibly already set one from a EF.GDO with this
2443          one.  Note, that for current OpenPGP cards, no EF.GDO exists
2444          and thus it won't matter at all. */
2445       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
2446       if (rc)
2447         goto leave;
2448       if (opt.verbose)
2449         {
2450           log_info ("AID: ");
2451           log_printhex ("", buffer, buflen);
2452         }
2453
2454       app->card_version = buffer[6] << 8;
2455       app->card_version |= buffer[7];
2456       manufacturer = (buffer[8]<<8 | buffer[9]);
2457
2458       xfree (app->serialno);
2459       app->serialno = buffer;
2460       app->serialnolen = buflen;
2461       buffer = NULL;
2462       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2463       if (!app->app_local)
2464         {
2465           rc = gpg_error (gpg_err_code_from_errno (errno));
2466           goto leave;
2467         }
2468
2469       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
2470       if (!relptr)
2471         {
2472           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2473                      "CHV Status Bytes");
2474           goto leave;
2475         }
2476       app->force_chv1 = (buflen && *buffer == 0);
2477       xfree (relptr);
2478
2479       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
2480       if (!relptr)
2481         {
2482           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2483                      "Extended Capability Flags" );
2484           goto leave;
2485         }
2486       if (buflen)
2487         {
2488           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
2489           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
2490           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
2491           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
2492         }
2493       xfree (relptr);
2494       
2495       /* Some of the first cards accidently don't set the
2496          CHANGE_FORCE_CHV bit but allow it anyway. */
2497       if (app->card_version <= 0x0100 && manufacturer == 1)
2498         app->app_local->extcap.change_force_chv = 1;
2499
2500       parse_login_data (app);
2501
2502       if (opt.verbose > 1)
2503         dump_all_do (slot);
2504
2505       app->fnc.deinit = do_deinit;
2506       app->fnc.learn_status = do_learn_status;
2507       app->fnc.readkey = do_readkey;
2508       app->fnc.getattr = do_getattr;
2509       app->fnc.setattr = do_setattr;
2510       app->fnc.writekey = do_writekey;
2511       app->fnc.genkey = do_genkey;
2512       app->fnc.sign = do_sign;
2513       app->fnc.auth = do_auth;
2514       app->fnc.decipher = do_decipher;
2515       app->fnc.change_pin = do_change_pin;
2516       app->fnc.check_pin = do_check_pin;
2517    }
2518
2519 leave:
2520   if (rc)
2521     do_deinit (app);
2522   return rc;
2523 }
2524
2525
2526