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