Added ID keywords because these files are often used in other packages.
[gnupg.git] / scd / app-openpgp.c
1 /* app-openpgp.c - The OpenPGP card application.
2  *      Copyright (C) 2003, 2004 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   { 0x007A, 1,    0, 1, 0, 0, 0, "Security Support Template" },
83   { 0x0093, 0, 0x7A, 1, 1, 0, 0, "Digital Signature Counter" },
84   { 0 }
85 };
86
87
88 struct cache_s {
89   struct cache_s *next;
90   int tag;
91   size_t length;
92   unsigned char data[1];
93 };
94
95 struct app_local_s {
96   struct cache_s *cache;
97   struct 
98   {
99     unsigned int get_challenge:1;
100     unsigned int key_import:1;
101     unsigned int change_force_chv:1;
102     unsigned int private_dos:1;
103   } extcap;
104 };
105
106
107 static unsigned long convert_sig_counter_value (const unsigned char *value,
108                                                 size_t valuelen);
109 static unsigned long get_sig_counter (APP app);
110
111 /* Deconstructor. */
112 static void
113 do_deinit (app_t app)
114 {
115   if (app && app->app_local)
116     {
117       struct cache_s *c, *c2;
118
119       for (c = app->app_local->cache; c; c = c2)
120         {
121           c2 = c->next;
122           xfree (c);
123         }
124       xfree (app->app_local);
125       app->app_local = NULL;
126     }
127 }
128
129
130 /* Wrapper around iso7816_get_data which first tries to get the data
131    from the cache. */
132 static gpg_error_t
133 get_cached_data (app_t app, int tag, 
134                  unsigned char **result, size_t *resultlen)
135 {
136   gpg_error_t err;
137   int i;
138   unsigned char *p;
139   size_t len;
140   struct cache_s *c;
141
142   *result = NULL;
143   *resultlen = 0;
144
145   for (c=app->app_local->cache; c; c = c->next)
146     if (c->tag == tag)
147       {
148         if(c->length)
149           {
150             p = xtrymalloc (c->length);
151             if (!p)
152               return gpg_error (gpg_err_code_from_errno (errno));
153             memcpy (p, c->data, c->length);
154             *result = p;
155           }
156
157         *resultlen = c->length;
158
159         return 0;
160       }
161  
162   
163   err = iso7816_get_data (app->slot, tag, &p, &len);
164   if (err)
165     return err;
166   *result = p;
167   *resultlen = len;
168
169   /* Check whether we should cache this object. */
170   for (i=0; data_objects[i].tag; i++)
171     if (data_objects[i].tag == tag)
172       {
173         if (data_objects[i].dont_cache)
174           return 0;
175         break;
176       }
177
178   /* No, cache it. */
179
180   for (c=app->app_local->cache; c; c = c->next)
181     assert (c->tag != tag);
182   
183   c = xtrymalloc (sizeof *c + len);
184   if (c)
185     {
186       memcpy (c->data, p, len);
187       c->length = len;
188       c->tag = tag;
189       c->next = app->app_local->cache;
190       app->app_local->cache = c;
191     }
192
193   return 0;
194 }
195
196 /* Remove DO at TAG from the cache. */
197 static void
198 flush_cache_item (app_t app, int tag)
199 {
200   struct cache_s *c, *cprev;
201   int i;
202
203   if (!app->app_local)
204     return;
205
206   for (c=app->app_local->cache, cprev=NULL; c ; cprev=c, c = c->next)
207     if (c->tag == tag)
208       {
209         if (cprev)
210           cprev->next = c->next;
211         else
212           app->app_local->cache = c->next;
213         xfree (c);
214
215         for (c=app->app_local->cache; c ; c = c->next)
216           {
217             assert (c->tag != tag); /* Oops: duplicated entry. */
218           }
219         return;
220       }
221
222   /* Try again if we have an outer tag. */
223   for (i=0; data_objects[i].tag; i++)
224     if (data_objects[i].tag == tag && data_objects[i].get_from
225         && data_objects[i].get_from != tag)
226       flush_cache_item (app, data_objects[i].get_from);
227 }
228
229 /* Flush all entries from the cache which might be out of sync after
230    an error. */
231 static void
232 flush_cache_after_error (app_t app)
233 {
234   int i;
235
236   for (i=0; data_objects[i].tag; i++)
237     if (data_objects[i].flush_on_error)
238       flush_cache_item (app, data_objects[i].tag);
239 }
240
241
242 /* Flush the entire cache. */
243 static void
244 flush_cache (app_t app)
245 {
246   if (app && app->app_local)
247     {
248       struct cache_s *c, *c2;
249
250       for (c = app->app_local->cache; c; c = c2)
251         {
252           c2 = c->next;
253           xfree (c);
254         }
255       app->app_local->cache = NULL;
256     }
257 }
258
259
260 /* Get the DO identified by TAG from the card in SLOT and return a
261    buffer with its content in RESULT and NBYTES.  The return value is
262    NULL if not found or a pointer which must be used to release the
263    buffer holding value. */
264 static void *
265 get_one_do (app_t app, int tag, unsigned char **result, size_t *nbytes)
266 {
267   int rc, i;
268   unsigned char *buffer;
269   size_t buflen;
270   unsigned char *value;
271   size_t valuelen;
272
273   *result = NULL;
274   *nbytes = 0;
275   for (i=0; data_objects[i].tag && data_objects[i].tag != tag; i++)
276     ;
277
278   if (app->card_version > 0x0100 && data_objects[i].get_immediate_in_v11)
279     {
280       if( iso7816_get_data (app->slot, tag, &buffer, &buflen))
281         return NULL;
282       *result = buffer;
283       *nbytes = buflen;
284       return buffer;
285     }
286
287   value = NULL;
288   rc = -1;
289   if (data_objects[i].tag && data_objects[i].get_from)
290     {
291       rc = get_cached_data (app, data_objects[i].get_from,
292                             &buffer, &buflen);
293       if (!rc)
294         {
295           const unsigned char *s;
296
297           s = find_tlv (buffer, buflen, tag, &valuelen);
298           if (!s)
299             value = NULL; /* not found */
300           else if (valuelen > buflen - (s - buffer))
301             {
302               log_error ("warning: constructed DO too short\n");
303               value = NULL;
304               xfree (buffer); buffer = NULL;
305             }
306           else
307             value = buffer + (s - buffer);
308         }
309     }
310
311   if (!value) /* Not in a constructed DO, try simple. */
312     {
313       rc = get_cached_data (app, tag, &buffer, &buflen);
314       if (!rc)
315         {
316           value = buffer;
317           valuelen = buflen;
318         }
319     }
320
321   if (!rc)
322     {
323       *nbytes = valuelen;
324       *result = value;
325       return buffer;
326     }
327   return NULL;
328 }
329
330
331 static void
332 dump_all_do (int slot)
333 {
334   int rc, i, j;
335   unsigned char *buffer;
336   size_t buflen;
337   
338   for (i=0; data_objects[i].tag; i++)
339     {
340       if (data_objects[i].get_from)
341         continue;
342
343       rc = iso7816_get_data (slot, data_objects[i].tag, &buffer, &buflen);
344       if (gpg_err_code (rc) == GPG_ERR_NO_OBJ)
345         ;
346       else if (rc) 
347         log_info ("DO `%s' not available: %s\n",
348                   data_objects[i].desc, gpg_strerror (rc));
349       else
350         {
351           if (data_objects[i].binary)
352             {
353               log_info ("DO `%s': ", data_objects[i].desc);
354               log_printhex ("", buffer, buflen);
355             }
356           else
357             log_info ("DO `%s': `%.*s'\n",
358                       data_objects[i].desc,
359                       (int)buflen, buffer); /* FIXME: sanitize */
360
361           if (data_objects[i].constructed)
362             {
363               for (j=0; data_objects[j].tag; j++)
364                 {
365                   const unsigned char *value;
366                   size_t valuelen;
367                   
368                   if (j==i || data_objects[i].tag != data_objects[j].get_from)
369                     continue;
370                   value = find_tlv (buffer, buflen,
371                                     data_objects[j].tag, &valuelen);
372                   if (!value)
373                     ; /* not found */
374                   else if (valuelen > buflen - (value - buffer))
375                     log_error ("warning: constructed DO too short\n");
376                   else
377                     {
378                       if (data_objects[j].binary)
379                         {
380                           log_info ("DO `%s': ", data_objects[j].desc);
381                           log_printhex ("", value, valuelen);
382                         }
383                       else
384                         log_info ("DO `%s': `%.*s'\n",
385                                   data_objects[j].desc,
386                                   (int)valuelen, value); /* FIXME: sanitize */
387                     }
388                 }
389             }
390         }
391       xfree (buffer); buffer = NULL;
392     }
393 }
394
395
396 /* Count the number of bits, assuming the A represents an unsigned big
397    integer of length LEN bytes. */
398 static unsigned int
399 count_bits (const unsigned char *a, size_t len)
400 {
401   unsigned int n = len * 8;
402   int i;
403
404   for (; len && !*a; len--, a++, n -=8)
405     ;
406   if (len)
407     {
408       for (i=7; i && !(*a & (1<<i)); i--)
409         n--;
410     }
411   return n;
412 }
413
414 /* Note, that FPR must be at least 20 bytes. */
415 static int 
416 store_fpr (int slot, int keynumber, u32 timestamp,
417            const unsigned char *m, size_t mlen,
418            const unsigned char *e, size_t elen, 
419            unsigned char *fpr, unsigned int card_version)
420 {
421   unsigned int n, nbits;
422   unsigned char *buffer, *p;
423   int rc;
424   
425   for (; mlen && !*m; mlen--, m++) /* strip leading zeroes */
426     ;
427   for (; elen && !*e; elen--, e++) /* strip leading zeroes */
428     ;
429
430   n = 6 + 2 + mlen + 2 + elen;
431   p = buffer = xtrymalloc (3 + n);
432   if (!buffer)
433     return gpg_error (gpg_err_code_from_errno (errno));
434   
435   *p++ = 0x99;     /* ctb */
436   *p++ = n >> 8;   /* 2 byte length header */
437   *p++ = n;
438   *p++ = 4;        /* key packet version */
439   *p++ = timestamp >> 24;
440   *p++ = timestamp >> 16;
441   *p++ = timestamp >>  8;
442   *p++ = timestamp;
443   *p++ = 1; /* RSA */
444   nbits = count_bits (m, mlen);
445   *p++ = nbits >> 8;
446   *p++ = nbits;
447   memcpy (p, m, mlen); p += mlen;
448   nbits = count_bits (e, elen);
449   *p++ = nbits >> 8;
450   *p++ = nbits;
451   memcpy (p, e, elen); p += elen;
452     
453   gcry_md_hash_buffer (GCRY_MD_SHA1, fpr, buffer, n+3);
454
455   xfree (buffer);
456
457   rc = iso7816_put_data (slot, (card_version > 0x0007? 0xC7 : 0xC6)
458                                + keynumber, fpr, 20);
459   if (rc)
460     log_error (_("failed to store the fingerprint: %s\n"),gpg_strerror (rc));
461
462   if (!rc && card_version > 0x0100)
463     {
464       unsigned char buf[4];
465
466       buf[0] = timestamp >> 24;
467       buf[1] = timestamp >> 16;
468       buf[2] = timestamp >>  8;
469       buf[3] = timestamp;
470
471       rc = iso7816_put_data (slot, 0xCE + keynumber, buf, 4);
472       if (rc)
473         log_error (_("failed to store the creation date: %s\n"),
474                    gpg_strerror (rc));
475     }
476
477   return rc;
478 }
479
480        
481 static void
482 send_fpr_if_not_null (CTRL ctrl, const char *keyword,
483                       int number, const unsigned char *fpr)
484 {                      
485   int i;
486   char buf[41];
487   char numbuf[25];
488
489   for (i=0; i < 20 && !fpr[i]; i++)
490     ;
491   if (i==20)
492     return; /* All zero. */
493   for (i=0; i< 20; i++)
494     sprintf (buf+2*i, "%02X", fpr[i]);
495   if (number == -1)
496     *numbuf = 0; /* Don't print the key number */
497   else
498     sprintf (numbuf, "%d", number);
499   send_status_info (ctrl, keyword,
500                     numbuf, (size_t)strlen(numbuf),
501                     buf, (size_t)strlen (buf), NULL, 0);
502 }
503
504 static void
505 send_key_data (CTRL ctrl, const char *name, 
506                const unsigned char *a, size_t alen)
507 {
508   char *p, *buf = xmalloc (alen*2+1);
509   
510   for (p=buf; alen; a++, alen--, p += 2)
511     sprintf (p, "%02X", *a);
512
513   send_status_info (ctrl, "KEY-DATA",
514                     name, (size_t)strlen(name), 
515                     buf, (size_t)strlen (buf),
516                     NULL, 0);
517   xfree (buf);
518 }
519
520 /* Implement the GETATTR command.  This is similar to the LEARN
521    command but returns just one value via the status interface. */
522 static int 
523 do_getattr (APP app, CTRL ctrl, const char *name)
524 {
525   static struct {
526     const char *name;
527     int tag;
528     int special;
529   } table[] = {
530     { "DISP-NAME",    0x005B },
531     { "LOGIN-DATA",   0x005E },
532     { "DISP-LANG",    0x5F2D },
533     { "DISP-SEX",     0x5F35 },
534     { "PUBKEY-URL",   0x5F50 },
535     { "KEY-FPR",      0x00C5, 3 },
536     { "CA-FPR",       0x00C6, 3 },
537     { "CHV-STATUS",   0x00C4, 1 },
538     { "SIG-COUNTER",  0x0093, 2 },
539     { "SERIALNO",     0x004F, -1 },
540     { "AID",          0x004F },
541     { "EXTCAP",       0x0000, -2 },
542     { NULL, 0 }
543   };
544   int idx, i;
545   void *relptr;
546   unsigned char *value;
547   size_t valuelen;
548
549   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
550     ;
551   if (!table[idx].name)
552     return gpg_error (GPG_ERR_INV_NAME); 
553   
554   if (table[idx].special == -1)
555     {
556       /* The serial number is very special.  We could have used the
557          AID DO to retrieve it, but we have it already in the app
558          context and the stamp argument is required anyway which we
559          can't by other means. The AID DO is available anyway but not
560          hex formatted. */
561       char *serial;
562       time_t stamp;
563       char tmp[50];
564
565       if (!app_get_serial_and_stamp (app, &serial, &stamp))
566         {
567           sprintf (tmp, "%lu", (unsigned long)stamp);
568           send_status_info (ctrl, "SERIALNO",
569                             serial, strlen (serial),
570                             tmp, strlen (tmp),
571                             NULL, 0);
572           xfree (serial);
573         }
574       return 0;
575     }
576   if (table[idx].special == -2)
577     {
578       char tmp[50];
579
580       sprintf (tmp, "gc=%d ki=%d fc=%d pd=%d", 
581                app->app_local->extcap.get_challenge,
582                app->app_local->extcap.key_import,
583                app->app_local->extcap.change_force_chv,
584                app->app_local->extcap.private_dos);
585       send_status_info (ctrl, table[idx].name, tmp, strlen (tmp), NULL, 0);
586       return 0;
587     }
588
589   relptr = get_one_do (app, table[idx].tag, &value, &valuelen);
590   if (relptr)
591     {
592       if (table[idx].special == 1)
593         {
594           char numbuf[7*23];
595           
596           for (i=0,*numbuf=0; i < valuelen && i < 7; i++)
597             sprintf (numbuf+strlen (numbuf), " %d", value[i]); 
598           send_status_info (ctrl, table[idx].name,
599                             numbuf, strlen (numbuf), NULL, 0);
600         }
601       else if (table[idx].special == 2)
602         {
603           char numbuf[50];
604
605           sprintf (numbuf, "%lu", convert_sig_counter_value (value, valuelen));
606           send_status_info (ctrl, table[idx].name,
607                             numbuf, strlen (numbuf), NULL, 0);
608         }
609       else if (table[idx].special == 3)
610         {
611           if (valuelen >= 60)
612             for (i=0; i < 3; i++)
613               send_fpr_if_not_null (ctrl, table[idx].name, i+1, value+i*20);
614         }
615       else
616         send_status_info (ctrl, table[idx].name, value, valuelen, NULL, 0);
617
618       xfree (relptr);
619     }
620   return 0;
621 }
622
623
624 static int
625 do_learn_status (APP app, CTRL ctrl)
626 {
627   do_getattr (app, ctrl, "EXTCAP");
628   do_getattr (app, ctrl, "DISP-NAME");
629   do_getattr (app, ctrl, "DISP-LANG");
630   do_getattr (app, ctrl, "DISP-SEX");
631   do_getattr (app, ctrl, "PUBKEY-URL");
632   do_getattr (app, ctrl, "LOGIN-DATA");
633   do_getattr (app, ctrl, "KEY-FPR");
634   do_getattr (app, ctrl, "CA-FPR");
635   do_getattr (app, ctrl, "CHV-STATUS");
636   do_getattr (app, ctrl, "SIG-COUNTER");
637
638   return 0;
639 }
640
641
642 /* Verify CHV2 if required.  Depending on the configuration of the
643    card CHV1 will also be verified. */
644 static int
645 verify_chv2 (app_t app,
646              int (*pincb)(void*, const char *, char **),
647              void *pincb_arg)
648 {
649   int rc = 0;
650
651   if (!app->did_chv2) 
652     {
653       char *pinvalue;
654
655       rc = pincb (pincb_arg, "PIN", &pinvalue); 
656       if (rc)
657         {
658           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
659           return rc;
660         }
661
662       if (strlen (pinvalue) < 6)
663         {
664           log_error (_("prassphrase (CHV%d) is too short;"
665                        " minimum length is %d\n"), 2, 6);
666           xfree (pinvalue);
667           return gpg_error (GPG_ERR_BAD_PIN);
668         }
669
670       rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
671       if (rc)
672         {
673           log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
674           xfree (pinvalue);
675           flush_cache_after_error (app);
676           return rc;
677         }
678       app->did_chv2 = 1;
679
680       if (!app->did_chv1 && !app->force_chv1)
681         {
682           rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
683           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
684             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
685           if (rc)
686             {
687               log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
688               xfree (pinvalue);
689               flush_cache_after_error (app);
690               return rc;
691             }
692           app->did_chv1 = 1;
693         }
694       xfree (pinvalue);
695     }
696   return rc;
697 }
698
699 /* Verify CHV3 if required. */
700 static int
701 verify_chv3 (APP app,
702              int (*pincb)(void*, const char *, char **),
703              void *pincb_arg)
704 {
705   int rc = 0;
706
707 #if GNUPG_MAJOR_VERSION != 1
708   if (!opt.allow_admin)
709     {
710       log_info (_("access to admin commands is not configured\n"));
711       return gpg_error (GPG_ERR_EACCES);
712     }
713 #endif
714       
715   if (!app->did_chv3) 
716     {
717       char *pinvalue;
718       void *relptr;
719       unsigned char *value;
720       size_t valuelen;
721       int reread_chv_status;
722       
723
724       relptr = get_one_do (app, 0x00C4, &value, &valuelen);
725       if (!relptr || valuelen < 7)
726         {
727           log_error (_("error retrieving CHV status from card\n"));
728           xfree (relptr);
729           return gpg_error (GPG_ERR_CARD);
730         }
731       if (value[6] == 0)
732         {
733           log_info (_("card is permanently locked!\n"));
734           xfree (relptr);
735           return gpg_error (GPG_ERR_BAD_PIN);
736         }
737
738       reread_chv_status = (value[6] < 3);
739
740       log_info(_("%d Admin PIN attempts remaining before card"
741                  " is permanently locked\n"), value[6]);
742       xfree (relptr);
743
744       rc = pincb (pincb_arg, _("Admin PIN"), &pinvalue); 
745       if (rc)
746         {
747           log_info (_("PIN callback returned error: %s\n"), gpg_strerror (rc));
748           return rc;
749         }
750
751       if (strlen (pinvalue) < 6)
752         {
753           log_error (_("prassphrase (CHV%d) is too short;"
754                        " minimum length is %d\n"), 3, 6);
755           xfree (pinvalue);
756           return gpg_error (GPG_ERR_BAD_PIN);
757         }
758
759       rc = iso7816_verify (app->slot, 0x83, pinvalue, strlen (pinvalue));
760       xfree (pinvalue);
761       if (rc)
762         {
763           log_error (_("verify CHV%d failed: %s\n"), 3, gpg_strerror (rc));
764           flush_cache_after_error (app);
765           return rc;
766         }
767       app->did_chv3 = 1;
768       /* If the PIN has been entered wrongly before, we need to flush
769          the cached value so that the next read correctly reflects the
770          resetted retry counter.  Note that version 1.1 of the specs
771          allow direct reading of that DO, so that we could actually
772          flush it in all cases. */
773       if (reread_chv_status)
774         flush_cache_item (app, 0x00C4);
775     }
776   return rc;
777 }
778
779
780 /* Handle the SETATTR operation. All arguments are already basically
781    checked. */
782 static int 
783 do_setattr (APP app, const char *name,
784             int (*pincb)(void*, const char *, char **),
785             void *pincb_arg,
786             const unsigned char *value, size_t valuelen)
787 {
788   gpg_error_t rc;
789   int idx;
790   static struct {
791     const char *name;
792     int tag;
793     int special;
794   } table[] = {
795     { "DISP-NAME",    0x005B },
796     { "LOGIN-DATA",   0x005E },
797     { "DISP-LANG",    0x5F2D },
798     { "DISP-SEX",     0x5F35 },
799     { "PUBKEY-URL",   0x5F50 },
800     { "CHV-STATUS-1", 0x00C4, 1 },
801     { "CA-FPR-1",     0x00CA },
802     { "CA-FPR-2",     0x00CB },
803     { "CA-FPR-3",     0x00CC },
804     { NULL, 0 }
805   };
806
807
808   for (idx=0; table[idx].name && strcmp (table[idx].name, name); idx++)
809     ;
810   if (!table[idx].name)
811     return gpg_error (GPG_ERR_INV_NAME); 
812
813   rc = verify_chv3 (app, pincb, pincb_arg);
814   if (rc)
815     return rc;
816
817   /* Flush the cache before writing it, so that the next get operation
818      will reread the data from the card and thus get synced in case of
819      errors (e.g. data truncated by the card). */
820   flush_cache_item (app, table[idx].tag);
821   rc = iso7816_put_data (app->slot, table[idx].tag, value, valuelen);
822   if (rc)
823     log_error ("failed to set `%s': %s\n", table[idx].name, gpg_strerror (rc));
824
825   if (table[idx].special == 1)
826     app->force_chv1 = (valuelen && *value == 0);
827
828   return rc;
829 }
830
831
832 /* Handle the PASSWD command. */
833 static int 
834 do_change_pin (APP app, CTRL ctrl,  const char *chvnostr, int reset_mode,
835                int (*pincb)(void*, const char *, char **),
836                void *pincb_arg)
837 {
838   int rc = 0;
839   int chvno = atoi (chvnostr);
840   char *pinvalue;
841
842   if (reset_mode && chvno == 3)
843     {
844       rc = gpg_error (GPG_ERR_INV_ID);
845       goto leave;
846     }
847   else if (reset_mode || chvno == 3)
848     {
849       /* we always require that the PIN is entered. */
850       app->did_chv3 = 0;
851       rc = verify_chv3 (app, pincb, pincb_arg);
852       if (rc)
853         goto leave;
854     }
855   else if (chvno == 1 || chvno == 2)
856     {
857       /* CHV1 and CVH2 should always have the same value, thus we
858          enforce it here.  */
859       int save_force = app->force_chv1;
860
861       app->force_chv1 = 0;
862       app->did_chv1 = 0;
863       app->did_chv2 = 0;
864       rc = verify_chv2 (app, pincb, pincb_arg);
865       app->force_chv1 = save_force;
866       if (rc)
867         goto leave;
868     }
869   else
870     {
871       rc = gpg_error (GPG_ERR_INV_ID);
872       goto leave;
873     }
874
875   if (chvno == 3)
876     app->did_chv3 = 0;
877   else
878     app->did_chv1 = app->did_chv2 = 0;
879
880   rc = pincb (pincb_arg, chvno == 3? "New Admin PIN" : "New PIN", &pinvalue); 
881   if (rc)
882     {
883       log_error ("error getting new PIN: %s\n", gpg_strerror (rc));
884       goto leave;
885     }
886
887   if (reset_mode)
888     {
889       rc = iso7816_reset_retry_counter (app->slot, 0x81,
890                                         pinvalue, strlen (pinvalue));
891       if (!rc)
892         rc = iso7816_reset_retry_counter (app->slot, 0x82,
893                                           pinvalue, strlen (pinvalue));
894     }
895   else
896     {
897       if (chvno == 1 || chvno == 2)
898         {
899           rc = iso7816_change_reference_data (app->slot, 0x81, NULL, 0,
900                                               pinvalue, strlen (pinvalue));
901           if (!rc)
902             rc = iso7816_change_reference_data (app->slot, 0x82, NULL, 0,
903                                                 pinvalue, strlen (pinvalue));
904         }
905       else
906         rc = iso7816_change_reference_data (app->slot, 0x80 + chvno, NULL, 0,
907                                             pinvalue, strlen (pinvalue));
908     }
909   xfree (pinvalue);
910   if (rc)
911     flush_cache_after_error (app);
912
913  leave:
914   return rc;
915 }
916
917
918
919 /* Handle the GENKEY command. */
920 static int 
921 do_genkey (APP app, CTRL ctrl,  const char *keynostr, unsigned int flags,
922           int (*pincb)(void*, const char *, char **),
923           void *pincb_arg)
924 {
925   int rc;
926   int i;
927   char numbuf[30];
928   unsigned char fprbuf[20];
929   const unsigned char *fpr;
930   const unsigned char *keydata, *m, *e;
931   unsigned char *buffer;
932   size_t buflen, keydatalen, n, mlen, elen;
933   time_t created_at;
934   int keyno = atoi (keynostr);
935   int force = (flags & 1);
936   time_t start_at;
937
938   if (keyno < 1 || keyno > 3)
939     return gpg_error (GPG_ERR_INV_ID);
940   keyno--;
941
942   /* We flush the cache to increase the traffic before a key
943      generation.  This _might_ help a card to gather more entropy. */
944   flush_cache (app);
945
946   rc = iso7816_get_data (app->slot, 0x006E, &buffer, &buflen);
947   if (rc)
948     {
949       log_error ("error reading application data\n");
950       return gpg_error (GPG_ERR_GENERAL);
951     }
952   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
953   if (!fpr || n != 60)
954     {
955       rc = gpg_error (GPG_ERR_GENERAL);
956       log_error ("error reading fingerprint DO\n");
957       goto leave;
958     }
959   fpr += 20*keyno;
960   for (i=0; i < 20 && !fpr[i]; i++)
961     ;
962   if (i!=20 && !force)
963     {
964       rc = gpg_error (GPG_ERR_EEXIST);
965       log_error ("key already exists\n");
966       goto leave;
967     }
968   else if (i!=20)
969     log_info ("existing key will be replaced\n");
970   else
971     log_info ("generating new key\n");
972
973
974   rc = verify_chv3 (app, pincb, pincb_arg);
975   if (rc)
976     goto leave;
977
978   xfree (buffer); buffer = NULL;
979
980 #if 1
981   log_info ("please wait while key is being generated ...\n");
982   start_at = time (NULL);
983   rc = iso7816_generate_keypair 
984 #else
985 #warning key generation temporary replaced by reading an existing key.
986   rc = iso7816_read_public_key
987 #endif
988                               (app->slot, 
989                                  keyno == 0? "\xB6" :
990                                  keyno == 1? "\xB8" : "\xA4",
991                                  2,
992                                  &buffer, &buflen);
993   if (rc)
994     {
995       rc = gpg_error (GPG_ERR_CARD);
996       log_error ("generating key failed\n");
997       goto leave;
998     }
999   log_info ("key generation completed (%d seconds)\n",
1000             (int)(time (NULL) - start_at));
1001   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1002   if (!keydata)
1003     {
1004       rc = gpg_error (GPG_ERR_CARD);
1005       log_error ("response does not contain the public key data\n");
1006       goto leave;
1007     }
1008  
1009   m = find_tlv (keydata, keydatalen, 0x0081, &mlen);
1010   if (!m)
1011     {
1012       rc = gpg_error (GPG_ERR_CARD);
1013       log_error ("response does not contain the RSA modulus\n");
1014       goto leave;
1015     }
1016 /*    log_printhex ("RSA n:", m, mlen); */
1017   send_key_data (ctrl, "n", m, mlen);
1018
1019   e = find_tlv (keydata, keydatalen, 0x0082, &elen);
1020   if (!e)
1021     {
1022       rc = gpg_error (GPG_ERR_CARD);
1023       log_error ("response does not contain the RSA public exponent\n");
1024       goto leave;
1025     }
1026 /*    log_printhex ("RSA e:", e, elen); */
1027   send_key_data (ctrl, "e", e, elen);
1028
1029   created_at = gnupg_get_time ();
1030   sprintf (numbuf, "%lu", (unsigned long)created_at);
1031   send_status_info (ctrl, "KEY-CREATED-AT",
1032                     numbuf, (size_t)strlen(numbuf), NULL, 0);
1033
1034   rc = store_fpr (app->slot, keyno, (u32)created_at,
1035                   m, mlen, e, elen, fprbuf, app->card_version);
1036   if (rc)
1037     goto leave;
1038   send_fpr_if_not_null (ctrl, "KEY-FPR", -1, fprbuf);
1039
1040
1041  leave:
1042   xfree (buffer);
1043   return rc;
1044 }
1045
1046
1047 static unsigned long
1048 convert_sig_counter_value (const unsigned char *value, size_t valuelen)
1049 {
1050   unsigned long ul;
1051
1052   if (valuelen == 3 )
1053     ul = (value[0] << 16) | (value[1] << 8) | value[2];
1054   else
1055     {
1056       log_error ("invalid structure of OpenPGP card (DO 0x93)\n");
1057       ul = 0;
1058     }
1059   return ul;
1060 }
1061
1062 static unsigned long
1063 get_sig_counter (APP app)
1064 {
1065   void *relptr;
1066   unsigned char *value;
1067   size_t valuelen;
1068   unsigned long ul;
1069
1070   relptr = get_one_do (app, 0x0093, &value, &valuelen);
1071   if (!relptr)
1072     return 0;
1073   ul = convert_sig_counter_value (value, valuelen);
1074   xfree (relptr);
1075   return ul;
1076 }
1077
1078 static int
1079 compare_fingerprint (APP app, int keyno, unsigned char *sha1fpr)
1080 {
1081   const unsigned char *fpr;
1082   unsigned char *buffer;
1083   size_t buflen, n;
1084   int rc, i;
1085   
1086   assert (keyno >= 1 && keyno <= 3);
1087
1088   rc = get_cached_data (app, 0x006E, &buffer, &buflen);
1089   if (rc)
1090     {
1091       log_error ("error reading application data\n");
1092       return gpg_error (GPG_ERR_GENERAL);
1093     }
1094   fpr = find_tlv (buffer, buflen, 0x00C5, &n);
1095   if (!fpr || n != 60)
1096     {
1097       xfree (buffer);
1098       log_error ("error reading fingerprint DO\n");
1099       return gpg_error (GPG_ERR_GENERAL);
1100     }
1101   fpr += (keyno-1)*20;
1102   for (i=0; i < 20; i++)
1103     if (sha1fpr[i] != fpr[i])
1104       {
1105         xfree (buffer);
1106         return gpg_error (GPG_ERR_WRONG_SECKEY);
1107       }
1108   xfree (buffer);
1109   return 0;
1110 }
1111
1112
1113   /* If a fingerprint has been specified check it against the one on
1114      the card.  This is allows for a meaningful error message in case
1115      the key on the card has been replaced but the shadow information
1116      known to gpg was not updated.  If there is no fingerprint we
1117      assume that this is okay. */
1118 static int
1119 check_against_given_fingerprint (APP app, const char *fpr, int keyno)
1120 {
1121   unsigned char tmp[20];
1122   const char *s;
1123   int n;
1124
1125   for (s=fpr, n=0; hexdigitp (s); s++, n++)
1126     ;
1127   if (n != 40)
1128     return gpg_error (GPG_ERR_INV_ID);
1129   else if (!*s)
1130     ; /* okay */
1131   else
1132     return gpg_error (GPG_ERR_INV_ID);
1133
1134   for (s=fpr, n=0; n < 20; s += 2, n++)
1135         tmp[n] = xtoi_2 (s);
1136   return compare_fingerprint (app, keyno, tmp);
1137 }
1138
1139
1140
1141 /* Compute a digital signature on INDATA which is expected to be the
1142    raw message digest. For this application the KEYIDSTR consists of
1143    the serialnumber and the fingerprint delimited by a slash.
1144
1145    Note that this fucntion may return the error code
1146    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1147    not match the one required for the requested action (e.g. the
1148    serial number does not match). */
1149 static int 
1150 do_sign (APP app, const char *keyidstr, int hashalgo,
1151          int (*pincb)(void*, const char *, char **),
1152          void *pincb_arg,
1153          const void *indata, size_t indatalen,
1154          unsigned char **outdata, size_t *outdatalen )
1155 {
1156   static unsigned char sha1_prefix[15] = /* Object ID is 1.3.14.3.2.26 */
1157   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03,
1158     0x02, 0x1a, 0x05, 0x00, 0x04, 0x14 };
1159   static unsigned char rmd160_prefix[15] = /* Object ID is 1.3.36.3.2.1 */
1160   { 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x24, 0x03,
1161     0x02, 0x01, 0x05, 0x00, 0x04, 0x14 };
1162   int rc;
1163   unsigned char data[35];
1164   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1165   const char *s;
1166   int n;
1167   const char *fpr = NULL;
1168   unsigned long sigcount;
1169
1170   if (!keyidstr || !*keyidstr)
1171     return gpg_error (GPG_ERR_INV_VALUE);
1172   if (indatalen != 20)
1173     return gpg_error (GPG_ERR_INV_VALUE);
1174
1175   /* Check whether an OpenPGP card of any version has been requested. */
1176   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1177     return gpg_error (GPG_ERR_INV_ID);
1178   
1179   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1180     ;
1181   if (n != 32)
1182     return gpg_error (GPG_ERR_INV_ID);
1183   else if (!*s)
1184     ; /* no fingerprint given: we allow this for now. */
1185   else if (*s == '/')
1186     fpr = s + 1; 
1187   else
1188     return gpg_error (GPG_ERR_INV_ID);
1189
1190   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1191     tmp_sn[n] = xtoi_2 (s);
1192
1193   if (app->serialnolen != 16)
1194     return gpg_error (GPG_ERR_INV_CARD);
1195   if (memcmp (app->serialno, tmp_sn, 16))
1196     return gpg_error (GPG_ERR_WRONG_CARD);
1197
1198   /* If a fingerprint has been specified check it against the one on
1199      the card.  This is allows for a meaningful error message in case
1200      the key on the card has been replaced but the shadow information
1201      known to gpg was not updated.  If there is no fingerprint, gpg
1202      will detect a bogus signature anyway due to the
1203      verify-after-signing feature. */
1204   rc = fpr? check_against_given_fingerprint (app, fpr, 1) : 0;
1205   if (rc)
1206     return rc;
1207
1208   if (hashalgo == GCRY_MD_SHA1)
1209     memcpy (data, sha1_prefix, 15);
1210   else if (hashalgo == GCRY_MD_RMD160)
1211     memcpy (data, rmd160_prefix, 15);
1212   else 
1213     return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
1214   memcpy (data+15, indata, indatalen);
1215
1216   sigcount = get_sig_counter (app);
1217   log_info ("signatures created so far: %lu\n", sigcount);
1218
1219   if (!app->did_chv1 || app->force_chv1 ) 
1220     {
1221       char *pinvalue;
1222
1223       {
1224         char *prompt;
1225         if (asprintf (&prompt, "PIN [sigs done: %lu]", sigcount) < 0)
1226           return gpg_error_from_errno (errno);
1227         rc = pincb (pincb_arg, prompt, &pinvalue); 
1228         free (prompt);
1229       }
1230       if (rc)
1231         {
1232           log_info ("PIN callback returned error: %s\n", gpg_strerror (rc));
1233           return rc;
1234         }
1235
1236       if (strlen (pinvalue) < 6)
1237         {
1238           log_error (_("prassphrase (CHV%d) is too short;"
1239                        " minimum length is %d\n"), 1, 6);
1240           xfree (pinvalue);
1241           return gpg_error (GPG_ERR_BAD_PIN);
1242         }
1243
1244       rc = iso7816_verify (app->slot, 0x81, pinvalue, strlen (pinvalue));
1245       if (rc)
1246         {
1247           log_error (_("verify CHV%d failed: %s\n"), 1, gpg_strerror (rc));
1248           xfree (pinvalue);
1249           flush_cache_after_error (app);
1250           return rc;
1251         }
1252       app->did_chv1 = 1;
1253       if (!app->did_chv2)
1254         {
1255           /* We should also verify CHV2. */
1256           rc = iso7816_verify (app->slot, 0x82, pinvalue, strlen (pinvalue));
1257           if (gpg_err_code (rc) == GPG_ERR_BAD_PIN)
1258             rc = gpg_error (GPG_ERR_PIN_NOT_SYNCED);
1259           if (rc)
1260             {
1261               log_error (_("verify CHV%d failed: %s\n"), 2, gpg_strerror (rc));
1262               xfree (pinvalue);
1263               flush_cache_after_error (app);
1264               return rc;
1265             }
1266           app->did_chv2 = 1;
1267         }
1268       xfree (pinvalue);
1269     }
1270
1271   rc = iso7816_compute_ds (app->slot, data, 35, outdata, outdatalen);
1272   return rc;
1273 }
1274
1275 /* Compute a digital signature using the INTERNAL AUTHENTICATE command
1276    on INDATA which is expected to be the raw message digest. For this
1277    application the KEYIDSTR consists of the serialnumber and the
1278    fingerprint delimited by a slash.
1279
1280    Note that this fucntion may return the error code
1281    GPG_ERR_WRONG_CARD to indicate that the card currently present does
1282    not match the one required for the requested action (e.g. the
1283    serial number does not match). */
1284 static int 
1285 do_auth (APP app, const char *keyidstr,
1286          int (*pincb)(void*, const char *, char **),
1287          void *pincb_arg,
1288          const void *indata, size_t indatalen,
1289          unsigned char **outdata, size_t *outdatalen )
1290 {
1291   int rc;
1292   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1293   const char *s;
1294   int n;
1295   const char *fpr = NULL;
1296
1297   if (!keyidstr || !*keyidstr)
1298     return gpg_error (GPG_ERR_INV_VALUE);
1299   if (indatalen > 50) /* For a 1024 bit key. */
1300     return gpg_error (GPG_ERR_INV_VALUE);
1301
1302   /* Check whether an OpenPGP card of any version has been requested. */
1303   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1304     return gpg_error (GPG_ERR_INV_ID);
1305   
1306   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1307     ;
1308   if (n != 32)
1309     return gpg_error (GPG_ERR_INV_ID);
1310   else if (!*s)
1311     ; /* no fingerprint given: we allow this for now. */
1312   else if (*s == '/')
1313     fpr = s + 1; 
1314   else
1315     return gpg_error (GPG_ERR_INV_ID);
1316
1317   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1318     tmp_sn[n] = xtoi_2 (s);
1319
1320   if (app->serialnolen != 16)
1321     return gpg_error (GPG_ERR_INV_CARD);
1322   if (memcmp (app->serialno, tmp_sn, 16))
1323     return gpg_error (GPG_ERR_WRONG_CARD);
1324
1325   /* If a fingerprint has been specified check it against the one on
1326      the card.  This is allows for a meaningful error message in case
1327      the key on the card has been replaced but the shadow information
1328      known to gpg was not updated.  If there is no fingerprint, gpg
1329      will detect a bogus signature anyway due to the
1330      verify-after-signing feature. */
1331   rc = fpr? check_against_given_fingerprint (app, fpr, 3) : 0;
1332   if (rc)
1333     return rc;
1334
1335   rc = verify_chv2 (app, pincb, pincb_arg);
1336   if (!rc)
1337     rc = iso7816_internal_authenticate (app->slot, indata, indatalen,
1338                                         outdata, outdatalen);
1339   return rc;
1340 }
1341
1342
1343 static int 
1344 do_decipher (APP app, const char *keyidstr,
1345              int (pincb)(void*, const char *, char **),
1346              void *pincb_arg,
1347              const void *indata, size_t indatalen,
1348              unsigned char **outdata, size_t *outdatalen )
1349 {
1350   int rc;
1351   unsigned char tmp_sn[20]; /* actually 16 but we use it also for the fpr. */
1352   const char *s;
1353   int n;
1354   const char *fpr = NULL;
1355
1356   if (!keyidstr || !*keyidstr || !indatalen)
1357     return gpg_error (GPG_ERR_INV_VALUE);
1358
1359   /* Check whether an OpenPGP card of any version has been requested. */
1360   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1361     return gpg_error (GPG_ERR_INV_ID);
1362   
1363   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1364     ;
1365   if (n != 32)
1366     return gpg_error (GPG_ERR_INV_ID);
1367   else if (!*s)
1368     ; /* no fingerprint given: we allow this for now. */
1369   else if (*s == '/')
1370     fpr = s + 1; 
1371   else
1372     return gpg_error (GPG_ERR_INV_ID);
1373
1374   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1375     tmp_sn[n] = xtoi_2 (s);
1376
1377   if (app->serialnolen != 16)
1378     return gpg_error (GPG_ERR_INV_CARD);
1379   if (memcmp (app->serialno, tmp_sn, 16))
1380     return gpg_error (GPG_ERR_WRONG_CARD);
1381
1382   /* If a fingerprint has been specified check it against the one on
1383      the card.  This is allows for a meaningful error message in case
1384      the key on the card has been replaced but the shadow information
1385      known to gpg was not updated.  If there is no fingerprint, the
1386      decryption will won't produce the right plaintext anyway. */
1387   rc = fpr? check_against_given_fingerprint (app, fpr, 2) : 0;
1388   if (rc)
1389     return rc;
1390
1391   rc = verify_chv2 (app, pincb, pincb_arg);
1392   if (!rc)
1393     rc = iso7816_decipher (app->slot, indata, indatalen, 0,
1394                            outdata, outdatalen);
1395   return rc;
1396 }
1397
1398
1399 /* Perform a simple verify operation for CHV1 and CHV2, so that
1400    further operations won't ask for CHV2 and it is possible to do a
1401    cheap check on the PIN: If there is something wrong with the PIN
1402    entry system, only the regular CHV will get blocked and not the
1403    dangerous CHV3.  KEYIDSTR is the usual card's serial number; an
1404    optional fingerprint part will be ignored. */
1405 static int 
1406 do_check_pin (APP app, const char *keyidstr,
1407               int (pincb)(void*, const char *, char **),
1408               void *pincb_arg)
1409 {
1410   unsigned char tmp_sn[20]; 
1411   const char *s;
1412   int n;
1413
1414   if (!keyidstr || !*keyidstr)
1415     return gpg_error (GPG_ERR_INV_VALUE);
1416
1417   /* Check whether an OpenPGP card of any version has been requested. */
1418   if (strlen (keyidstr) < 32 || strncmp (keyidstr, "D27600012401", 12))
1419     return gpg_error (GPG_ERR_INV_ID);
1420   
1421   for (s=keyidstr, n=0; hexdigitp (s); s++, n++)
1422     ;
1423   if (n != 32)
1424     return gpg_error (GPG_ERR_INV_ID);
1425   else if (!*s)
1426     ; /* No fingerprint given: we allow this for now. */
1427   else if (*s == '/')
1428     ; /* We ignore a fingerprint. */
1429   else
1430     return gpg_error (GPG_ERR_INV_ID);
1431
1432   for (s=keyidstr, n=0; n < 16; s += 2, n++)
1433     tmp_sn[n] = xtoi_2 (s);
1434
1435   if (app->serialnolen != 16)
1436     return gpg_error (GPG_ERR_INV_CARD);
1437   if (memcmp (app->serialno, tmp_sn, 16))
1438     return gpg_error (GPG_ERR_WRONG_CARD);
1439   /* Yes, there is a race conditions: The user might pull the card
1440      right here and we won't notice that.  However this is not a
1441      problem and the check above is merely for a graceful failure
1442      between operations. */
1443
1444   return verify_chv2 (app, pincb, pincb_arg);
1445 }
1446
1447
1448
1449
1450 /* Select the OpenPGP application on the card in SLOT.  This function
1451    must be used before any other OpenPGP application functions. */
1452 int
1453 app_select_openpgp (APP app)
1454 {
1455   static char const aid[] = { 0xD2, 0x76, 0x00, 0x01, 0x24, 0x01 };
1456   int slot = app->slot;
1457   int rc;
1458   unsigned char *buffer;
1459   size_t buflen;
1460   void *relptr;
1461   
1462   rc = iso7816_select_application (slot, aid, sizeof aid);
1463   if (!rc)
1464     {
1465       unsigned int manufacturer;
1466
1467       app->apptype = "OPENPGP";
1468
1469       app->did_chv1 = 0;
1470       app->did_chv2 = 0;
1471       app->did_chv3 = 0;
1472       app->app_local = NULL;
1473
1474       /* The OpenPGP card returns the serial number as part of the
1475          AID; because we prefer to use OpenPGP serial numbers, we
1476          replace a possibly already set one from a EF.GDO with this
1477          one.  Note, that for current OpenPGP cards, no EF.GDO exists
1478          and thus it won't matter at all. */
1479       rc = iso7816_get_data (slot, 0x004F, &buffer, &buflen);
1480       if (rc)
1481         goto leave;
1482       if (opt.verbose)
1483         {
1484           log_info ("AID: ");
1485           log_printhex ("", buffer, buflen);
1486         }
1487
1488       app->card_version = buffer[6] << 8;
1489       app->card_version |= buffer[7];
1490       manufacturer = (buffer[8]<<8 | buffer[9]);
1491
1492       xfree (app->serialno);
1493       app->serialno = buffer;
1494       app->serialnolen = buflen;
1495       buffer = NULL;
1496       app->app_local = xtrycalloc (1, sizeof *app->app_local);
1497       if (!app->app_local)
1498         {
1499           rc = gpg_error (gpg_err_code_from_errno (errno));
1500           goto leave;
1501         }
1502
1503       relptr = get_one_do (app, 0x00C4, &buffer, &buflen);
1504       if (!relptr)
1505         {
1506           log_error (_("can't access CHV Status Bytes "
1507                        "- invalid OpenPGP card?\n"));
1508           goto leave;
1509         }
1510       app->force_chv1 = (buflen && *buffer == 0);
1511       xfree (relptr);
1512
1513       relptr = get_one_do (app, 0x00C0, &buffer, &buflen);
1514       if (!relptr)
1515         {
1516           log_error (_("can't access Extended Capability Flags - "
1517                        "invalid OpenPGP card?\n"));
1518           goto leave;
1519         }
1520       if (buflen)
1521         {
1522           app->app_local->extcap.get_challenge    = !!(*buffer & 0x40);
1523           app->app_local->extcap.key_import       = !!(*buffer & 0x20);
1524           app->app_local->extcap.change_force_chv = !!(*buffer & 0x10);
1525           app->app_local->extcap.private_dos      = !!(*buffer & 0x08);
1526         }
1527       xfree (relptr);
1528       
1529       /* Some of the first cards accidently don't set the
1530          CHANGE_FORCE_CHV bit but allow it anyway. */
1531       if (app->card_version <= 0x0100 && manufacturer == 1)
1532         app->app_local->extcap.change_force_chv = 1;
1533
1534
1535       if (opt.verbose > 1)
1536         dump_all_do (slot);
1537
1538       app->fnc.deinit = do_deinit;
1539       app->fnc.learn_status = do_learn_status;
1540       app->fnc.readcert = NULL;
1541       app->fnc.getattr = do_getattr;
1542       app->fnc.setattr = do_setattr;
1543       app->fnc.genkey = do_genkey;
1544       app->fnc.sign = do_sign;
1545       app->fnc.auth = do_auth;
1546       app->fnc.decipher = do_decipher;
1547       app->fnc.change_pin = do_change_pin;
1548       app->fnc.check_pin = do_check_pin;
1549    }
1550
1551 leave:
1552   if (rc)
1553     do_deinit (app);
1554   return rc;
1555 }
1556
1557
1558
1559 /* This function is a hack to retrieve essential information about the
1560    card to be displayed by simple tools.  It mostly resembles what the
1561    LEARN command returns. All parameters return allocated strings or
1562    buffers or NULL if the data object is not available.  All returned
1563    values are sanitized. */
1564 int
1565 app_openpgp_cardinfo (APP app,
1566                       char **serialno,
1567                       char **disp_name,
1568                       char **pubkey_url,
1569                       unsigned char **fpr1,
1570                       unsigned char **fpr2,
1571                       unsigned char **fpr3)
1572 {
1573   int rc;
1574   void *relptr;
1575   unsigned char *value;
1576   size_t valuelen;
1577
1578   if (serialno)
1579     {
1580       time_t dummy;
1581
1582       *serialno = NULL;
1583       rc = app_get_serial_and_stamp (app, serialno, &dummy);
1584       if (rc)
1585         {
1586           log_error (_("error getting serial number: %s\n"),
1587                      gpg_strerror (rc));
1588           return rc;
1589         }
1590     }
1591       
1592   if (disp_name)
1593     {
1594       *disp_name = NULL;
1595       relptr = get_one_do (app, 0x005B, &value, &valuelen);
1596       if (relptr)
1597         {
1598           *disp_name = make_printable_string (value, valuelen, 0);
1599           xfree (relptr);
1600         }
1601     }
1602
1603   if (pubkey_url)
1604     {
1605       *pubkey_url = NULL;
1606       relptr = get_one_do (app, 0x5F50, &value, &valuelen);
1607       if (relptr)
1608         {
1609           *pubkey_url = make_printable_string (value, valuelen, 0);
1610           xfree (relptr);
1611         }
1612     }
1613
1614   if (fpr1)
1615     *fpr1 = NULL;
1616   if (fpr2)
1617     *fpr2 = NULL;
1618   if (fpr3)
1619     *fpr3 = NULL;
1620   relptr = get_one_do (app, 0x00C5, &value, &valuelen);
1621   if (relptr && valuelen >= 60)
1622     {
1623       if (fpr1)
1624         {
1625           *fpr1 = xmalloc (20);
1626           memcpy (*fpr1, value +  0, 20);
1627         }
1628       if (fpr2)
1629         {
1630           *fpr2 = xmalloc (20);
1631           memcpy (*fpr2, value + 20, 20);
1632         }
1633       if (fpr3)
1634         {
1635           *fpr3 = xmalloc (20);
1636           memcpy (*fpr3, value + 40, 20);
1637         }
1638     }
1639   xfree (relptr);
1640
1641   return 0;
1642 }
1643
1644
1645
1646 /* This function is currently only used by the sc-copykeys program to
1647    store a key on the smartcard.  APP ist the application handle,
1648    KEYNO is the number of the key and PINCB, PINCB_ARG are used to ask
1649    for the SO PIN.  TEMPLATE and TEMPLATE_LEN describe a buffer with
1650    the key template to store. CREATED_AT is the timestamp used to
1651    create the fingerprint. M, MLEN is the RSA modulus and E, ELEN the
1652    RSA public exponent. This function silently overwrites an existing
1653    key.*/
1654 int 
1655 app_openpgp_storekey (APP app, int keyno,
1656                       unsigned char *template, size_t template_len,
1657                       time_t created_at,
1658                       const unsigned char *m, size_t mlen,
1659                       const unsigned char *e, size_t elen,
1660                       int (*pincb)(void*, const char *, char **),
1661                       void *pincb_arg)
1662 {
1663   int rc;
1664   unsigned char fprbuf[20];
1665
1666   if (keyno < 1 || keyno > 3)
1667     return gpg_error (GPG_ERR_INV_ID);
1668   keyno--;
1669
1670   rc = verify_chv3 (app, pincb, pincb_arg);
1671   if (rc)
1672     goto leave;
1673
1674   flush_cache (app);
1675
1676   rc = iso7816_put_data (app->slot,
1677                          (app->card_version > 0x0007? 0xE0 : 0xE9) + keyno,
1678                          template, template_len);
1679   if (rc)
1680     {
1681       log_error (_("failed to store the key: %s\n"), gpg_strerror (rc));
1682       rc = gpg_error (GPG_ERR_CARD);
1683       goto leave;
1684     }
1685  
1686 /*    log_printhex ("RSA n:", m, mlen);  */
1687 /*    log_printhex ("RSA e:", e, elen);  */
1688
1689   rc = store_fpr (app->slot, keyno, (u32)created_at,
1690                   m, mlen, e, elen, fprbuf, app->card_version);
1691
1692  leave:
1693   return rc;
1694 }
1695
1696
1697 /* Utility function for external tools: Read the public RSA key at
1698    KEYNO and return modulus and exponent in (M,MLEN) and (E,ELEN). */
1699 int 
1700 app_openpgp_readkey (APP app, int keyno, unsigned char **m, size_t *mlen,
1701                      unsigned char **e, size_t *elen)
1702 {
1703   int rc;
1704   const unsigned char *keydata, *a;
1705   unsigned char *buffer;
1706   size_t buflen, keydatalen, alen;
1707
1708   *m = NULL;
1709   *e = NULL;
1710
1711   if (keyno < 1 || keyno > 3)
1712     return gpg_error (GPG_ERR_INV_ID);
1713   keyno--;
1714
1715   rc = iso7816_read_public_key(app->slot, 
1716                                keyno == 0? "\xB6" :
1717                                keyno == 1? "\xB8" : "\xA4",
1718                                2,
1719                                &buffer, &buflen);
1720   if (rc)
1721     {
1722       rc = gpg_error (GPG_ERR_CARD);
1723       log_error (_("reading the key failed\n"));
1724       goto leave;
1725     }
1726
1727   keydata = find_tlv (buffer, buflen, 0x7F49, &keydatalen);
1728   if (!keydata)
1729     {
1730       log_error (_("response does not contain the public key data\n"));
1731       rc = gpg_error (GPG_ERR_CARD);
1732       goto leave;
1733     }
1734  
1735   a = find_tlv (keydata, keydatalen, 0x0081, &alen);
1736   if (!a)
1737     {
1738       log_error (_("response does not contain the RSA modulus\n"));
1739       rc = gpg_error (GPG_ERR_CARD);
1740       goto leave;
1741     }
1742   *mlen = alen;
1743   *m = xmalloc (alen);
1744   memcpy (*m, a, alen);
1745   
1746   a = find_tlv (keydata, keydatalen, 0x0082, &alen);
1747   if (!a)
1748     {
1749       log_error (_("response does not contain the RSA public exponent\n"));
1750       rc = gpg_error (GPG_ERR_CARD);
1751       goto leave;
1752     }
1753   *elen = alen;
1754   *e = xmalloc (alen);
1755   memcpy (*e, a, alen);
1756
1757  leave:
1758   xfree (buffer);
1759   if (rc)
1760     { 
1761       xfree (*m); *m = NULL;
1762       xfree (*e); *e = NULL;
1763     }
1764   return rc;
1765 }