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