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