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