1165ec683a487254e8f18284f9023787994abfa7
[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 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   unsigned char *keybuf = NULL;
952   unsigned 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   if (app->card_version > 0x0100)
967     {
968       /* We may simply read the public key out of these cards.  */
969       err = iso7816_read_public_key (app->slot, 
970                                     keyno == 0? "\xB6" :
971                                     keyno == 1? "\xB8" : "\xA4",
972                                     2,  
973                                     &buffer, &buflen);
974       if (err)
975         {
976           log_error (_("reading public key failed: %s\n"), gpg_strerror (err));
977           goto leave;
978         }
979
980       keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
981       if (!keydata)
982         {
983           err = gpg_error (GPG_ERR_CARD);
984           log_error (_("response does not contain the public key data\n"));
985           goto leave;
986         }
987  
988       m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
989       if (!m)
990         {
991           err = gpg_error (GPG_ERR_CARD);
992           log_error (_("response does not contain the RSA modulus\n"));
993           goto leave;
994         }
995       
996
997       e = find_tlv (keydata, keydatalen, 0x0082, &elen);
998       if (!e)
999         {
1000           err = gpg_error (GPG_ERR_CARD);
1001           log_error (_("response does not contain the RSA public exponent\n"));
1002           goto leave;
1003         }
1004
1005       /* Prepend numbers with a 0 if needed.  */
1006       if (mlen && (*m & 0x80))
1007         {
1008           mbuf = xtrymalloc ( mlen + 1);
1009           if (!mbuf)
1010             {
1011               err = gpg_error_from_errno (errno);
1012               goto leave;
1013             }
1014           *mbuf = 0;
1015           memcpy (mbuf+1, m, mlen);
1016           mlen++;
1017           m = mbuf;
1018         }
1019       if (elen && (*e & 0x80))
1020         {
1021           ebuf = xtrymalloc ( elen + 1);
1022           if (!ebuf)
1023             {
1024               err = gpg_error_from_errno (errno);
1025               goto leave;
1026             }
1027           *ebuf = 0;
1028           memcpy (ebuf+1, e, elen);
1029           elen++;
1030           e = ebuf;
1031         }
1032
1033     }
1034   else
1035     {
1036       /* Due to a design problem in v1.0 cards we can't get the public
1037          key out of these cards without doing a verify on CHV3.
1038          Clearly that is not an option and thus we try to locate the
1039          key using an external helper.
1040
1041          The helper we use here is gpg itself, which should know about
1042          the key in any case.  */
1043
1044       char fpr[41];
1045       char *hexkeyid;
1046       char *command = NULL;
1047       FILE *fp;
1048       int ret;
1049
1050       buffer = NULL; /* We don't need buffer.  */
1051
1052       err = retrieve_fpr_from_card (app, keyno, fpr);
1053       if (err)
1054         {
1055           log_error ("error while retrieving fpr from card: %s\n",
1056                      gpg_strerror (err));
1057           goto leave;
1058         }
1059       hexkeyid = fpr + 24;
1060
1061       ret = asprintf (&command,
1062                       "gpg --list-keys --with-colons --with-key-data '%s'",
1063                       fpr);
1064       if (ret < 0)
1065         {
1066           err = gpg_error_from_errno (errno);
1067           goto leave;
1068         }
1069
1070       fp = popen (command, "r");
1071       free (command);
1072       if (!fp)
1073         {
1074           err = gpg_error_from_errno (errno);
1075           log_error ("running gpg failed: %s\n", gpg_strerror (err));
1076           goto leave;
1077         }
1078
1079       err = retrieve_key_material (fp, hexkeyid, &m, &mlen, &e, &elen);
1080       fclose (fp);
1081       if (err)
1082         {
1083           log_error ("error while retrieving key material through pipe: %s\n",
1084                      gpg_strerror (err));
1085           goto leave;
1086         }
1087     }
1088
1089   /* Allocate a buffer to construct the S-expression.  */
1090   /* FIXME: We should provide a generalized S-expression creation
1091      mechanism. */
1092   keybuf = xtrymalloc (50 + 2*35 + mlen + elen + 1);
1093   if (!keybuf)
1094     {
1095       err = gpg_error_from_errno (errno);
1096       goto leave;
1097     }
1098   
1099   sprintf (keybuf, "(10:public-key(3:rsa(1:n%u:", (unsigned int) mlen);
1100   keybuf_p = keybuf + strlen (keybuf);
1101   memcpy (keybuf_p, m, mlen);
1102   keybuf_p += mlen;
1103   sprintf (keybuf_p, ")(1:e%u:", (unsigned int)elen);
1104   keybuf_p += strlen (keybuf_p);
1105   memcpy (keybuf_p, e, elen);
1106   keybuf_p += elen;
1107   strcpy (keybuf_p, ")))");
1108   keybuf_p += strlen (keybuf_p);
1109   
1110   app->app_local->pk[keyno].key = keybuf;
1111   app->app_local->pk[keyno].keylen = (keybuf_p - keybuf);
1112
1113  leave:
1114   /* Set a flag to indicate that we tried to read the key.  */
1115   app->app_local->pk[keyno].read_done = 1;
1116
1117   xfree (buffer);
1118   xfree (mbuf);
1119   xfree (ebuf);
1120   return 0;
1121 }
1122 #endif /* GNUPG_MAJOR_VERSION > 1 */
1123
1124
1125
1126 /* Send the KEYPAIRINFO back. KEYNO needs to be in the range [1,3].
1127    This is used by the LEARN command. */
1128 static gpg_error_t
1129 send_keypair_info (app_t app, ctrl_t ctrl, int keyno)
1130 {
1131   gpg_error_t err = 0;
1132   /* Note that GnuPG 1.x does not need this and it would be too time
1133      consuming to send it just for the fun of it. */
1134 #if GNUPG_MAJOR_VERSION > 1
1135   unsigned char grip[20];
1136   char gripstr[41];
1137   char idbuf[50];
1138   int i;
1139
1140   err = get_public_key (app, keyno);
1141   if (err)
1142     goto leave;
1143   
1144   assert (keyno >= 1 && keyno <= 3);
1145   if (!app->app_local->pk[keyno-1].key)
1146     goto leave; /* No such key - ignore. */
1147
1148   err = keygrip_from_canon_sexp (app->app_local->pk[keyno-1].key,
1149                                  app->app_local->pk[keyno-1].keylen,
1150                                  grip);
1151   if (err)
1152     goto leave;
1153   
1154   for (i=0; i < 20; i++)
1155     sprintf (gripstr+i*2, "%02X", grip[i]);
1156
1157   sprintf (idbuf, "OPENPGP.%d", keyno);
1158   send_status_info (ctrl, "KEYPAIRINFO", 
1159                     gripstr, 40, 
1160                     idbuf, strlen (idbuf), 
1161                     NULL, (size_t)0);
1162
1163  leave:
1164 #endif /* GNUPG_MAJOR_VERSION > 1 */
1165
1166   return err; 
1167 }
1168
1169
1170 /* Handle the LEARN command for OpenPGP.  */
1171 static gpg_error_t
1172 do_learn_status (app_t app, ctrl_t ctrl)
1173 {
1174   do_getattr (app, ctrl, "EXTCAP");
1175   do_getattr (app, ctrl, "DISP-NAME");
1176   do_getattr (app, ctrl, "DISP-LANG");
1177   do_getattr (app, ctrl, "DISP-SEX");
1178   do_getattr (app, ctrl, "PUBKEY-URL");
1179   do_getattr (app, ctrl, "LOGIN-DATA");
1180   do_getattr (app, ctrl, "KEY-FPR");
1181   if (app->card_version > 0x0100)
1182     do_getattr (app, ctrl, "KEY-TIME");
1183   do_getattr (app, ctrl, "CA-FPR");
1184   do_getattr (app, ctrl, "CHV-STATUS");
1185   do_getattr (app, ctrl, "SIG-COUNTER");
1186   if (app->app_local->extcap.private_dos)
1187     {
1188       do_getattr (app, ctrl, "PRIVATE-DO-1");
1189       do_getattr (app, ctrl, "PRIVATE-DO-2");
1190       if (app->did_chv2)
1191         do_getattr (app, ctrl, "PRIVATE-DO-3");
1192       if (app->did_chv3)
1193         do_getattr (app, ctrl, "PRIVATE-DO-4");
1194     }
1195   send_keypair_info (app, ctrl, 1);
1196   send_keypair_info (app, ctrl, 2);
1197   send_keypair_info (app, ctrl, 3);
1198   return 0;
1199 }
1200
1201
1202 /* Handle the READKEY command for OpenPGP.  On success a canonical
1203    encoded S-expression with the public key will get stored at PK and
1204    its length (for assertions) at PKLEN; the caller must release that
1205    buffer. On error PK and PKLEN are not changed and an error code is
1206    returned.  */
1207 static gpg_error_t
1208 do_readkey (app_t app, const char *keyid, unsigned char **pk, size_t *pklen)
1209 {
1210 #if GNUPG_MAJOR_VERSION > 1
1211   gpg_error_t err;
1212   int keyno;
1213   unsigned char *buf;
1214
1215   if (!strcmp (keyid, "OPENPGP.1"))
1216     keyno = 1;
1217   else if (!strcmp (keyid, "OPENPGP.2"))
1218     keyno = 2;
1219   else if (!strcmp (keyid, "OPENPGP.3"))
1220     keyno = 3;
1221   else
1222     return gpg_error (GPG_ERR_INV_ID);
1223
1224   err = get_public_key (app, keyno);
1225   if (err)
1226     return err;
1227
1228   buf = app->app_local->pk[keyno-1].key;
1229   if (!buf)
1230     return gpg_error (GPG_ERR_NO_PUBKEY);
1231   *pk = buf;
1232   *pklen = app->app_local->pk[keyno-1].keylen;;
1233   return 0;
1234 #else
1235   return gpg_error (GPG_ERR_NOT_IMPLEMENTED);
1236 #endif
1237 }
1238
1239
1240
1241 /* Verify CHV2 if required.  Depending on the configuration of the
1242    card CHV1 will also be verified. */
1243 static gpg_error_t
1244 verify_chv2 (app_t app,
1245              gpg_error_t (*pincb)(void*, const char *, char **),
1246              void *pincb_arg)
1247 {
1248   int rc = 0;
1249
1250   if (!app->did_chv2) 
1251     {
1252       char *pinvalue;
1253
1254       rc = pincb (pincb_arg, "PIN", &pinvalue); 
1255       if (rc)
1256         {
1257           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1258           return rc;
1259         }
1260
1261       if (strlen (pinvalue) < 6)
1262         {
1263           log_error (_("PIN for CHV%d is too short;"
1264                        " minimum length is %d\n"), 2, 6);
1265           xfree (pinvalue);
1266           return gpg_error (GPG_ERR_BAD_PIN);
1267         }
1268
1269       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1270       if (rc)
1271         {
1272           log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1273           xfree (pinvalue);
1274           flush_cache_after_error (app);
1275           return rc;
1276         }
1277       app->did_chv2 = 1;
1278
1279       if (!app->did_chv1 && !app->force_chv1)
1280         {
1281           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1282           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1283             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1284           if (rc)
1285             {
1286               log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1287               xfree (pinvalue);
1288               flush_cache_after_error (app);
1289               return rc;
1290             }
1291           app->did_chv1 = 1;
1292         }
1293       xfree (pinvalue);
1294     }
1295   return rc;
1296 }
1297
1298 /* Verify CHV3 if required. */
1299 static gpg_error_t
1300 verify_chv3 (app_t app,
1301              gpg_error_t (*pincb)(void*, const char *, char **),
1302              void *pincb_arg)
1303 {
1304   int rc = 0;
1305
1306 #if GNUPG_MAJOR_VERSION != 1
1307   if (!opt.allow_admin)
1308     {
1309       log_info (_("access to admin commands is not configured\n"));
1310       return gpg_error (GPG_ERR_EACCES);
1311     }
1312 #endif
1313       
1314   if (!app->did_chv3) 
1315     {
1316       char *pinvalue;
1317       void *relptr;
1318       unsigned char *value;
1319       size_t valuelen;
1320
1321       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
1322       if (!relptr || valuelen < 7)
1323         {
1324           log_error (_("error retrieving CHV status from card\n"));
1325           xfree (relptr);
1326           return gpg_error (GPG_ERR_CARD);
1327         }
1328       if (value[6] == 0)
1329         {
1330           log_info (_("card is permanently locked!\n"));
1331           xfree (relptr);
1332           return gpg_error (GPG_ERR_BAD_PIN);
1333         }
1334
1335       log_info(_("%d Admin PIN attempts remaining before card"
1336                  " is permanently locked\n"), value[6]);
1337       xfree (relptr);
1338
1339       /* TRANSLATORS: Do not translate the "|A|" prefix but
1340          keep it at the start of the string.  We need this elsewhere
1341          to get some infos on the string. */
1342       rc = pincb (pincb_arg, _("|A|Admin PIN"), &pinvalue); 
1343       if (rc)
1344         {
1345           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
1346           return rc;
1347         }
1348
1349       if (strlen (pinvalue) < 8)
1350         {
1351           log_error (_("PIN for CHV%d is too short;"
1352                        " minimum length is %d\n"), 3, 8);
1353           xfree (pinvalue);
1354           return gpg_error (GPG_ERR_BAD_PIN);
1355         }
1356
1357       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
1358       xfree (pinvalue);
1359       if (rc)
1360         {
1361           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
1362           flush_cache_after_error (app);
1363           return rc;
1364         }
1365       app->did_chv3 = 1;
1366     }
1367   return rc;
1368 }
1369
1370
1371 /* Handle the SETATTR operation. All arguments are already basically
1372    checked. */
1373 static gpg_error_t 
1374 do_setattr (app_t app, const char *name,
1375             gpg_error_t (*pincb)(void*, const char *, char **),
1376             void *pincb_arg,
1377             const unsigned char *value, size_t valuelen)
1378 {
1379   gpg_error_t rc;
1380   int idx;
1381   static struct {
1382     const char *name;
1383     int tag;
1384     int need_chv;
1385     int special;
1386   } table[] = {
1387     { "DISP-NAME",    0x005B, 3 },
1388     { "LOGIN-DATA",   0x005E, 3, 2 },
1389     { "DISP-LANG",    0x5F2D, 3 },
1390     { "DISP-SEX",     0x5F35, 3 },
1391     { "PUBKEY-URL",   0x5F50, 3 },
1392     { "CHV-STATUS-1", 0x00C4, 3, 1 },
1393     { "CA-FPR-1",     0x00CA, 3 },
1394     { "CA-FPR-2",     0x00CB, 3 },
1395     { "CA-FPR-3",     0x00CC, 3 },
1396     { "PRIVATE-DO-1", 0x0101, 2 },
1397     { "PRIVATE-DO-2", 0x0102, 3 },
1398     { "PRIVATE-DO-3", 0x0103, 2 },
1399     { "PRIVATE-DO-4", 0x0104, 3 },
1400     { NULL, 0 }
1401   };
1402
1403
1404   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
1405     ;
1406   if (!table[idx].name)
1407     return gpg_error (GPG_ERR_INV_NAME); 
1408
1409   switch (table[idx].need_chv)
1410     {
1411     case 2:
1412       rc = verify_chv2 (app, pincb, pincb_arg);
1413       break;
1414     case 3:
1415       rc = verify_chv3 (app, pincb, pincb_arg);
1416       break;
1417     default:
1418       rc = 0;
1419     }
1420   if (rc)
1421     return rc;
1422
1423   /* Flush the cache before writing it, so that the next get operation
1424      will reread the data from the card and thus get synced in case of
1425      errors (e.g. data truncated by the card). */
1426   flush_cache_item (app, table[idx].tag);
1427   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
1428   if (rc)
1429     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
1430
1431   if (table[idx].special == 1)
1432     app->force_chv1 = (valuelen && *value == 0);
1433   else if (table[idx].special == 2)
1434     parse_login_data (app);
1435
1436   return rc;
1437 }
1438
1439
1440 /* Handle the PASSWD command. */
1441 static gpg_error_t 
1442 do_change_pin (app_t app, ctrl_t ctrl,  const char *chvnostr, int reset_mode,
1443                gpg_error_t (*pincb)(void*, const char *, char **),
1444                void *pincb_arg)
1445 {
1446   int rc = 0;
1447   int chvno = atoi (chvnostr);
1448   char *pinvalue;
1449
1450   if (reset_mode && chvno == 3)
1451     {
1452       rc = gpg_error (GPG_ERR_INV_ID);
1453       goto leave;
1454     }
1455   else if (reset_mode || chvno == 3)
1456     {
1457       /* we always require that the PIN is entered. */
1458       app->did_chv3 = 0;
1459       rc = verify_chv3 (app, pincb, pincb_arg);
1460       if (rc)
1461         goto leave;
1462     }
1463   else if (chvno == 1 || chvno == 2)
1464     {
1465       /* CHV1 and CVH2 should always have the same value, thus we
1466          enforce it here.  */
1467       int save_force = app->force_chv1;
1468
1469       app->force_chv1 = 0;
1470       app->did_chv1 = 0;
1471       app->did_chv2 = 0;
1472       rc = verify_chv2 (app, pincb, pincb_arg);
1473       app->force_chv1 = save_force;
1474       if (rc)
1475         goto leave;
1476     }
1477   else
1478     {
1479       rc = gpg_error (GPG_ERR_INV_ID);
1480       goto leave;
1481     }
1482
1483   if (chvno == 3)
1484     app->did_chv3 = 0;
1485   else
1486     app->did_chv1 = app->did_chv2 = 0;
1487
1488   /* TRANSLATORS: Do not translate the "|*|" prefixes but
1489      keep it at the start of the string.  We need this elsewhere
1490      to get some infos on the string. */
1491   rc = pincb (pincb_arg, chvno == 3? _("|AN|New Admin PIN") : _("|N|New PIN"), 
1492               &pinvalue); 
1493   if (rc)
1494     {
1495       log_error (_("error getting new PIN: %s\n"), gpg_strerror (rc));
1496       goto leave;
1497     }
1498
1499   if (reset_mode)
1500     {
1501       rc = iso7816_reset_retry_counter (app->slot, 0x81,
1502                                         pinvalue, strlen (pinvalue));
1503       if (!rc)
1504         rc = iso7816_reset_retry_counter (app->slot, 0x82,
1505                                           pinvalue, strlen (pinvalue));
1506     }
1507   else
1508     {
1509       if (chvno == 1 || chvno == 2)
1510         {
1511           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
1512                                               pinvalue, strlen (pinvalue));
1513           if (!rc)
1514             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
1515                                                 pinvalue, strlen (pinvalue));
1516         }
1517       else
1518         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
1519                                             pinvalue, strlen (pinvalue));
1520     }
1521   xfree (pinvalue);
1522   if (rc)
1523     flush_cache_after_error (app);
1524
1525  leave:
1526   return rc;
1527 }
1528
1529
1530 /* Check whether a key already exists.  KEYIDX is the index of the key
1531    (0..2).  If FORCE is TRUE a diagnositivc will be printed but no
1532    error returned if the key already exists. */
1533 static gpg_error_t
1534 does_key_exist (app_t app, int keyidx, int force)
1535 {
1536   const unsigned char *fpr;
1537   unsigned char *buffer;
1538   size_t buflen, n;
1539   int i;
1540
1541   assert (keyidx >=0 && keyidx <= 2);
1542
1543   if (iso7816_get_data (app->slot, 0x006E, &buffer, &buflen))
1544     {
1545       log_error (_("error reading application data\n"));
1546       return gpg_error (GPG_ERR_GENERAL);
1547     }
1548   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1549   if (!fpr || n < 60)
1550     {
1551       log_error (_("error reading fingerprint DO\n"));
1552       xfree (buffer);
1553       return gpg_error (GPG_ERR_GENERAL);
1554     }
1555   fpr += 20*keyidx;
1556   for (i=0; i < 20 && !fpr[i]; i++)
1557     ;
1558   xfree (buffer);
1559   if (i!=20 && !force)
1560     {
1561       log_error (_("key already exists\n"));
1562       return gpg_error (GPG_ERR_EEXIST);
1563     }
1564   else if (i!=20)
1565     log_info (_("existing key will be replaced\n"));
1566   else
1567     log_info (_("generating new key\n"));
1568   return 0;
1569 }
1570
1571
1572
1573 /* Handle the WRITEKEY command for OpenPGP.  This function expects a
1574    canonical encoded S-expression with the secret key in KEYDATA and
1575    its length (for assertions) in KEYDATALEN.  KEYID needs to be the
1576    usual keyid which for OpenPGP is the string "OPENPGP.n" with
1577    n=1,2,3.  Bit 0 of FLAGS indicates whether an existing key shall
1578    get overwritten.  PINCB and PINCB_ARG are the usual arguments for
1579    the pinentry callback.  */
1580 static gpg_error_t
1581 do_writekey (app_t app, ctrl_t ctrl,
1582              const char *keyid, unsigned int flags,
1583              gpg_error_t (*pincb)(void*, const char *, char **),
1584              void *pincb_arg,
1585              const unsigned char *keydata, size_t keydatalen)
1586 {
1587   gpg_error_t err;
1588   int force = (flags & 1);
1589   int keyno;
1590   const unsigned char *buf, *tok;
1591   size_t buflen, toklen;
1592   int depth, last_depth1, last_depth2;
1593   const unsigned char *rsa_n = NULL;
1594   const unsigned char *rsa_e = NULL;
1595   const unsigned char *rsa_p = NULL;
1596   const unsigned char *rsa_q = NULL;
1597   size_t rsa_n_len, rsa_e_len, rsa_p_len, rsa_q_len;
1598   unsigned int nbits;
1599   unsigned char *template = NULL;
1600   unsigned char *tp;
1601   size_t template_len;
1602   unsigned char fprbuf[20];
1603   u32 created_at = 0;
1604
1605   if (!strcmp (keyid, "OPENPGP.1"))
1606     keyno = 0;
1607   else if (!strcmp (keyid, "OPENPGP.2"))
1608     keyno = 1;
1609   else if (!strcmp (keyid, "OPENPGP.3"))
1610     keyno = 2;
1611   else
1612     return gpg_error (GPG_ERR_INV_ID);
1613   
1614   err = does_key_exist (app, keyno, force);
1615   if (err)
1616     return err;
1617
1618
1619   /* 
1620      Parse the S-expression
1621    */
1622   buf = keydata;
1623   buflen = keydatalen;
1624   depth = 0;
1625   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1626     goto leave;
1627   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1628     goto leave;
1629   if (!tok || toklen != 11 || memcmp ("private-key", tok, toklen))
1630     {
1631       if (!tok)
1632         ;
1633       else if (toklen == 21 && !memcmp ("protected-private-key", tok, toklen))
1634         log_info ("protected-private-key passed to writekey\n");
1635       else if (toklen == 20 && !memcmp ("shadowed-private-key", tok, toklen))
1636         log_info ("shadowed-private-key passed to writekey\n");
1637       err = gpg_error (GPG_ERR_BAD_SECKEY);
1638       goto leave;
1639     }
1640   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1641     goto leave;
1642   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1643     goto leave;
1644   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
1645     {
1646       err = gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
1647       goto leave;
1648     }
1649   last_depth1 = depth;
1650   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1651          && depth && depth >= last_depth1)
1652     {
1653       if (tok)
1654         {
1655           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1656           goto leave;
1657         }
1658       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1659         goto leave;
1660       if (tok && toklen == 1)
1661         {
1662           const unsigned char **mpi;
1663           size_t *mpi_len;
1664
1665           switch (*tok)
1666             {
1667             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break; 
1668             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break; 
1669             case 'p': mpi = &rsa_p; mpi_len = &rsa_p_len; break; 
1670             case 'q': mpi = &rsa_q; mpi_len = &rsa_q_len;break; 
1671             default: mpi = NULL;  mpi_len = NULL; break;
1672             }
1673           if (mpi && *mpi)
1674             {
1675               err = gpg_error (GPG_ERR_DUP_VALUE);
1676               goto leave;
1677             }
1678           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1679             goto leave;
1680           if (tok && mpi)
1681             {
1682               /* Strip off leading zero bytes and save. */
1683               for (;toklen && !*tok; toklen--, tok++)
1684                 ;
1685               *mpi = tok;
1686               *mpi_len = toklen;
1687             }
1688         }
1689       /* Skip until end of list. */
1690       last_depth2 = depth;
1691       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1692              && depth && depth >= last_depth2)
1693         ;
1694       if (err)
1695         goto leave;
1696     }
1697   /* Parse other attributes. */
1698   last_depth1 = depth;
1699   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1700          && depth && depth >= last_depth1)
1701     {
1702       if (tok)
1703         {
1704           err = gpg_error (GPG_ERR_UNKNOWN_SEXP);
1705           goto leave;
1706         }
1707       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
1708         goto leave;
1709       if (tok && toklen == 10 && !memcmp ("created-at", tok, toklen))
1710         {
1711           if ((err = parse_sexp (&buf,&buflen,&depth,&tok,&toklen)))
1712             goto leave;
1713           if (tok)
1714             {
1715               for (created_at=0; toklen && *tok && *tok >= '0' && *tok <= '9';
1716                    tok++, toklen--)
1717                 created_at = created_at*10 + (*tok - '0');
1718             }
1719         }
1720       /* Skip until end of list. */
1721       last_depth2 = depth;
1722       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
1723              && depth && depth >= last_depth2)
1724         ;
1725       if (err)
1726         goto leave;
1727     }
1728
1729
1730   /* Check that we have all parameters and that they match the card
1731      description. */
1732   if (!created_at)
1733     {
1734       log_error (_("creation timestamp missing\n"));
1735       err = gpg_error (GPG_ERR_INV_VALUE);
1736       goto leave;
1737     }
1738   nbits = rsa_n? count_bits (rsa_n, rsa_n_len) : 0;
1739   if (nbits != 1024)
1740     {
1741       log_error (_("RSA modulus missing or not of size %d bits\n"), 1024);
1742       err = gpg_error (GPG_ERR_BAD_SECKEY);
1743       goto leave;
1744     }
1745   nbits = rsa_e? count_bits (rsa_e, rsa_e_len) : 0;
1746   if (nbits < 2 || nbits > 32)
1747     {
1748       log_error (_("RSA public exponent missing or largerr than %d bits\n"),
1749                  32);
1750       err = gpg_error (GPG_ERR_BAD_SECKEY);
1751       goto leave;
1752     }
1753   nbits = rsa_p? count_bits (rsa_p, rsa_p_len) : 0;
1754   if (nbits != 512)
1755     {
1756       log_error (_("RSA prime %s missing or not of size %d bits\n"), "P", 512);
1757       err = gpg_error (GPG_ERR_BAD_SECKEY);
1758       goto leave;
1759     }
1760   nbits = rsa_q? count_bits (rsa_q, rsa_q_len) : 0;
1761   if (nbits != 512)
1762     {
1763       log_error (_("RSA prime %s missing or not of size %d bits\n"), "Q", 512);
1764       err = gpg_error (GPG_ERR_BAD_SECKEY);
1765       goto leave;
1766     }
1767   
1768
1769   /* Build the private key template as described in section 4.3.3.6 of
1770      the OpenPGP card specs:
1771          0xC0   <length> public exponent
1772          0xC1   <length> prime p 
1773          0xC2   <length> prime q 
1774   */
1775   assert (rsa_e_len <= 4);
1776   template_len = (1 + 1 + 4
1777                   + 1 + 1 + rsa_p_len
1778                   + 1 + 1 + rsa_q_len);
1779   template = tp = xtrymalloc_secure (template_len);
1780   if (!template)
1781     {
1782       err = gpg_error_from_errno (errno);
1783       goto leave;
1784     }
1785   *tp++ = 0xC0;
1786   *tp++ = 4;
1787   memcpy (tp, rsa_e, rsa_e_len);
1788   if (rsa_e_len < 4)
1789     {
1790       /* Right justify E. */
1791       memmove (tp+4-rsa_e_len, tp, 4-rsa_e_len);
1792       memset (tp, 0, 4-rsa_e_len);
1793     }                 
1794   tp += 4;
1795
1796   *tp++ = 0xC1;
1797   *tp++ = rsa_p_len;
1798   memcpy (tp, rsa_p, rsa_p_len);
1799   tp += rsa_p_len;
1800
1801   *tp++ = 0xC2;
1802   *tp++ = rsa_q_len;
1803   memcpy (tp, rsa_q, rsa_q_len);
1804   tp += rsa_q_len;
1805
1806   assert (tp - template == template_len);
1807
1808
1809   /* Obviously we need to remove the cached public key.  */
1810   xfree (app->app_local->pk[keyno].key);
1811   app->app_local->pk[keyno].key = NULL;
1812   app->app_local->pk[keyno].keylen = 0;
1813   app->app_local->pk[keyno].read_done = 0;
1814
1815   /* Prepare for storing the key.  */
1816   err = verify_chv3 (app, pincb, pincb_arg);
1817   if (err)
1818     goto leave;
1819
1820   /* Store the key. */
1821   err = iso7816_put_data (app->slot,
1822                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1823                          template, template_len);
1824   if (err)
1825     {
1826       log_error (_("failed to store the key: %s\n"), gpg_strerror (err));
1827       goto leave;
1828     }
1829  
1830   err = store_fpr (app->slot, keyno, created_at,
1831                   rsa_n, rsa_n_len, rsa_e, rsa_e_len,
1832                   fprbuf, app->card_version);
1833   if (err)
1834     goto leave;
1835
1836
1837  leave:
1838   xfree (template);
1839   return err;
1840 }
1841
1842
1843 /* Handle the GENKEY command. */
1844 static gpg_error_t 
1845 do_genkey (app_t app, ctrl_t ctrl,  const char *keynostr, unsigned int flags,
1846           gpg_error_t (*pincb)(void*, const char *, char **),
1847           void *pincb_arg)
1848 {
1849   int rc;
1850   char numbuf[30];
1851   unsigned char fprbuf[20];
1852   const unsigned char *keydata, *m, *e;
1853   unsigned char *buffer = NULL;
1854   size_t buflen, keydatalen, mlen, elen;
1855   time_t created_at;
1856   int keyno = atoi (keynostr);
1857   int force = (flags & 1);
1858   time_t start_at;
1859
1860   if (keyno < 1 || keyno > 3)
1861     return gpg_error (GPG_ERR_INV_ID);
1862   keyno--;
1863
1864   /* We flush the cache to increase the traffic before a key
1865      generation.  This _might_ help a card to gather more entropy. */
1866   flush_cache (app);
1867
1868   /* Obviously we need to remove the cached public key.  */
1869   xfree (app->app_local->pk[keyno].key);
1870   app->app_local->pk[keyno].key = NULL;
1871   app->app_local->pk[keyno].keylen = 0;
1872   app->app_local->pk[keyno].read_done = 0;
1873
1874   /* Check whether a key already exists.  */
1875   rc = does_key_exist (app, keyno, force);
1876   if (rc)
1877     return rc;
1878
1879   /* Prepare for key generation by verifying the ADmin PIN.  */
1880   rc = verify_chv3 (app, pincb, pincb_arg);
1881   if (rc)
1882     goto leave;
1883    
1884 #if 1
1885   log_info (_("please wait while key is being generated ...\n"));
1886   start_at = time (NULL);
1887   rc = iso7816_generate_keypair 
1888 #else
1889 #warning key generation temporary replaced by reading an existing key.
1890   rc = iso7816_read_public_key
1891 #endif
1892                               (app->slot, 
1893                                  keyno == 0? "\xB6" :
1894                                  keyno == 1? "\xB8" : "\xA4",
1895                                  2,
1896                                  &buffer, &buflen);
1897   if (rc)
1898     {
1899       rc = gpg_error (GPG_ERR_CARD);
1900       log_error (_("generating key failed\n"));
1901       goto leave;
1902     }
1903   log_info (_("key generation completed (%d seconds)\n"),
1904             (int)(time (NULL) - start_at));
1905   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1906   if (!keydata)
1907     {
1908       rc = gpg_error (GPG_ERR_CARD);
1909       log_error (_("response does not contain the public key data\n"));
1910       goto leave;
1911     }
1912  
1913   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1914   if (!m)
1915     {
1916       rc = gpg_error (GPG_ERR_CARD);
1917       log_error (_("response does not contain the RSA modulus\n"));
1918       goto leave;
1919     }
1920 /*    log_printhex ("RSA n:", m, mlen); */
1921   send_key_data (ctrl, "n", m, mlen);
1922
1923   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1924   if (!e)
1925     {
1926       rc = gpg_error (GPG_ERR_CARD);
1927       log_error (_("response does not contain the RSA public exponent\n"));
1928       goto leave;
1929     }
1930 /*    log_printhex ("RSA e:", e, elen); */
1931   send_key_data (ctrl, "e", e, elen);
1932
1933   created_at = gnupg_get_time ();
1934   sprintf (numbuf, "%lu", (unsigned long)created_at);
1935   send_status_info (ctrl, "KEY-CREATED-AT",
1936                     numbuf, (size_t)strlen(numbuf), NULL, 0);
1937
1938   rc = store_fpr (app->slot, keyno, (u32)created_at,
1939                   m, mlen, e, elen, fprbuf, app->card_version);
1940   if (rc)
1941     goto leave;
1942   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1943
1944
1945  leave:
1946   xfree (buffer);
1947   return rc;
1948 }
1949
1950
1951 static unsigned long
1952 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
1953 {
1954   unsigned long ul;
1955
1956   if (valuelen == 3 )
1957     ul = (value[0] << 16) | (value[1] << 8) | value[2];
1958   else
1959     {
1960       log_error (_("invalid structure of OpenPGP card (DO 0x93)\n"));
1961       ul = 0;
1962     }
1963   return ul;
1964 }
1965
1966 static unsigned long
1967 get_sig_counter (app_t app)
1968 {
1969   void *relptr;
1970   unsigned char *value;
1971   size_t valuelen;
1972   unsigned long ul;
1973
1974   relptr = get_one_do (app, 0x0093, &value, &valuelen, NULL);
1975   if (!relptr)
1976     return 0;
1977   ul = convert_sig_counter_value (value, valuelen);
1978   xfree (relptr);
1979   return ul;
1980 }
1981
1982 static gpg_error_t
1983 compare_fingerprint (app_t app, int keyno, unsigned char *sha1fpr)
1984 {
1985   const unsigned char *fpr;
1986   unsigned char *buffer;
1987   size_t buflen, n;
1988   int rc, i;
1989   
1990   assert (keyno >= 1 && keyno <= 3);
1991
1992   rc = get_cached_data (app, 0x006E, &buffer, &buflen, 0);
1993   if (rc)
1994     {
1995       log_error (_("error reading application data\n"));
1996       return gpg_error (GPG_ERR_GENERAL);
1997     }
1998   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1999   if (!fpr || n != 60)
2000     {
2001       xfree (buffer);
2002       log_error (_("error reading fingerprint DO\n"));
2003       return gpg_error (GPG_ERR_GENERAL);
2004     }
2005   fpr += (keyno-1)*20;
2006   for (i=0; i < 20; i++)
2007     if (sha1fpr[i] != fpr[i])
2008       {
2009         xfree (buffer);
2010         return gpg_error (GPG_ERR_WRONG_SECKEY);
2011       }
2012   xfree (buffer);
2013   return 0;
2014 }
2015
2016
2017   /* If a fingerprint has been specified check it against the one on
2018      the card.  This is allows for a meaningful error message in case
2019      the key on the card has been replaced but the shadow information
2020      known to gpg was not updated.  If there is no fingerprint we
2021      assume that this is okay. */
2022 static gpg_error_t
2023 check_against_given_fingerprint (app_t app, const char *fpr, int keyno)
2024 {
2025   unsigned char tmp[20];
2026   const char *s;
2027   int n;
2028
2029   for (s=fpr, n=0; hexdigitp (s); s++, n++)
2030     ;
2031   if (n != 40)
2032     return gpg_error (GPG_ERR_INV_ID);
2033   else if (!*s)
2034     ; /* okay */
2035   else
2036     return gpg_error (GPG_ERR_INV_ID);
2037
2038   for (s=fpr, n=0; n < 20; s += 2, n++)
2039         tmp[n] = xtoi_2 (s);
2040   return compare_fingerprint (app, keyno, tmp);
2041 }
2042
2043
2044
2045 /* Compute a digital signature on INDATA which is expected to be the
2046    raw message digest. For this application the KEYIDSTR consists of
2047    the serialnumber and the fingerprint delimited by a slash.
2048
2049    Note that this fucntion may return the error code
2050    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2051    not match the one required for the requested action (e.g. the
2052    serial number does not match). */
2053 static gpg_error_t 
2054 do_sign (app_t app, const char *keyidstr, int hashalgo,
2055          gpg_error_t (*pincb)(void*, const char *, char **),
2056          void *pincb_arg,
2057          const void *indata, size_t indatalen,
2058          unsigned char **outdata, size_t *outdatalen )
2059 {
2060   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
2061   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
2062     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
2063   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
2064   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
2065     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
2066   int rc;
2067   unsigned char data[35];
2068   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2069   const char *s;
2070   int n;
2071   const char *fpr = NULL;
2072   unsigned long sigcount;
2073
2074   if (!keyidstr || !*keyidstr)
2075     return gpg_error (GPG_ERR_INV_VALUE);
2076   if (indatalen == 20)
2077     ;
2078   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_SHA1
2079            && !memcmp (indata, sha1_prefix, 15))
2080     ;
2081   else if (indatalen == (15 + 20) && hashalgo == GCRY_MD_RMD160
2082            && !memcmp (indata, rmd160_prefix, 15))
2083     ;
2084   else
2085     return gpg_error (GPG_ERR_INV_VALUE);
2086
2087   /* Check whether an OpenPGP card of any version has been requested. */
2088   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2089     return gpg_error (GPG_ERR_INV_ID);
2090   
2091   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2092     ;
2093   if (n != 32)
2094     return gpg_error (GPG_ERR_INV_ID);
2095   else if (!*s)
2096     ; /* no fingerprint given: we allow this for now. */
2097   else if (*s == '/')
2098     fpr = s + 1; 
2099   else
2100     return gpg_error (GPG_ERR_INV_ID);
2101
2102   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2103     tmp_sn[n] = xtoi_2 (s);
2104
2105   if (app->serialnolen != 16)
2106     return gpg_error (GPG_ERR_INV_CARD);
2107   if (memcmp (app->serialno, tmp_sn, 16))
2108     return gpg_error (GPG_ERR_WRONG_CARD);
2109
2110   /* If a fingerprint has been specified check it against the one on
2111      the card.  This is allows for a meaningful error message in case
2112      the key on the card has been replaced but the shadow information
2113      known to gpg was not updated.  If there is no fingerprint, gpg
2114      will detect a bogus signature anyway due to the
2115      verify-after-signing feature. */
2116   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
2117   if (rc)
2118     return rc;
2119
2120   if (hashalgo == GCRY_MD_SHA1)
2121     memcpy (data, sha1_prefix, 15);
2122   else if (hashalgo == GCRY_MD_RMD160)
2123     memcpy (data, rmd160_prefix, 15);
2124   else 
2125     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
2126   memcpy (data+15, indata, indatalen);
2127
2128   sigcount = get_sig_counter (app);
2129   log_info (_("signatures created so far: %lu\n"), sigcount);
2130
2131   if (!app->did_chv1 || app->force_chv1 ) 
2132     {
2133       char *pinvalue;
2134
2135       {
2136         char *prompt;
2137 #define PROMPTSTRING  _("PIN [sigs done: %lu]")
2138
2139         prompt = malloc (strlen (PROMPTSTRING) + 50);
2140         if (!prompt)
2141           return gpg_error_from_errno (errno);
2142         sprintf (prompt, PROMPTSTRING, sigcount);
2143         rc = pincb (pincb_arg, prompt, &pinvalue); 
2144         free (prompt);
2145 #undef PROMPTSTRING
2146       }
2147       if (rc)
2148         {
2149           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
2150           return rc;
2151         }
2152
2153       if (strlen (pinvalue) < 6)
2154         {
2155           log_error (_("PIN for CHV%d is too short;"
2156                        " minimum length is %d\n"), 1, 6);
2157           xfree (pinvalue);
2158           return gpg_error (GPG_ERR_BAD_PIN);
2159         }
2160
2161       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
2162       if (rc)
2163         {
2164           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
2165           xfree (pinvalue);
2166           flush_cache_after_error (app);
2167           return rc;
2168         }
2169       app->did_chv1 = 1;
2170       if (!app->did_chv2)
2171         {
2172           /* We should also verify CHV2. */
2173           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
2174           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
2175             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
2176           if (rc)
2177             {
2178               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
2179               xfree (pinvalue);
2180               flush_cache_after_error (app);
2181               return rc;
2182             }
2183           app->did_chv2 = 1;
2184         }
2185       xfree (pinvalue);
2186     }
2187
2188   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
2189   return rc;
2190 }
2191
2192 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
2193    on INDATA which is expected to be the raw message digest. For this
2194    application the KEYIDSTR consists of the serialnumber and the
2195    fingerprint delimited by a slash.  Optionally the id OPENPGP.3 may
2196    be given.
2197
2198    Note that this fucntion may return the error code
2199    GPG_ERR_WRONG_CARD to indicate that the card currently present does
2200    not match the one required for the requested action (e.g. the
2201    serial number does not match). */
2202 static gpg_error_t 
2203 do_auth (app_t app, const char *keyidstr,
2204          gpg_error_t (*pincb)(void*, const char *, char **),
2205          void *pincb_arg,
2206          const void *indata, size_t indatalen,
2207          unsigned char **outdata, size_t *outdatalen )
2208 {
2209   int rc;
2210   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2211   const char *s;
2212   int n;
2213   const char *fpr = NULL;
2214
2215   if (!keyidstr || !*keyidstr)
2216     return gpg_error (GPG_ERR_INV_VALUE);
2217   if (indatalen > 50) /* For a 1024 bit key. */
2218     return gpg_error (GPG_ERR_INV_VALUE);
2219
2220   /* Check whether an OpenPGP card of any version has been requested. */
2221   if (!strcmp (keyidstr, "OPENPGP.3"))
2222     ;
2223   else if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2224     return gpg_error (GPG_ERR_INV_ID);
2225   else
2226     {
2227       for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2228         ;
2229       if (n != 32)
2230         return gpg_error (GPG_ERR_INV_ID);
2231       else if (!*s)
2232         ; /* no fingerprint given: we allow this for now. */
2233       else if (*s == '/')
2234         fpr = s + 1; 
2235       else
2236         return gpg_error (GPG_ERR_INV_ID);
2237
2238       for (s=keyidstr, n=0; n < 16; s += 2, n++)
2239         tmp_sn[n] = xtoi_2 (s);
2240       
2241       if (app->serialnolen != 16)
2242         return gpg_error (GPG_ERR_INV_CARD);
2243       if (memcmp (app->serialno, tmp_sn, 16))
2244         return gpg_error (GPG_ERR_WRONG_CARD);
2245     }
2246
2247   /* If a fingerprint has been specified check it against the one on
2248      the card.  This is allows for a meaningful error message in case
2249      the key on the card has been replaced but the shadow information
2250      known to gpg was not updated.  If there is no fingerprint, gpg
2251      will detect a bogus signature anyway due to the
2252      verify-after-signing feature. */
2253   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
2254   if (rc)
2255     return rc;
2256
2257   rc = verify_chv2 (app, pincb, pincb_arg);
2258   if (!rc)
2259     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
2260                                         outdata, outdatalen);
2261   return rc;
2262 }
2263
2264
2265 static gpg_error_t 
2266 do_decipher (app_t app, const char *keyidstr,
2267              gpg_error_t (*pincb)(void*, const char *, char **),
2268              void *pincb_arg,
2269              const void *indata, size_t indatalen,
2270              unsigned char **outdata, size_t *outdatalen )
2271 {
2272   int rc;
2273   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
2274   const char *s;
2275   int n;
2276   const char *fpr = NULL;
2277
2278   if (!keyidstr || !*keyidstr || !indatalen)
2279     return gpg_error (GPG_ERR_INV_VALUE);
2280
2281   /* Check whether an OpenPGP card of any version has been requested. */
2282   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2283     return gpg_error (GPG_ERR_INV_ID);
2284   
2285   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2286     ;
2287   if (n != 32)
2288     return gpg_error (GPG_ERR_INV_ID);
2289   else if (!*s)
2290     ; /* no fingerprint given: we allow this for now. */
2291   else if (*s == '/')
2292     fpr = s + 1; 
2293   else
2294     return gpg_error (GPG_ERR_INV_ID);
2295
2296   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2297     tmp_sn[n] = xtoi_2 (s);
2298
2299   if (app->serialnolen != 16)
2300     return gpg_error (GPG_ERR_INV_CARD);
2301   if (memcmp (app->serialno, tmp_sn, 16))
2302     return gpg_error (GPG_ERR_WRONG_CARD);
2303
2304   /* If a fingerprint has been specified check it against the one on
2305      the card.  This is allows for a meaningful error message in case
2306      the key on the card has been replaced but the shadow information
2307      known to gpg was not updated.  If there is no fingerprint, the
2308      decryption will won't produce the right plaintext anyway. */
2309   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
2310   if (rc)
2311     return rc;
2312
2313   rc = verify_chv2 (app, pincb, pincb_arg);
2314   if (!rc)
2315     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
2316                            outdata, outdatalen);
2317   return rc;
2318 }
2319
2320
2321 /* Perform a simple verify operation for CHV1 and CHV2, so that
2322    further operations won't ask for CHV2 and it is possible to do a
2323    cheap check on the PIN: If there is something wrong with the PIN
2324    entry system, only the regular CHV will get blocked and not the
2325    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
2326    optional fingerprint part will be ignored.
2327
2328    There is a special mode if the keyidstr is "<serialno>[CHV3]" with
2329    the "[CHV3]" being a literal string:  The Admin Pin is checked if
2330    and only if the retry counter is still at 3. */
2331 static gpg_error_t 
2332 do_check_pin (app_t app, const char *keyidstr,
2333               gpg_error_t (*pincb)(void*, const char *, char **),
2334               void *pincb_arg)
2335 {
2336   unsigned char tmp_sn[20]; 
2337   const char *s;
2338   int n;
2339   int admin_pin = 0;
2340
2341   if (!keyidstr || !*keyidstr)
2342     return gpg_error (GPG_ERR_INV_VALUE);
2343
2344   /* Check whether an OpenPGP card of any version has been requested. */
2345   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
2346     return gpg_error (GPG_ERR_INV_ID);
2347   
2348   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
2349     ;
2350   if (n != 32)
2351     return gpg_error (GPG_ERR_INV_ID);
2352   else if (!*s)
2353     ; /* No fingerprint given: we allow this for now. */
2354   else if (*s == '/')
2355     ; /* We ignore a fingerprint. */
2356   else if (!strcmp (s, "[CHV3]") )
2357     admin_pin = 1;
2358   else
2359     return gpg_error (GPG_ERR_INV_ID);
2360
2361   for (s=keyidstr, n=0; n < 16; s += 2, n++)
2362     tmp_sn[n] = xtoi_2 (s);
2363
2364   if (app->serialnolen != 16)
2365     return gpg_error (GPG_ERR_INV_CARD);
2366   if (memcmp (app->serialno, tmp_sn, 16))
2367     return gpg_error (GPG_ERR_WRONG_CARD);
2368
2369   /* Yes, there is a race conditions: The user might pull the card
2370      right here and we won't notice that.  However this is not a
2371      problem and the check above is merely for a graceful failure
2372      between operations. */
2373
2374   if (admin_pin)
2375     {
2376       void *relptr;
2377       unsigned char *value;
2378       size_t valuelen;
2379       int count;
2380       
2381       relptr = get_one_do (app, 0x00C4, &value, &valuelen, NULL);
2382       if (!relptr || valuelen < 7)
2383         {
2384           log_error (_("error retrieving CHV status from card\n"));
2385           xfree (relptr);
2386           return gpg_error (GPG_ERR_CARD);
2387         }
2388       count = value[6];
2389       xfree (relptr);
2390
2391       if (!count)
2392         {
2393           log_info (_("card is permanently locked!\n"));
2394           return gpg_error (GPG_ERR_BAD_PIN);
2395         }
2396       else if (value[6] < 3)
2397         {
2398           log_info (_("verification of Admin PIN is currently prohibited "
2399                       "through this command\n"));
2400           return gpg_error (GPG_ERR_GENERAL);
2401         }
2402
2403       app->did_chv3 = 0; /* Force verification.  */
2404       return verify_chv3 (app, pincb, pincb_arg);
2405     }
2406   else
2407     return verify_chv2 (app, pincb, pincb_arg);
2408 }
2409
2410
2411
2412
2413 /* Select the OpenPGP application on the card in SLOT.  This function
2414    must be used before any other OpenPGP application functions. */
2415 gpg_error_t
2416 app_select_openpgp (app_t app)
2417 {
2418   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
2419   int slot = app->slot;
2420   int rc;
2421   unsigned char *buffer;
2422   size_t buflen;
2423   void *relptr;
2424   
2425   rc = iso7816_select_application (slot, aid, sizeof aid);
2426   if (!rc)
2427     {
2428       unsigned int manufacturer;
2429
2430       app->apptype = "OPENPGP";
2431
2432       app->did_chv1 = 0;
2433       app->did_chv2 = 0;
2434       app->did_chv3 = 0;
2435       app->app_local = NULL;
2436
2437       /* The OpenPGP card returns the serial number as part of the
2438          AID; because we prefer to use OpenPGP serial numbers, we
2439          replace a possibly already set one from a EF.GDO with this
2440          one.  Note, that for current OpenPGP cards, no EF.GDO exists
2441          and thus it won't matter at all. */
2442       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
2443       if (rc)
2444         goto leave;
2445       if (opt.verbose)
2446         {
2447           log_info ("AID: ");
2448           log_printhex ("", buffer, buflen);
2449         }
2450
2451       app->card_version = buffer[6] << 8;
2452       app->card_version |= buffer[7];
2453       manufacturer = (buffer[8]<<8 | buffer[9]);
2454
2455       xfree (app->serialno);
2456       app->serialno = buffer;
2457       app->serialnolen = buflen;
2458       buffer = NULL;
2459       app->app_local = xtrycalloc (1, sizeof *app->app_local);
2460       if (!app->app_local)
2461         {
2462           rc = gpg_error (gpg_err_code_from_errno (errno));
2463           goto leave;
2464         }
2465
2466       relptr = get_one_do (app, 0x00C4, &buffer, &buflen, NULL);
2467       if (!relptr)
2468         {
2469           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2470                      "CHV Status Bytes");
2471           goto leave;
2472         }
2473       app->force_chv1 = (buflen && *buffer == 0);
2474       xfree (relptr);
2475
2476       relptr = get_one_do (app, 0x00C0, &buffer, &buflen, NULL);
2477       if (!relptr)
2478         {
2479           log_error (_("can't access %s - invalid OpenPGP card?\n"),
2480                      "Extended Capability Flags" );
2481           goto leave;
2482         }
2483       if (buflen)
2484         {
2485           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
2486           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
2487           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
2488           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
2489         }
2490       xfree (relptr);
2491       
2492       /* Some of the first cards accidently don't set the
2493          CHANGE_FORCE_CHV bit but allow it anyway. */
2494       if (app->card_version <= 0x0100 && manufacturer == 1)
2495         app->app_local->extcap.change_force_chv = 1;
2496
2497       parse_login_data (app);
2498
2499       if (opt.verbose > 1)
2500         dump_all_do (slot);
2501
2502       app->fnc.deinit = do_deinit;
2503       app->fnc.learn_status = do_learn_status;
2504       app->fnc.readkey = do_readkey;
2505       app->fnc.getattr = do_getattr;
2506       app->fnc.setattr = do_setattr;
2507       app->fnc.writekey = do_writekey;
2508       app->fnc.genkey = do_genkey;
2509       app->fnc.sign = do_sign;
2510       app->fnc.auth = do_auth;
2511       app->fnc.decipher = do_decipher;
2512       app->fnc.change_pin = do_change_pin;
2513       app->fnc.check_pin = do_check_pin;
2514    }
2515
2516 leave:
2517   if (rc)
2518     do_deinit (app);
2519   return rc;
2520 }
2521
2522
2523
2524 /* This function is a hack to retrieve essential information about the
2525    card to be displayed by simple tools.  It mostly resembles what the
2526    LEARN command returns. All parameters return allocated strings or
2527    buffers or NULL if the data object is not available.  All returned
2528    values are sanitized. */
2529 gpg_error_t
2530 app_openpgp_cardinfo (app_t app,
2531                       char **serialno,
2532                       char **disp_name,
2533                       char **pubkey_url,
2534                       unsigned char **fpr1,
2535                       unsigned char **fpr2,
2536                       unsigned char **fpr3)
2537 {
2538   int rc;
2539   void *relptr;
2540   unsigned char *value;
2541   size_t valuelen;
2542
2543   if (serialno)
2544     {
2545       time_t dummy;
2546
2547       *serialno = NULL;
2548       rc = app_get_serial_and_stamp (app, serialno, &dummy);
2549       if (rc)
2550         {
2551           log_error (_("error getting serial number: %s\n"),
2552                      gpg_strerror (rc));
2553           return rc;
2554         }
2555     }
2556       
2557   if (disp_name)
2558     {
2559       *disp_name = NULL;
2560       relptr = get_one_do (app, 0x005B, &value, &valuelen, NULL);
2561       if (relptr)
2562         {
2563           *disp_name = make_printable_string (value, valuelen, 0);
2564           xfree (relptr);
2565         }
2566     }
2567
2568   if (pubkey_url)
2569     {
2570       *pubkey_url = NULL;
2571       relptr = get_one_do (app, 0x5F50, &value, &valuelen, NULL);
2572       if (relptr)
2573         {
2574           *pubkey_url = make_printable_string (value, valuelen, 0);
2575           xfree (relptr);
2576         }
2577     }
2578
2579   if (fpr1)
2580     *fpr1 = NULL;
2581   if (fpr2)
2582     *fpr2 = NULL;
2583   if (fpr3)
2584     *fpr3 = NULL;
2585   relptr = get_one_do (app, 0x00C5, &value, &valuelen, NULL);
2586   if (relptr && valuelen >= 60)
2587     {
2588       if (fpr1)
2589         {
2590           *fpr1 = xmalloc (20);
2591           memcpy (*fpr1, value +  0, 20);
2592         }
2593       if (fpr2)
2594         {
2595           *fpr2 = xmalloc (20);
2596           memcpy (*fpr2, value + 20, 20);
2597         }
2598       if (fpr3)
2599         {
2600           *fpr3 = xmalloc (20);
2601           memcpy (*fpr3, value + 40, 20);
2602         }
2603     }
2604   xfree (relptr);
2605
2606   return 0;
2607 }
2608
2609
2610
2611 /* This function is currently only used by the sc-copykeys program to
2612    store a key on the smartcard.  app_t ist the application handle,
2613    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
2614    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
2615    the key template to store. CREATED_AT is the timestamp used to
2616    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
2617    RSA public exponent. This function silently overwrites an existing
2618    key.*/
2619 gpg_error_t
2620 app_openpgp_storekey (app_t app, int keyno,
2621                       unsigned char *template, size_t template_len,
2622                       time_t created_at,
2623                       const unsigned char *m, size_t mlen,
2624                       const unsigned char *e, size_t elen,
2625                       gpg_error_t (*pincb)(void*, const char *, char **),
2626                       void *pincb_arg)
2627 {
2628   int rc;
2629   unsigned char fprbuf[20];
2630
2631   if (keyno < 1 || keyno > 3)
2632     return gpg_error (GPG_ERR_INV_ID);
2633   keyno--;
2634
2635   rc = verify_chv3 (app, pincb, pincb_arg);
2636   if (rc)
2637     goto leave;
2638
2639   flush_cache (app);
2640
2641   xfree (app->app_local->pk[keyno].key);
2642   app->app_local->pk[keyno].key = NULL;
2643   app->app_local->pk[keyno].keylen = 0;
2644   app->app_local->pk[keyno].read_done = 0;
2645
2646   rc = iso7816_put_data (app->slot,
2647                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
2648                          template, template_len);
2649   if (rc)
2650     {
2651       log_error (_("failed to store the key: %s\n"), gpg_strerror (rc));
2652       rc = gpg_error (GPG_ERR_CARD);
2653       goto leave;
2654     }
2655  
2656 /*    log_printhex ("RSA n:", m, mlen);  */
2657 /*    log_printhex ("RSA e:", e, elen);  */
2658
2659   rc = store_fpr (app->slot, keyno, (u32)created_at,
2660                   m, mlen, e, elen, fprbuf, app->card_version);
2661
2662  leave:
2663   return rc;
2664 }
2665
2666
2667 /* Utility function for external tools: Read the public RSA key at
2668    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
2669 gpg_error_t 
2670 app_openpgp_readkey (app_t app, int keyno, unsigned char **m, size_t *mlen,
2671                      unsigned char **e, size_t *elen)
2672 {
2673   int rc;
2674   const unsigned char *keydata, *a;
2675   unsigned char *buffer;
2676   size_t buflen, keydatalen, alen;
2677
2678   *m = NULL;
2679   *e = NULL;
2680
2681   if (keyno < 1 || keyno > 3)
2682     return gpg_error (GPG_ERR_INV_ID);
2683   keyno--;
2684
2685   rc = iso7816_read_public_key(app->slot, 
2686                                keyno == 0? "\xB6" :
2687                                keyno == 1? "\xB8" : "\xA4",
2688                                2,
2689                                &buffer, &buflen);
2690   if (rc)
2691     {
2692       rc = gpg_error (GPG_ERR_CARD);
2693       log_error (_("reading the key failed\n"));
2694       goto leave;
2695     }
2696
2697   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
2698   if (!keydata)
2699     {
2700       log_error (_("response does not contain the public key data\n"));
2701       rc = gpg_error (GPG_ERR_CARD);
2702       goto leave;
2703     }
2704  
2705   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
2706   if (!a)
2707     {
2708       log_error (_("response does not contain the RSA modulus\n"));
2709       rc = gpg_error (GPG_ERR_CARD);
2710       goto leave;
2711     }
2712   *mlen = alen;
2713   *m = xmalloc (alen);
2714   memcpy (*m, a, alen);
2715   
2716   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
2717   if (!a)
2718     {
2719       log_error (_("response does not contain the RSA public exponent\n"));
2720       rc = gpg_error (GPG_ERR_CARD);
2721       goto leave;
2722     }
2723   *elen = alen;
2724   *e = xmalloc (alen);
2725   memcpy (*e, a, alen);
2726
2727  leave:
2728   xfree (buffer);
2729   if (rc)
2730     { 
2731       xfree (*m); *m = NULL;
2732       xfree (*e); *e = NULL;
2733     }
2734   return rc;
2735 }