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