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